drivers/regulator/tps6524x-regulator.c

   1 /*
   2  * Regulator driver for TPS6524x PMIC
   3  *
   4  * Copyright (C) 2010 Texas Instruments
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation version 2.
   9  *
  10  * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
  11  * whether express or implied; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  */
  15
  16 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/err.h>
  19 #include <linux/errno.h>
  20 #include <linux/slab.h>
  21 #include <linux/spi/spi.h>
  22 #include <linux/regulator/driver.h>
  23 #include <linux/regulator/machine.h>
  24
  25 #define REG_LDO_SET             0x0
  26 #define LDO_ILIM_MASK           1       /* 0 = 400-800, 1 = 900-1500 */
  27 #define LDO_VSEL_MASK           0x0f
  28 #define LDO2_ILIM_SHIFT         12
  29 #define LDO2_VSEL_SHIFT         4
  30 #define LDO1_ILIM_SHIFT         8
  31 #define LDO1_VSEL_SHIFT         0
  32
  33 #define REG_BLOCK_EN            0x1
  34 #define BLOCK_MASK              1
  35 #define BLOCK_LDO1_SHIFT        0
  36 #define BLOCK_LDO2_SHIFT        1
  37 #define BLOCK_LCD_SHIFT         2
  38 #define BLOCK_USB_SHIFT         3
  39
  40 #define REG_DCDC_SET            0x2
  41 #define DCDC_VDCDC_MASK         0x1f
  42 #define DCDC_VDCDC1_SHIFT       0
  43 #define DCDC_VDCDC2_SHIFT       5
  44 #define DCDC_VDCDC3_SHIFT       10
  45
  46 #define REG_DCDC_EN             0x3
  47 #define DCDCDCDC_EN_MASK        0x1
  48 #define DCDCDCDC1_EN_SHIFT      0
  49 #define DCDCDCDC1_PG_MSK        BIT(1)
  50 #define DCDCDCDC2_EN_SHIFT      2
  51 #define DCDCDCDC2_PG_MSK        BIT(3)
  52 #define DCDCDCDC3_EN_SHIFT      4
  53 #define DCDCDCDC3_PG_MSK        BIT(5)
  54
  55 #define REG_USB                 0x4
  56 #define USB_ILIM_SHIFT          0
  57 #define USB_ILIM_MASK           0x3
  58 #define USB_TSD_SHIFT           2
  59 #define USB_TSD_MASK            0x3
  60 #define USB_TWARN_SHIFT         4
  61 #define USB_TWARN_MASK          0x3
  62 #define USB_IWARN_SD            BIT(6)
  63 #define USB_FAST_LOOP           BIT(7)
  64
  65 #define REG_ALARM               0x5
  66 #define ALARM_LDO1              BIT(0)
  67 #define ALARM_DCDC1             BIT(1)
  68 #define ALARM_DCDC2             BIT(2)
  69 #define ALARM_DCDC3             BIT(3)
  70 #define ALARM_LDO2              BIT(4)
  71 #define ALARM_USB_WARN          BIT(5)
  72 #define ALARM_USB_ALARM         BIT(6)
  73 #define ALARM_LCD               BIT(9)
  74 #define ALARM_TEMP_WARM         BIT(10)
  75 #define ALARM_TEMP_HOT          BIT(11)
  76 #define ALARM_NRST              BIT(14)
  77 #define ALARM_POWERUP           BIT(15)
  78
  79 #define REG_INT_ENABLE          0x6
  80 #define INT_LDO1                BIT(0)
  81 #define INT_DCDC1               BIT(1)
  82 #define INT_DCDC2               BIT(2)
  83 #define INT_DCDC3               BIT(3)
  84 #define INT_LDO2                BIT(4)
  85 #define INT_USB_WARN            BIT(5)
  86 #define INT_USB_ALARM           BIT(6)
  87 #define INT_LCD                 BIT(9)
  88 #define INT_TEMP_WARM           BIT(10)
  89 #define INT_TEMP_HOT            BIT(11)
  90 #define INT_GLOBAL_EN           BIT(15)
  91
  92 #define REG_INT_STATUS          0x7
  93 #define STATUS_LDO1             BIT(0)
  94 #define STATUS_DCDC1            BIT(1)
  95 #define STATUS_DCDC2            BIT(2)
  96 #define STATUS_DCDC3            BIT(3)
  97 #define STATUS_LDO2             BIT(4)
  98 #define STATUS_USB_WARN         BIT(5)
  99 #define STATUS_USB_ALARM        BIT(6)
 100 #define STATUS_LCD              BIT(9)
 101 #define STATUS_TEMP_WARM        BIT(10)
 102 #define STATUS_TEMP_HOT         BIT(11)
 103
 104 #define REG_SOFTWARE_RESET      0xb
 105 #define REG_WRITE_ENABLE        0xd
 106 #define REG_REV_ID              0xf
 107
 108 #define N_DCDC                  3
 109 #define N_LDO                   2
 110 #define N_SWITCH                2
 111 #define N_REGULATORS            (N_DCDC + N_LDO + N_SWITCH)
 112
 113 #define CMD_READ(reg)           ((reg) << 6)
 114 #define CMD_WRITE(reg)          (BIT(5) | (reg) << 6)
 115 #define STAT_CLK                BIT(3)
 116 #define STAT_WRITE              BIT(2)
 117 #define STAT_INVALID            BIT(1)
 118 #define STAT_WP                 BIT(0)
 119
 120 struct field {
 121         int             reg;
 122         int             shift;
 123         int             mask;
 124 };
 125
 126 struct supply_info {
 127         const char      *name;
 128         int             n_voltages;
 129         const unsigned int *voltages;
 130         int             n_ilimsels;
 131         const unsigned int *ilimsels;
 132         struct field    enable, voltage, ilimsel;
 133 };
 134
 135 struct tps6524x {
 136         struct device           *dev;
 137         struct spi_device       *spi;
 138         struct mutex            lock;
 139         struct regulator_desc   desc[N_REGULATORS];
 140 };
 141
 142 static int __read_reg(struct tps6524x *hw, int reg)
 143 {
 144         int error = 0;
 145         u16 cmd = CMD_READ(reg), in;
 146         u8 status;
 147         struct spi_message m;
 148         struct spi_transfer t[3];
 149
 150         spi_message_init(&m);
 151         memset(t, 0, sizeof(t));
 152
 153         t[0].tx_buf = &cmd;
 154         t[0].len = 2;
 155         t[0].bits_per_word = 12;
 156         spi_message_add_tail(&t[0], &m);
 157
 158         t[1].rx_buf = &in;
 159         t[1].len = 2;
 160         t[1].bits_per_word = 16;
 161         spi_message_add_tail(&t[1], &m);
 162
 163         t[2].rx_buf = &status;
 164         t[2].len = 1;
 165         t[2].bits_per_word = 4;
 166         spi_message_add_tail(&t[2], &m);
 167
 168         error = spi_sync(hw->spi, &m);
 169         if (error < 0)
 170                 return error;
 171
 172         dev_dbg(hw->dev, "read reg %d, data %x, status %x\n",
 173                 reg, in, status);
 174
 175         if (!(status & STAT_CLK) || (status & STAT_WRITE))
 176                 return -EIO;
 177
 178         if (status & STAT_INVALID)
 179                 return -EINVAL;
 180
 181         return in;
 182 }
 183
 184 static int read_reg(struct tps6524x *hw, int reg)
 185 {
 186         int ret;
 187
 188         mutex_lock(&hw->lock);
 189         ret = __read_reg(hw, reg);
 190         mutex_unlock(&hw->lock);
 191
 192         return ret;
 193 }
 194
 195 static int __write_reg(struct tps6524x *hw, int reg, int val)
 196 {
 197         int error = 0;
 198         u16 cmd = CMD_WRITE(reg), out = val;
 199         u8 status;
 200         struct spi_message m;
 201         struct spi_transfer t[3];
 202
 203         spi_message_init(&m);
 204         memset(t, 0, sizeof(t));
 205
 206         t[0].tx_buf = &cmd;
 207         t[0].len = 2;
 208         t[0].bits_per_word = 12;
 209         spi_message_add_tail(&t[0], &m);
 210
 211         t[1].tx_buf = &out;
 212         t[1].len = 2;
 213         t[1].bits_per_word = 16;
 214         spi_message_add_tail(&t[1], &m);
 215
 216         t[2].rx_buf = &status;
 217         t[2].len = 1;
 218         t[2].bits_per_word = 4;
 219         spi_message_add_tail(&t[2], &m);
 220
 221         error = spi_sync(hw->spi, &m);
 222         if (error < 0)
 223                 return error;
 224
 225         dev_dbg(hw->dev, "wrote reg %d, data %x, status %x\n",
 226                 reg, out, status);
 227
 228         if (!(status & STAT_CLK) || !(status & STAT_WRITE))
 229                 return -EIO;
 230
 231         if (status & (STAT_INVALID | STAT_WP))
 232                 return -EINVAL;
 233
 234         return error;
 235 }
 236
 237 static int __rmw_reg(struct tps6524x *hw, int reg, int mask, int val)
 238 {
 239         int ret;
 240
 241         ret = __read_reg(hw, reg);
 242         if (ret < 0)
 243                 return ret;
 244
 245         ret &= ~mask;
 246         ret |= val;
 247
 248         ret = __write_reg(hw, reg, ret);
 249
 250         return (ret < 0) ? ret : 0;
 251 }
 252
 253 static int rmw_protect(struct tps6524x *hw, int reg, int mask, int val)
 254 {
 255         int ret;
 256
 257         mutex_lock(&hw->lock);
 258
 259         ret = __write_reg(hw, REG_WRITE_ENABLE, 1);
 260         if (ret) {
 261                 dev_err(hw->dev, "failed to set write enable\n");
 262                 goto error;
 263         }
 264
 265         ret = __rmw_reg(hw, reg, mask, val);
 266         if (ret)
 267                 dev_err(hw->dev, "failed to rmw register %d\n", reg);
 268
 269         ret = __write_reg(hw, REG_WRITE_ENABLE, 0);
 270         if (ret) {
 271                 dev_err(hw->dev, "failed to clear write enable\n");
 272                 goto error;
 273         }
 274
 275 error:
 276         mutex_unlock(&hw->lock);
 277
 278         return ret;
 279 }
 280
 281 static int read_field(struct tps6524x *hw, const struct field *field)
 282 {
 283         int tmp;
 284
 285         tmp = read_reg(hw, field->reg);
 286         if (tmp < 0)
 287                 return tmp;
 288
 289         return (tmp >> field->shift) & field->mask;
 290 }
 291
 292 static int write_field(struct tps6524x *hw, const struct field *field,
 293                        int val)
 294 {
 295         if (val & ~field->mask)
 296                 return -EOVERFLOW;
 297
 298         return rmw_protect(hw, field->reg,
 299                                     field->mask << field->shift,
 300                                     val << field->shift);
 301 }
 302
 303 static const unsigned int dcdc1_voltages[] = {
 304          800000,  825000,  850000,  875000,
 305          900000,  925000,  950000,  975000,
 306         1000000, 1025000, 1050000, 1075000,
 307         1100000, 1125000, 1150000, 1175000,
 308         1200000, 1225000, 1250000, 1275000,
 309         1300000, 1325000, 1350000, 1375000,
 310         1400000, 1425000, 1450000, 1475000,
 311         1500000, 1525000, 1550000, 1575000,
 312 };
 313
 314 static const unsigned int dcdc2_voltages[] = {
 315         1400000, 1450000, 1500000, 1550000,
 316         1600000, 1650000, 1700000, 1750000,
 317         1800000, 1850000, 1900000, 1950000,
 318         2000000, 2050000, 2100000, 2150000,
 319         2200000, 2250000, 2300000, 2350000,
 320         2400000, 2450000, 2500000, 2550000,
 321         2600000, 2650000, 2700000, 2750000,
 322         2800000, 2850000, 2900000, 2950000,
 323 };
 324
 325 static const unsigned int dcdc3_voltages[] = {
 326         2400000, 2450000, 2500000, 2550000, 2600000,
 327         2650000, 2700000, 2750000, 2800000, 2850000,
 328         2900000, 2950000, 3000000, 3050000, 3100000,
 329         3150000, 3200000, 3250000, 3300000, 3350000,
 330         3400000, 3450000, 3500000, 3550000, 3600000,
 331 };
 332
 333 static const unsigned int ldo1_voltages[] = {
 334         4300000, 4350000, 4400000, 4450000,
 335         4500000, 4550000, 4600000, 4650000,
 336         4700000, 4750000, 4800000, 4850000,
 337         4900000, 4950000, 5000000, 5050000,
 338 };
 339
 340 static const unsigned int ldo2_voltages[] = {
 341         1100000, 1150000, 1200000, 1250000,
 342         1300000, 1700000, 1750000, 1800000,
 343         1850000, 1900000, 3150000, 3200000,
 344         3250000, 3300000, 3350000, 3400000,
 345 };
 346
 347 static const unsigned int fixed_5000000_voltage[] = {
 348         5000000
 349 };
 350
 351 static const unsigned int ldo_ilimsel[] = {
 352         400000, 1500000
 353 };
 354
 355 static const unsigned int usb_ilimsel[] = {
 356         200000, 400000, 800000, 1000000
 357 };
 358
 359 static const unsigned int fixed_2400000_ilimsel[] = {
 360         2400000
 361 };
 362
 363 static const unsigned int fixed_1200000_ilimsel[] = {
 364         1200000
 365 };
 366
 367 static const unsigned int fixed_400000_ilimsel[] = {
 368         400000
 369 };
 370
 371 #define __MK_FIELD(_reg, _mask, _shift) \
 372         { .reg = (_reg), .mask = (_mask), .shift = (_shift), }
 373
 374 static const struct supply_info supply_info[N_REGULATORS] = {
 375         {
 376                 .name           = "DCDC1",
 377                 .n_voltages     = ARRAY_SIZE(dcdc1_voltages),
 378                 .voltages       = dcdc1_voltages,
 379                 .n_ilimsels     = ARRAY_SIZE(fixed_2400000_ilimsel),
 380                 .ilimsels       = fixed_2400000_ilimsel,
 381                 .enable         = __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK,
 382                                              DCDCDCDC1_EN_SHIFT),
 383                 .voltage        = __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK,
 384                                              DCDC_VDCDC1_SHIFT),
 385         },
 386         {
 387                 .name           = "DCDC2",
 388                 .n_voltages     = ARRAY_SIZE(dcdc2_voltages),
 389                 .voltages       = dcdc2_voltages,
 390                 .n_ilimsels     = ARRAY_SIZE(fixed_1200000_ilimsel),
 391                 .ilimsels       = fixed_1200000_ilimsel,
 392                 .enable         = __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK,
 393                                              DCDCDCDC2_EN_SHIFT),
 394                 .voltage        = __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK,
 395                                              DCDC_VDCDC2_SHIFT),
 396         },
 397         {
 398                 .name           = "DCDC3",
 399                 .n_voltages     = ARRAY_SIZE(dcdc3_voltages),
 400                 .voltages       = dcdc3_voltages,
 401                 .n_ilimsels     = ARRAY_SIZE(fixed_1200000_ilimsel),
 402                 .ilimsels       = fixed_1200000_ilimsel,
 403                 .enable         = __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK,
 404                                         DCDCDCDC3_EN_SHIFT),
 405                 .voltage        = __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK,
 406                                              DCDC_VDCDC3_SHIFT),
 407         },
 408         {
 409                 .name           = "LDO1",
 410                 .n_voltages     = ARRAY_SIZE(ldo1_voltages),
 411                 .voltages       = ldo1_voltages,
 412                 .n_ilimsels     = ARRAY_SIZE(ldo_ilimsel),
 413                 .ilimsels       = ldo_ilimsel,
 414                 .enable         = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
 415                                              BLOCK_LDO1_SHIFT),
 416                 .voltage        = __MK_FIELD(REG_LDO_SET, LDO_VSEL_MASK,
 417                                              LDO1_VSEL_SHIFT),
 418                 .ilimsel        = __MK_FIELD(REG_LDO_SET, LDO_ILIM_MASK,
 419                                              LDO1_ILIM_SHIFT),
 420         },
 421         {
 422                 .name           = "LDO2",
 423                 .n_voltages     = ARRAY_SIZE(ldo2_voltages),
 424                 .voltages       = ldo2_voltages,
 425                 .n_ilimsels     = ARRAY_SIZE(ldo_ilimsel),
 426                 .ilimsels       = ldo_ilimsel,
 427                 .enable         = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
 428                                              BLOCK_LDO2_SHIFT),
 429                 .voltage        = __MK_FIELD(REG_LDO_SET, LDO_VSEL_MASK,
 430                                              LDO2_VSEL_SHIFT),
 431                 .ilimsel        = __MK_FIELD(REG_LDO_SET, LDO_ILIM_MASK,
 432                                              LDO2_ILIM_SHIFT),
 433         },
 434         {
 435                 .name           = "USB",
 436                 .n_voltages     = ARRAY_SIZE(fixed_5000000_voltage),
 437                 .voltages       = fixed_5000000_voltage,
 438                 .n_ilimsels     = ARRAY_SIZE(usb_ilimsel),
 439                 .ilimsels       = usb_ilimsel,
 440                 .enable         = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
 441                                              BLOCK_USB_SHIFT),
 442                 .ilimsel        = __MK_FIELD(REG_USB, USB_ILIM_MASK,
 443                                              USB_ILIM_SHIFT),
 444         },
 445         {
 446                 .name           = "LCD",
 447                 .n_voltages     = ARRAY_SIZE(fixed_5000000_voltage),
 448                 .voltages       = fixed_5000000_voltage,
 449                 .n_ilimsels     = ARRAY_SIZE(fixed_400000_ilimsel),
 450                 .ilimsels       = fixed_400000_ilimsel,
 451                 .enable         = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
 452                                              BLOCK_LCD_SHIFT),
 453         },
 454 };
 455
 456 static int set_voltage_sel(struct regulator_dev *rdev, unsigned selector)
 457 {
 458         const struct supply_info *info;
 459         struct tps6524x *hw;
 460
 461         hw      = rdev_get_drvdata(rdev);
 462         info    = &supply_info[rdev_get_id(rdev)];
 463
 464         if (rdev->desc->n_voltages == 1)
 465                 return -EINVAL;
 466
 467         return write_field(hw, &info->voltage, selector);
 468 }
 469
 470 static int get_voltage_sel(struct regulator_dev *rdev)
 471 {
 472         const struct supply_info *info;
 473         struct tps6524x *hw;
 474         int ret;
 475
 476         hw      = rdev_get_drvdata(rdev);
 477         info    = &supply_info[rdev_get_id(rdev)];
 478
 479         if (rdev->desc->n_voltages == 1)
 480                 return 0;
 481
 482         ret = read_field(hw, &info->voltage);
 483         if (ret < 0)
 484                 return ret;
 485         if (WARN_ON(ret >= info->n_voltages))
 486                 return -EIO;
 487
 488         return ret;
 489 }
 490
 491 static int set_current_limit(struct regulator_dev *rdev, int min_uA,
 492                              int max_uA)
 493 {
 494         const struct supply_info *info;
 495         struct tps6524x *hw;
 496         int i;
 497
 498         hw      = rdev_get_drvdata(rdev);
 499         info    = &supply_info[rdev_get_id(rdev)];
 500
 501         if (info->n_ilimsels == 1)
 502                 return -EINVAL;
 503
 504         for (i = info->n_ilimsels - 1; i >= 0; i--) {
 505                 if (min_uA <= info->ilimsels[i] &&
 506                     max_uA >= info->ilimsels[i])
 507                         return write_field(hw, &info->ilimsel, i);
 508         }
 509
 510         return -EINVAL;
 511 }
 512
 513 static int get_current_limit(struct regulator_dev *rdev)
 514 {
 515         const struct supply_info *info;
 516         struct tps6524x *hw;
 517         int ret;
 518
 519         hw      = rdev_get_drvdata(rdev);
 520         info    = &supply_info[rdev_get_id(rdev)];
 521
 522         if (info->n_ilimsels == 1)
 523                 return info->ilimsels[0];
 524
 525         ret = read_field(hw, &info->ilimsel);
 526         if (ret < 0)
 527                 return ret;
 528         if (WARN_ON(ret >= info->n_ilimsels))
 529                 return -EIO;
 530
 531         return info->ilimsels[ret];
 532 }
 533
 534 static int enable_supply(struct regulator_dev *rdev)
 535 {
 536         const struct supply_info *info;
 537         struct tps6524x *hw;
 538
 539         hw      = rdev_get_drvdata(rdev);
 540         info    = &supply_info[rdev_get_id(rdev)];
 541
 542         return write_field(hw, &info->enable, 1);
 543 }
 544
 545 static int disable_supply(struct regulator_dev *rdev)
 546 {
 547         const struct supply_info *info;
 548         struct tps6524x *hw;
 549
 550         hw      = rdev_get_drvdata(rdev);
 551         info    = &supply_info[rdev_get_id(rdev)];
 552
 553         return write_field(hw, &info->enable, 0);
 554 }
 555
 556 static int is_supply_enabled(struct regulator_dev *rdev)
 557 {
 558         const struct supply_info *info;
 559         struct tps6524x *hw;
 560
 561         hw      = rdev_get_drvdata(rdev);
 562         info    = &supply_info[rdev_get_id(rdev)];
 563
 564         return read_field(hw, &info->enable);
 565 }
 566
 567 static const struct regulator_ops regulator_ops = {
 568         .is_enabled             = is_supply_enabled,
 569         .enable                 = enable_supply,
 570         .disable                = disable_supply,
 571         .get_voltage_sel        = get_voltage_sel,
 572         .set_voltage_sel        = set_voltage_sel,
 573         .list_voltage           = regulator_list_voltage_table,
 574         .map_voltage            = regulator_map_voltage_ascend,
 575         .set_current_limit      = set_current_limit,
 576         .get_current_limit      = get_current_limit,
 577 };
 578
 579 static int pmic_probe(struct spi_device *spi)
 580 {
 581         struct tps6524x *hw;
 582         struct device *dev = &spi->dev;
 583         const struct supply_info *info = supply_info;
 584         struct regulator_init_data *init_data;
 585         struct regulator_config config = { };
 586         struct regulator_dev *rdev;
 587         int i;
 588
 589         init_data = dev_get_platdata(dev);
 590         if (!init_data) {
 591                 dev_err(dev, "could not find regulator platform data\n");
 592                 return -EINVAL;
 593         }
 594
 595         hw = devm_kzalloc(&spi->dev, sizeof(struct tps6524x), GFP_KERNEL);
 596         if (!hw)
 597                 return -ENOMEM;
 598
 599         spi_set_drvdata(spi, hw);
 600
 601         memset(hw, 0, sizeof(struct tps6524x));
 602         hw->dev = dev;
 603         hw->spi = spi;
 604         mutex_init(&hw->lock);
 605
 606         for (i = 0; i < N_REGULATORS; i++, info++, init_data++) {
 607                 hw->desc[i].name        = info->name;
 608                 hw->desc[i].id          = i;
 609                 hw->desc[i].n_voltages  = info->n_voltages;
 610                 hw->desc[i].volt_table  = info->voltages;
 611                 hw->desc[i].ops         = &regulator_ops;
 612                 hw->desc[i].type        = REGULATOR_VOLTAGE;
 613                 hw->desc[i].owner       = THIS_MODULE;
 614
 615                 config.dev = dev;
 616                 config.init_data = init_data;
 617                 config.driver_data = hw;
 618
 619                 rdev = devm_regulator_register(dev, &hw->desc[i], &config);
 620                 if (IS_ERR(rdev))
 621                         return PTR_ERR(rdev);
 622         }
 623
 624         return 0;
 625 }
 626
 627 static struct spi_driver pmic_driver = {
 628         .probe          = pmic_probe,
 629         .driver         = {
 630                 .name   = "tps6524x",
 631         },
 632 };
 633
 634 module_spi_driver(pmic_driver);
 635
 636 MODULE_DESCRIPTION("TPS6524X PMIC Driver");
 637 MODULE_AUTHOR("Cyril Chemparathy");
 638 MODULE_LICENSE("GPL");
 639 MODULE_ALIAS("spi:tps6524x");