drivers/regulator/qcom_smd-regulator.c

   1 /*
   2  * Copyright (c) 2015, Sony Mobile Communications AB.
   3  * Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 and
   7  * only version 2 as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  */
  14
  15 #include <linux/module.h>
  16 #include <linux/of.h>
  17 #include <linux/of_device.h>
  18 #include <linux/platform_device.h>
  19 #include <linux/regulator/driver.h>
  20 #include <linux/soc/qcom/smd-rpm.h>
  21
  22 struct qcom_rpm_reg {
  23         struct device *dev;
  24
  25         struct qcom_smd_rpm *rpm;
  26
  27         u32 type;
  28         u32 id;
  29
  30         struct regulator_desc desc;
  31
  32         int is_enabled;
  33         int uV;
  34 };
  35
  36 struct rpm_regulator_req {
  37         __le32 key;
  38         __le32 nbytes;
  39         __le32 value;
  40 };
  41
  42 #define RPM_KEY_SWEN    0x6e657773 /* "swen" */
  43 #define RPM_KEY_UV      0x00007675 /* "uv" */
  44 #define RPM_KEY_MA      0x0000616d /* "ma" */
  45
  46 static int rpm_reg_write_active(struct qcom_rpm_reg *vreg,
  47                                 struct rpm_regulator_req *req,
  48                                 size_t size)
  49 {
  50         return qcom_rpm_smd_write(vreg->rpm,
  51                                   QCOM_SMD_RPM_ACTIVE_STATE,
  52                                   vreg->type,
  53                                   vreg->id,
  54                                   req, size);
  55 }
  56
  57 static int rpm_reg_enable(struct regulator_dev *rdev)
  58 {
  59         struct qcom_rpm_reg *vreg = rdev_get_drvdata(rdev);
  60         struct rpm_regulator_req req;
  61         int ret;
  62
  63         req.key = cpu_to_le32(RPM_KEY_SWEN);
  64         req.nbytes = cpu_to_le32(sizeof(u32));
  65         req.value = cpu_to_le32(1);
  66
  67         ret = rpm_reg_write_active(vreg, &req, sizeof(req));
  68         if (!ret)
  69                 vreg->is_enabled = 1;
  70
  71         return ret;
  72 }
  73
  74 static int rpm_reg_is_enabled(struct regulator_dev *rdev)
  75 {
  76         struct qcom_rpm_reg *vreg = rdev_get_drvdata(rdev);
  77
  78         return vreg->is_enabled;
  79 }
  80
  81 static int rpm_reg_disable(struct regulator_dev *rdev)
  82 {
  83         struct qcom_rpm_reg *vreg = rdev_get_drvdata(rdev);
  84         struct rpm_regulator_req req;
  85         int ret;
  86
  87         req.key = cpu_to_le32(RPM_KEY_SWEN);
  88         req.nbytes = cpu_to_le32(sizeof(u32));
  89         req.value = 0;
  90
  91         ret = rpm_reg_write_active(vreg, &req, sizeof(req));
  92         if (!ret)
  93                 vreg->is_enabled = 0;
  94
  95         return ret;
  96 }
  97
  98 static int rpm_reg_get_voltage(struct regulator_dev *rdev)
  99 {
 100         struct qcom_rpm_reg *vreg = rdev_get_drvdata(rdev);
 101
 102         return vreg->uV;
 103 }
 104
 105 static int rpm_reg_set_voltage(struct regulator_dev *rdev,
 106                                int min_uV,
 107                                int max_uV,
 108                                unsigned *selector)
 109 {
 110         struct qcom_rpm_reg *vreg = rdev_get_drvdata(rdev);
 111         struct rpm_regulator_req req;
 112         int ret = 0;
 113
 114         req.key = cpu_to_le32(RPM_KEY_UV);
 115         req.nbytes = cpu_to_le32(sizeof(u32));
 116         req.value = cpu_to_le32(min_uV);
 117
 118         ret = rpm_reg_write_active(vreg, &req, sizeof(req));
 119         if (!ret)
 120                 vreg->uV = min_uV;
 121
 122         return ret;
 123 }
 124
 125 static int rpm_reg_set_load(struct regulator_dev *rdev, int load_uA)
 126 {
 127         struct qcom_rpm_reg *vreg = rdev_get_drvdata(rdev);
 128         struct rpm_regulator_req req;
 129
 130         req.key = cpu_to_le32(RPM_KEY_MA);
 131         req.nbytes = cpu_to_le32(sizeof(u32));
 132         req.value = cpu_to_le32(load_uA / 1000);
 133
 134         return rpm_reg_write_active(vreg, &req, sizeof(req));
 135 }
 136
 137 static const struct regulator_ops rpm_smps_ldo_ops = {
 138         .enable = rpm_reg_enable,
 139         .disable = rpm_reg_disable,
 140         .is_enabled = rpm_reg_is_enabled,
 141         .list_voltage = regulator_list_voltage_linear_range,
 142
 143         .get_voltage = rpm_reg_get_voltage,
 144         .set_voltage = rpm_reg_set_voltage,
 145
 146         .set_load = rpm_reg_set_load,
 147 };
 148
 149 static const struct regulator_ops rpm_smps_ldo_ops_fixed = {
 150         .enable = rpm_reg_enable,
 151         .disable = rpm_reg_disable,
 152         .is_enabled = rpm_reg_is_enabled,
 153
 154         .get_voltage = rpm_reg_get_voltage,
 155         .set_voltage = rpm_reg_set_voltage,
 156
 157         .set_load = rpm_reg_set_load,
 158 };
 159
 160 static const struct regulator_ops rpm_switch_ops = {
 161         .enable = rpm_reg_enable,
 162         .disable = rpm_reg_disable,
 163         .is_enabled = rpm_reg_is_enabled,
 164 };
 165
 166 static const struct regulator_ops rpm_bob_ops = {
 167         .enable = rpm_reg_enable,
 168         .disable = rpm_reg_disable,
 169         .is_enabled = rpm_reg_is_enabled,
 170
 171         .get_voltage = rpm_reg_get_voltage,
 172         .set_voltage = rpm_reg_set_voltage,
 173 };
 174
 175 static const struct regulator_desc pma8084_hfsmps = {
 176         .linear_ranges = (struct regulator_linear_range[]) {
 177                 REGULATOR_LINEAR_RANGE(375000,  0,  95, 12500),
 178                 REGULATOR_LINEAR_RANGE(1550000, 96, 158, 25000),
 179         },
 180         .n_linear_ranges = 2,
 181         .n_voltages = 159,
 182         .ops = &rpm_smps_ldo_ops,
 183 };
 184
 185 static const struct regulator_desc pma8084_ftsmps = {
 186         .linear_ranges = (struct regulator_linear_range[]) {
 187                 REGULATOR_LINEAR_RANGE(350000,  0, 184, 5000),
 188                 REGULATOR_LINEAR_RANGE(1280000, 185, 261, 10000),
 189         },
 190         .n_linear_ranges = 2,
 191         .n_voltages = 262,
 192         .ops = &rpm_smps_ldo_ops,
 193 };
 194
 195 static const struct regulator_desc pma8084_pldo = {
 196         .linear_ranges = (struct regulator_linear_range[]) {
 197                 REGULATOR_LINEAR_RANGE( 750000,  0,  63, 12500),
 198                 REGULATOR_LINEAR_RANGE(1550000, 64, 126, 25000),
 199                 REGULATOR_LINEAR_RANGE(3100000, 127, 163, 50000),
 200         },
 201         .n_linear_ranges = 3,
 202         .n_voltages = 164,
 203         .ops = &rpm_smps_ldo_ops,
 204 };
 205
 206 static const struct regulator_desc pma8084_nldo = {
 207         .linear_ranges = (struct regulator_linear_range[]) {
 208                 REGULATOR_LINEAR_RANGE(750000, 0, 63, 12500),
 209         },
 210         .n_linear_ranges = 1,
 211         .n_voltages = 64,
 212         .ops = &rpm_smps_ldo_ops,
 213 };
 214
 215 static const struct regulator_desc pma8084_switch = {
 216         .ops = &rpm_switch_ops,
 217 };
 218
 219 static const struct regulator_desc pm8x41_hfsmps = {
 220         .linear_ranges = (struct regulator_linear_range[]) {
 221                 REGULATOR_LINEAR_RANGE( 375000,  0,  95, 12500),
 222                 REGULATOR_LINEAR_RANGE(1575000, 96, 158, 25000),
 223         },
 224         .n_linear_ranges = 2,
 225         .n_voltages = 159,
 226         .ops = &rpm_smps_ldo_ops,
 227 };
 228
 229 static const struct regulator_desc pm8841_ftsmps = {
 230         .linear_ranges = (struct regulator_linear_range[]) {
 231                 REGULATOR_LINEAR_RANGE(350000,  0, 184, 5000),
 232                 REGULATOR_LINEAR_RANGE(1280000, 185, 261, 10000),
 233         },
 234         .n_linear_ranges = 2,
 235         .n_voltages = 262,
 236         .ops = &rpm_smps_ldo_ops,
 237 };
 238
 239 static const struct regulator_desc pm8941_boost = {
 240         .linear_ranges = (struct regulator_linear_range[]) {
 241                 REGULATOR_LINEAR_RANGE(4000000, 0, 30, 50000),
 242         },
 243         .n_linear_ranges = 1,
 244         .n_voltages = 31,
 245         .ops = &rpm_smps_ldo_ops,
 246 };
 247
 248 static const struct regulator_desc pm8941_pldo = {
 249         .linear_ranges = (struct regulator_linear_range[]) {
 250                 REGULATOR_LINEAR_RANGE( 750000,  0,  63, 12500),
 251                 REGULATOR_LINEAR_RANGE(1550000, 64, 126, 25000),
 252                 REGULATOR_LINEAR_RANGE(3100000, 127, 163, 50000),
 253         },
 254         .n_linear_ranges = 3,
 255         .n_voltages = 164,
 256         .ops = &rpm_smps_ldo_ops,
 257 };
 258
 259 static const struct regulator_desc pm8941_nldo = {
 260         .linear_ranges = (struct regulator_linear_range[]) {
 261                 REGULATOR_LINEAR_RANGE(750000, 0, 63, 12500),
 262         },
 263         .n_linear_ranges = 1,
 264         .n_voltages = 64,
 265         .ops = &rpm_smps_ldo_ops,
 266 };
 267
 268 static const struct regulator_desc pm8941_lnldo = {
 269         .fixed_uV = 1740000,
 270         .n_voltages = 1,
 271         .ops = &rpm_smps_ldo_ops_fixed,
 272 };
 273
 274 static const struct regulator_desc pm8941_switch = {
 275         .ops = &rpm_switch_ops,
 276 };
 277
 278 static const struct regulator_desc pm8916_pldo = {
 279         .linear_ranges = (struct regulator_linear_range[]) {
 280                 REGULATOR_LINEAR_RANGE(750000, 0, 208, 12500),
 281         },
 282         .n_linear_ranges = 1,
 283         .n_voltages = 209,
 284         .ops = &rpm_smps_ldo_ops,
 285 };
 286
 287 static const struct regulator_desc pm8916_nldo = {
 288         .linear_ranges = (struct regulator_linear_range[]) {
 289                 REGULATOR_LINEAR_RANGE(375000, 0, 93, 12500),
 290         },
 291         .n_linear_ranges = 1,
 292         .n_voltages = 94,
 293         .ops = &rpm_smps_ldo_ops,
 294 };
 295
 296 static const struct regulator_desc pm8916_buck_lvo_smps = {
 297         .linear_ranges = (struct regulator_linear_range[]) {
 298                 REGULATOR_LINEAR_RANGE(375000, 0, 95, 12500),
 299                 REGULATOR_LINEAR_RANGE(750000, 96, 127, 25000),
 300         },
 301         .n_linear_ranges = 2,
 302         .n_voltages = 128,
 303         .ops = &rpm_smps_ldo_ops,
 304 };
 305
 306 static const struct regulator_desc pm8916_buck_hvo_smps = {
 307         .linear_ranges = (struct regulator_linear_range[]) {
 308                 REGULATOR_LINEAR_RANGE(1550000, 0, 31, 25000),
 309         },
 310         .n_linear_ranges = 1,
 311         .n_voltages = 32,
 312         .ops = &rpm_smps_ldo_ops,
 313 };
 314
 315 static const struct regulator_desc pm8994_hfsmps = {
 316         .linear_ranges = (struct regulator_linear_range[]) {
 317                 REGULATOR_LINEAR_RANGE( 375000,  0,  95, 12500),
 318                 REGULATOR_LINEAR_RANGE(1550000, 96, 158, 25000),
 319         },
 320         .n_linear_ranges = 2,
 321         .n_voltages = 159,
 322         .ops = &rpm_smps_ldo_ops,
 323 };
 324
 325 static const struct regulator_desc pm8994_ftsmps = {
 326         .linear_ranges = (struct regulator_linear_range[]) {
 327                 REGULATOR_LINEAR_RANGE(350000,  0, 199, 5000),
 328                 REGULATOR_LINEAR_RANGE(700000, 200, 349, 10000),
 329         },
 330         .n_linear_ranges = 2,
 331         .n_voltages = 350,
 332         .ops = &rpm_smps_ldo_ops,
 333 };
 334
 335 static const struct regulator_desc pm8994_nldo = {
 336         .linear_ranges = (struct regulator_linear_range[]) {
 337                 REGULATOR_LINEAR_RANGE(750000, 0, 63, 12500),
 338         },
 339         .n_linear_ranges = 1,
 340         .n_voltages = 64,
 341         .ops = &rpm_smps_ldo_ops,
 342 };
 343
 344 static const struct regulator_desc pm8994_pldo = {
 345         .linear_ranges = (struct regulator_linear_range[]) {
 346                 REGULATOR_LINEAR_RANGE( 750000,  0,  63, 12500),
 347                 REGULATOR_LINEAR_RANGE(1550000, 64, 126, 25000),
 348                 REGULATOR_LINEAR_RANGE(3100000, 127, 163, 50000),
 349         },
 350         .n_linear_ranges = 3,
 351         .n_voltages = 164,
 352         .ops = &rpm_smps_ldo_ops,
 353 };
 354
 355 static const struct regulator_desc pm8994_switch = {
 356         .ops = &rpm_switch_ops,
 357 };
 358
 359 static const struct regulator_desc pm8994_lnldo = {
 360         .fixed_uV = 1740000,
 361         .n_voltages = 1,
 362         .ops = &rpm_smps_ldo_ops_fixed,
 363 };
 364
 365 static const struct regulator_desc pm8998_ftsmps = {
 366         .linear_ranges = (struct regulator_linear_range[]) {
 367                 REGULATOR_LINEAR_RANGE(320000, 0, 258, 4000),
 368         },
 369         .n_linear_ranges = 1,
 370         .n_voltages = 259,
 371         .ops = &rpm_smps_ldo_ops,
 372 };
 373
 374 static const struct regulator_desc pm8998_hfsmps = {
 375         .linear_ranges = (struct regulator_linear_range[]) {
 376                 REGULATOR_LINEAR_RANGE(320000, 0, 215, 8000),
 377         },
 378         .n_linear_ranges = 1,
 379         .n_voltages = 216,
 380         .ops = &rpm_smps_ldo_ops,
 381 };
 382
 383 static const struct regulator_desc pm8998_nldo = {
 384         .linear_ranges = (struct regulator_linear_range[]) {
 385                 REGULATOR_LINEAR_RANGE(312000, 0, 127, 8000),
 386         },
 387         .n_linear_ranges = 1,
 388         .n_voltages = 128,
 389         .ops = &rpm_smps_ldo_ops,
 390 };
 391
 392 static const struct regulator_desc pm8998_pldo = {
 393         .linear_ranges = (struct regulator_linear_range[]) {
 394                 REGULATOR_LINEAR_RANGE(1664000, 0, 255, 8000),
 395         },
 396         .n_linear_ranges = 1,
 397         .n_voltages = 256,
 398         .ops = &rpm_smps_ldo_ops,
 399 };
 400
 401 static const struct regulator_desc pm8998_pldo_lv = {
 402         .linear_ranges = (struct regulator_linear_range[]) {
 403                 REGULATOR_LINEAR_RANGE(1256000, 0, 127, 8000),
 404         },
 405         .n_linear_ranges = 1,
 406         .n_voltages = 128,
 407         .ops = &rpm_smps_ldo_ops,
 408 };
 409
 410 static const struct regulator_desc pm8998_switch = {
 411         .ops = &rpm_switch_ops,
 412 };
 413
 414 static const struct regulator_desc pmi8998_bob = {
 415         .linear_ranges = (struct regulator_linear_range[]) {
 416                 REGULATOR_LINEAR_RANGE(1824000, 0, 83, 32000),
 417         },
 418         .n_linear_ranges = 1,
 419         .n_voltages = 84,
 420         .ops = &rpm_bob_ops,
 421 };
 422
 423 static const struct regulator_desc pms405_hfsmps3 = {
 424         .linear_ranges = (struct regulator_linear_range[]) {
 425                 REGULATOR_LINEAR_RANGE(320000, 0, 215, 8000),
 426         },
 427         .n_linear_ranges = 1,
 428         .n_voltages = 216,
 429         .ops = &rpm_smps_ldo_ops,
 430 };
 431
 432 static const struct regulator_desc pms405_nldo300 = {
 433         .linear_ranges = (struct regulator_linear_range[]) {
 434                 REGULATOR_LINEAR_RANGE(312000, 0, 127, 8000),
 435         },
 436         .n_linear_ranges = 1,
 437         .n_voltages = 128,
 438         .ops = &rpm_smps_ldo_ops,
 439 };
 440
 441 static const struct regulator_desc pms405_nldo1200 = {
 442         .linear_ranges = (struct regulator_linear_range[]) {
 443                 REGULATOR_LINEAR_RANGE(312000, 0, 127, 8000),
 444         },
 445         .n_linear_ranges = 1,
 446         .n_voltages = 128,
 447         .ops = &rpm_smps_ldo_ops,
 448 };
 449
 450 static const struct regulator_desc pms405_pldo50 = {
 451         .linear_ranges = (struct regulator_linear_range[]) {
 452                 REGULATOR_LINEAR_RANGE(1664000, 0, 128, 16000),
 453         },
 454         .n_linear_ranges = 1,
 455         .n_voltages = 129,
 456         .ops = &rpm_smps_ldo_ops,
 457 };
 458
 459 static const struct regulator_desc pms405_pldo150 = {
 460         .linear_ranges = (struct regulator_linear_range[]) {
 461                 REGULATOR_LINEAR_RANGE(1664000, 0, 128, 16000),
 462         },
 463         .n_linear_ranges = 1,
 464         .n_voltages = 129,
 465         .ops = &rpm_smps_ldo_ops,
 466 };
 467
 468 static const struct regulator_desc pms405_pldo600 = {
 469         .linear_ranges = (struct regulator_linear_range[]) {
 470                 REGULATOR_LINEAR_RANGE(1256000, 0, 98, 8000),
 471         },
 472         .n_linear_ranges = 1,
 473         .n_voltages = 99,
 474         .ops = &rpm_smps_ldo_ops,
 475 };
 476
 477 struct rpm_regulator_data {
 478         const char *name;
 479         u32 type;
 480         u32 id;
 481         const struct regulator_desc *desc;
 482         const char *supply;
 483 };
 484
 485 static const struct rpm_regulator_data rpm_pm8841_regulators[] = {
 486         { "s1", QCOM_SMD_RPM_SMPB, 1, &pm8x41_hfsmps, "vdd_s1" },
 487         { "s2", QCOM_SMD_RPM_SMPB, 2, &pm8841_ftsmps, "vdd_s2" },
 488         { "s3", QCOM_SMD_RPM_SMPB, 3, &pm8x41_hfsmps, "vdd_s3" },
 489         { "s4", QCOM_SMD_RPM_SMPB, 4, &pm8841_ftsmps, "vdd_s4" },
 490         { "s5", QCOM_SMD_RPM_SMPB, 5, &pm8841_ftsmps, "vdd_s5" },
 491         { "s6", QCOM_SMD_RPM_SMPB, 6, &pm8841_ftsmps, "vdd_s6" },
 492         { "s7", QCOM_SMD_RPM_SMPB, 7, &pm8841_ftsmps, "vdd_s7" },
 493         { "s8", QCOM_SMD_RPM_SMPB, 8, &pm8841_ftsmps, "vdd_s8" },
 494         {}
 495 };
 496
 497 static const struct rpm_regulator_data rpm_pm8916_regulators[] = {
 498         { "s1", QCOM_SMD_RPM_SMPA, 1, &pm8916_buck_lvo_smps, "vdd_s1" },
 499         { "s2", QCOM_SMD_RPM_SMPA, 2, &pm8916_buck_lvo_smps, "vdd_s2" },
 500         { "s3", QCOM_SMD_RPM_SMPA, 3, &pm8916_buck_lvo_smps, "vdd_s3" },
 501         { "s4", QCOM_SMD_RPM_SMPA, 4, &pm8916_buck_hvo_smps, "vdd_s4" },
 502         { "l1", QCOM_SMD_RPM_LDOA, 1, &pm8916_nldo, "vdd_l1_l2_l3" },
 503         { "l2", QCOM_SMD_RPM_LDOA, 2, &pm8916_nldo, "vdd_l1_l2_l3" },
 504         { "l3", QCOM_SMD_RPM_LDOA, 3, &pm8916_nldo, "vdd_l1_l2_l3" },
 505         { "l4", QCOM_SMD_RPM_LDOA, 4, &pm8916_pldo, "vdd_l4_l5_l6" },
 506         { "l5", QCOM_SMD_RPM_LDOA, 5, &pm8916_pldo, "vdd_l4_l5_l6" },
 507         { "l6", QCOM_SMD_RPM_LDOA, 6, &pm8916_pldo, "vdd_l4_l5_l6" },
 508         { "l7", QCOM_SMD_RPM_LDOA, 7, &pm8916_pldo, "vdd_l7" },
 509         { "l8", QCOM_SMD_RPM_LDOA, 8, &pm8916_pldo, "vdd_l8_l9_l10_l11_l12_l13_l14_l15_l16_l17_l18" },
 510         { "l9", QCOM_SMD_RPM_LDOA, 9, &pm8916_pldo, "vdd_l8_l9_l10_l11_l12_l13_l14_l15_l16_l17_l18" },
 511         { "l10", QCOM_SMD_RPM_LDOA, 10, &pm8916_pldo, "vdd_l8_l9_l10_l11_l12_l13_l14_l15_l16_l17_l18"},
 512         { "l11", QCOM_SMD_RPM_LDOA, 11, &pm8916_pldo, "vdd_l8_l9_l10_l11_l12_l13_l14_l15_l16_l17_l18"},
 513         { "l12", QCOM_SMD_RPM_LDOA, 12, &pm8916_pldo, "vdd_l8_l9_l10_l11_l12_l13_l14_l15_l16_l17_l18"},
 514         { "l13", QCOM_SMD_RPM_LDOA, 13, &pm8916_pldo, "vdd_l8_l9_l10_l11_l12_l13_l14_l15_l16_l17_l18"},
 515         { "l14", QCOM_SMD_RPM_LDOA, 14, &pm8916_pldo, "vdd_l8_l9_l10_l11_l12_l13_l14_l15_l16_l17_l18"},
 516         { "l15", QCOM_SMD_RPM_LDOA, 15, &pm8916_pldo, "vdd_l8_l9_l10_l11_l12_l13_l14_l15_l16_l17_l18"},
 517         { "l16", QCOM_SMD_RPM_LDOA, 16, &pm8916_pldo, "vdd_l8_l9_l10_l11_l12_l13_l14_l15_l16_l17_l18"},
 518         { "l17", QCOM_SMD_RPM_LDOA, 17, &pm8916_pldo, "vdd_l8_l9_l10_l11_l12_l13_l14_l15_l16_l17_l18"},
 519         { "l18", QCOM_SMD_RPM_LDOA, 18, &pm8916_pldo, "vdd_l8_l9_l10_l11_l12_l13_l14_l15_l16_l17_l18"},
 520         {}
 521 };
 522
 523 static const struct rpm_regulator_data rpm_pm8941_regulators[] = {
 524         { "s1", QCOM_SMD_RPM_SMPA, 1, &pm8x41_hfsmps, "vdd_s1" },
 525         { "s2", QCOM_SMD_RPM_SMPA, 2, &pm8x41_hfsmps, "vdd_s2" },
 526         { "s3", QCOM_SMD_RPM_SMPA, 3, &pm8x41_hfsmps, "vdd_s3" },
 527         { "s4", QCOM_SMD_RPM_BOOST, 1, &pm8941_boost },
 528
 529         { "l1", QCOM_SMD_RPM_LDOA, 1, &pm8941_nldo, "vdd_l1_l3" },
 530         { "l2", QCOM_SMD_RPM_LDOA, 2, &pm8941_nldo, "vdd_l2_lvs1_2_3" },
 531         { "l3", QCOM_SMD_RPM_LDOA, 3, &pm8941_nldo, "vdd_l1_l3" },
 532         { "l4", QCOM_SMD_RPM_LDOA, 4, &pm8941_nldo, "vdd_l4_l11" },
 533         { "l5", QCOM_SMD_RPM_LDOA, 5, &pm8941_lnldo, "vdd_l5_l7" },
 534         { "l6", QCOM_SMD_RPM_LDOA, 6, &pm8941_pldo, "vdd_l6_l12_l14_l15" },
 535         { "l7", QCOM_SMD_RPM_LDOA, 7, &pm8941_lnldo, "vdd_l5_l7" },
 536         { "l8", QCOM_SMD_RPM_LDOA, 8, &pm8941_pldo, "vdd_l8_l16_l18_l19" },
 537         { "l9", QCOM_SMD_RPM_LDOA, 9, &pm8941_pldo, "vdd_l9_l10_l17_l22" },
 538         { "l10", QCOM_SMD_RPM_LDOA, 10, &pm8941_pldo, "vdd_l9_l10_l17_l22" },
 539         { "l11", QCOM_SMD_RPM_LDOA, 11, &pm8941_nldo, "vdd_l4_l11" },
 540         { "l12", QCOM_SMD_RPM_LDOA, 12, &pm8941_pldo, "vdd_l6_l12_l14_l15" },
 541         { "l13", QCOM_SMD_RPM_LDOA, 13, &pm8941_pldo, "vdd_l13_l20_l23_l24" },
 542         { "l14", QCOM_SMD_RPM_LDOA, 14, &pm8941_pldo, "vdd_l6_l12_l14_l15" },
 543         { "l15", QCOM_SMD_RPM_LDOA, 15, &pm8941_pldo, "vdd_l6_l12_l14_l15" },
 544         { "l16", QCOM_SMD_RPM_LDOA, 16, &pm8941_pldo, "vdd_l8_l16_l18_l19" },
 545         { "l17", QCOM_SMD_RPM_LDOA, 17, &pm8941_pldo, "vdd_l9_l10_l17_l22" },
 546         { "l18", QCOM_SMD_RPM_LDOA, 18, &pm8941_pldo, "vdd_l8_l16_l18_l19" },
 547         { "l19", QCOM_SMD_RPM_LDOA, 19, &pm8941_pldo, "vdd_l8_l16_l18_l19" },
 548         { "l20", QCOM_SMD_RPM_LDOA, 20, &pm8941_pldo, "vdd_l13_l20_l23_l24" },
 549         { "l21", QCOM_SMD_RPM_LDOA, 21, &pm8941_pldo, "vdd_l21" },
 550         { "l22", QCOM_SMD_RPM_LDOA, 22, &pm8941_pldo, "vdd_l9_l10_l17_l22" },
 551         { "l23", QCOM_SMD_RPM_LDOA, 23, &pm8941_pldo, "vdd_l13_l20_l23_l24" },
 552         { "l24", QCOM_SMD_RPM_LDOA, 24, &pm8941_pldo, "vdd_l13_l20_l23_l24" },
 553
 554         { "lvs1", QCOM_SMD_RPM_VSA, 1, &pm8941_switch, "vdd_l2_lvs1_2_3" },
 555         { "lvs2", QCOM_SMD_RPM_VSA, 2, &pm8941_switch, "vdd_l2_lvs1_2_3" },
 556         { "lvs3", QCOM_SMD_RPM_VSA, 3, &pm8941_switch, "vdd_l2_lvs1_2_3" },
 557
 558         { "5vs1", QCOM_SMD_RPM_VSA, 4, &pm8941_switch, "vin_5vs" },
 559         { "5vs2", QCOM_SMD_RPM_VSA, 5, &pm8941_switch, "vin_5vs" },
 560
 561         {}
 562 };
 563
 564 static const struct rpm_regulator_data rpm_pma8084_regulators[] = {
 565         { "s1", QCOM_SMD_RPM_SMPA, 1, &pma8084_ftsmps, "vdd_s1" },
 566         { "s2", QCOM_SMD_RPM_SMPA, 2, &pma8084_ftsmps, "vdd_s2" },
 567         { "s3", QCOM_SMD_RPM_SMPA, 3, &pma8084_hfsmps, "vdd_s3" },
 568         { "s4", QCOM_SMD_RPM_SMPA, 4, &pma8084_hfsmps, "vdd_s4" },
 569         { "s5", QCOM_SMD_RPM_SMPA, 5, &pma8084_hfsmps, "vdd_s5" },
 570         { "s6", QCOM_SMD_RPM_SMPA, 6, &pma8084_ftsmps, "vdd_s6" },
 571         { "s7", QCOM_SMD_RPM_SMPA, 7, &pma8084_ftsmps, "vdd_s7" },
 572         { "s8", QCOM_SMD_RPM_SMPA, 8, &pma8084_ftsmps, "vdd_s8" },
 573         { "s9", QCOM_SMD_RPM_SMPA, 9, &pma8084_ftsmps, "vdd_s9" },
 574         { "s10", QCOM_SMD_RPM_SMPA, 10, &pma8084_ftsmps, "vdd_s10" },
 575         { "s11", QCOM_SMD_RPM_SMPA, 11, &pma8084_ftsmps, "vdd_s11" },
 576         { "s12", QCOM_SMD_RPM_SMPA, 12, &pma8084_ftsmps, "vdd_s12" },
 577
 578         { "l1", QCOM_SMD_RPM_LDOA, 1, &pma8084_nldo, "vdd_l1_l11" },
 579         { "l2", QCOM_SMD_RPM_LDOA, 2, &pma8084_nldo, "vdd_l2_l3_l4_l27" },
 580         { "l3", QCOM_SMD_RPM_LDOA, 3, &pma8084_nldo, "vdd_l2_l3_l4_l27" },
 581         { "l4", QCOM_SMD_RPM_LDOA, 4, &pma8084_nldo, "vdd_l2_l3_l4_l27" },
 582         { "l5", QCOM_SMD_RPM_LDOA, 5, &pma8084_pldo, "vdd_l5_l7" },
 583         { "l6", QCOM_SMD_RPM_LDOA, 6, &pma8084_pldo, "vdd_l6_l12_l14_l15_l26" },
 584         { "l7", QCOM_SMD_RPM_LDOA, 7, &pma8084_pldo, "vdd_l5_l7" },
 585         { "l8", QCOM_SMD_RPM_LDOA, 8, &pma8084_pldo, "vdd_l8" },
 586         { "l9", QCOM_SMD_RPM_LDOA, 9, &pma8084_pldo, "vdd_l9_l10_l13_l20_l23_l24" },
 587         { "l10", QCOM_SMD_RPM_LDOA, 10, &pma8084_pldo, "vdd_l9_l10_l13_l20_l23_l24" },
 588         { "l11", QCOM_SMD_RPM_LDOA, 11, &pma8084_nldo, "vdd_l1_l11" },
 589         { "l12", QCOM_SMD_RPM_LDOA, 12, &pma8084_pldo, "vdd_l6_l12_l14_l15_l26" },
 590         { "l13", QCOM_SMD_RPM_LDOA, 13, &pma8084_pldo, "vdd_l9_l10_l13_l20_l23_l24" },
 591         { "l14", QCOM_SMD_RPM_LDOA, 14, &pma8084_pldo, "vdd_l6_l12_l14_l15_l26" },
 592         { "l15", QCOM_SMD_RPM_LDOA, 15, &pma8084_pldo, "vdd_l6_l12_l14_l15_l26" },
 593         { "l16", QCOM_SMD_RPM_LDOA, 16, &pma8084_pldo, "vdd_l16_l25" },
 594         { "l17", QCOM_SMD_RPM_LDOA, 17, &pma8084_pldo, "vdd_l17" },
 595         { "l18", QCOM_SMD_RPM_LDOA, 18, &pma8084_pldo, "vdd_l18" },
 596         { "l19", QCOM_SMD_RPM_LDOA, 19, &pma8084_pldo, "vdd_l19" },
 597         { "l20", QCOM_SMD_RPM_LDOA, 20, &pma8084_pldo, "vdd_l9_l10_l13_l20_l23_l24" },
 598         { "l21", QCOM_SMD_RPM_LDOA, 21, &pma8084_pldo, "vdd_l21" },
 599         { "l22", QCOM_SMD_RPM_LDOA, 22, &pma8084_pldo, "vdd_l22" },
 600         { "l23", QCOM_SMD_RPM_LDOA, 23, &pma8084_pldo, "vdd_l9_l10_l13_l20_l23_l24" },
 601         { "l24", QCOM_SMD_RPM_LDOA, 24, &pma8084_pldo, "vdd_l9_l10_l13_l20_l23_l24" },
 602         { "l25", QCOM_SMD_RPM_LDOA, 25, &pma8084_pldo, "vdd_l16_l25" },
 603         { "l26", QCOM_SMD_RPM_LDOA, 26, &pma8084_pldo, "vdd_l6_l12_l14_l15_l26" },
 604         { "l27", QCOM_SMD_RPM_LDOA, 27, &pma8084_nldo, "vdd_l2_l3_l4_l27" },
 605
 606         { "lvs1", QCOM_SMD_RPM_VSA, 1, &pma8084_switch },
 607         { "lvs2", QCOM_SMD_RPM_VSA, 2, &pma8084_switch },
 608         { "lvs3", QCOM_SMD_RPM_VSA, 3, &pma8084_switch },
 609         { "lvs4", QCOM_SMD_RPM_VSA, 4, &pma8084_switch },
 610         { "5vs1", QCOM_SMD_RPM_VSA, 5, &pma8084_switch },
 611
 612         {}
 613 };
 614
 615 static const struct rpm_regulator_data rpm_pm8994_regulators[] = {
 616         { "s1", QCOM_SMD_RPM_SMPA, 1, &pm8994_ftsmps, "vdd_s1" },
 617         { "s2", QCOM_SMD_RPM_SMPA, 2, &pm8994_ftsmps, "vdd_s2" },
 618         { "s3", QCOM_SMD_RPM_SMPA, 3, &pm8994_hfsmps, "vdd_s3" },
 619         { "s4", QCOM_SMD_RPM_SMPA, 4, &pm8994_hfsmps, "vdd_s4" },
 620         { "s5", QCOM_SMD_RPM_SMPA, 5, &pm8994_hfsmps, "vdd_s5" },
 621         { "s6", QCOM_SMD_RPM_SMPA, 6, &pm8994_ftsmps, "vdd_s6" },
 622         { "s7", QCOM_SMD_RPM_SMPA, 7, &pm8994_hfsmps, "vdd_s7" },
 623         { "s8", QCOM_SMD_RPM_SMPA, 8, &pm8994_ftsmps, "vdd_s8" },
 624         { "s9", QCOM_SMD_RPM_SMPA, 9, &pm8994_ftsmps, "vdd_s9" },
 625         { "s10", QCOM_SMD_RPM_SMPA, 10, &pm8994_ftsmps, "vdd_s10" },
 626         { "s11", QCOM_SMD_RPM_SMPA, 11, &pm8994_ftsmps, "vdd_s11" },
 627         { "s12", QCOM_SMD_RPM_SMPA, 12, &pm8994_ftsmps, "vdd_s12" },
 628         { "l1", QCOM_SMD_RPM_LDOA, 1, &pm8994_nldo, "vdd_l1" },
 629         { "l2", QCOM_SMD_RPM_LDOA, 2, &pm8994_nldo, "vdd_l2_l26_l28" },
 630         { "l3", QCOM_SMD_RPM_LDOA, 3, &pm8994_nldo, "vdd_l3_l11" },
 631         { "l4", QCOM_SMD_RPM_LDOA, 4, &pm8994_nldo, "vdd_l4_l27_l31" },
 632         { "l5", QCOM_SMD_RPM_LDOA, 5, &pm8994_lnldo, "vdd_l5_l7" },
 633         { "l6", QCOM_SMD_RPM_LDOA, 6, &pm8994_pldo, "vdd_l6_l12_l32" },
 634         { "l7", QCOM_SMD_RPM_LDOA, 7, &pm8994_lnldo, "vdd_l5_l7" },
 635         { "l8", QCOM_SMD_RPM_LDOA, 8, &pm8994_pldo, "vdd_l8_l16_l30" },
 636         { "l9", QCOM_SMD_RPM_LDOA, 9, &pm8994_pldo, "vdd_l9_l10_l18_l22" },
 637         { "l10", QCOM_SMD_RPM_LDOA, 10, &pm8994_pldo, "vdd_l9_l10_l18_l22" },
 638         { "l11", QCOM_SMD_RPM_LDOA, 11, &pm8994_nldo, "vdd_l3_l11" },
 639         { "l12", QCOM_SMD_RPM_LDOA, 12, &pm8994_pldo, "vdd_l6_l12_l32" },
 640         { "l13", QCOM_SMD_RPM_LDOA, 13, &pm8994_pldo, "vdd_l13_l19_l23_l24" },
 641         { "l14", QCOM_SMD_RPM_LDOA, 14, &pm8994_pldo, "vdd_l14_l15" },
 642         { "l15", QCOM_SMD_RPM_LDOA, 15, &pm8994_pldo, "vdd_l14_l15" },
 643         { "l16", QCOM_SMD_RPM_LDOA, 16, &pm8994_pldo, "vdd_l8_l16_l30" },
 644         { "l17", QCOM_SMD_RPM_LDOA, 17, &pm8994_pldo, "vdd_l17_l29" },
 645         { "l18", QCOM_SMD_RPM_LDOA, 18, &pm8994_pldo, "vdd_l9_l10_l18_l22" },
 646         { "l19", QCOM_SMD_RPM_LDOA, 19, &pm8994_pldo, "vdd_l13_l19_l23_l24" },
 647         { "l20", QCOM_SMD_RPM_LDOA, 20, &pm8994_pldo, "vdd_l20_l21" },
 648         { "l21", QCOM_SMD_RPM_LDOA, 21, &pm8994_pldo, "vdd_l20_l21" },
 649         { "l22", QCOM_SMD_RPM_LDOA, 22, &pm8994_pldo, "vdd_l9_l10_l18_l22" },
 650         { "l23", QCOM_SMD_RPM_LDOA, 23, &pm8994_pldo, "vdd_l13_l19_l23_l24" },
 651         { "l24", QCOM_SMD_RPM_LDOA, 24, &pm8994_pldo, "vdd_l13_l19_l23_l24" },
 652         { "l25", QCOM_SMD_RPM_LDOA, 25, &pm8994_pldo, "vdd_l25" },
 653         { "l26", QCOM_SMD_RPM_LDOA, 26, &pm8994_nldo, "vdd_l2_l26_l28" },
 654         { "l27", QCOM_SMD_RPM_LDOA, 27, &pm8994_nldo, "vdd_l4_l27_l31" },
 655         { "l28", QCOM_SMD_RPM_LDOA, 28, &pm8994_nldo, "vdd_l2_l26_l28" },
 656         { "l29", QCOM_SMD_RPM_LDOA, 29, &pm8994_pldo, "vdd_l17_l29" },
 657         { "l30", QCOM_SMD_RPM_LDOA, 30, &pm8994_pldo, "vdd_l8_l16_l30" },
 658         { "l31", QCOM_SMD_RPM_LDOA, 31, &pm8994_nldo, "vdd_l4_l27_l31" },
 659         { "l32", QCOM_SMD_RPM_LDOA, 32, &pm8994_pldo, "vdd_l6_l12_l32" },
 660         { "lvs1", QCOM_SMD_RPM_VSA, 1, &pm8994_switch, "vdd_lvs1_2" },
 661         { "lvs2", QCOM_SMD_RPM_VSA, 2, &pm8994_switch, "vdd_lvs1_2" },
 662
 663         {}
 664 };
 665
 666 static const struct rpm_regulator_data rpm_pm8998_regulators[] = {
 667         { "s1", QCOM_SMD_RPM_SMPA, 1, &pm8998_ftsmps, "vdd_s1" },
 668         { "s2", QCOM_SMD_RPM_SMPA, 2, &pm8998_ftsmps, "vdd_s2" },
 669         { "s3", QCOM_SMD_RPM_SMPA, 3, &pm8998_hfsmps, "vdd_s3" },
 670         { "s4", QCOM_SMD_RPM_SMPA, 4, &pm8998_hfsmps, "vdd_s4" },
 671         { "s5", QCOM_SMD_RPM_SMPA, 5, &pm8998_hfsmps, "vdd_s5" },
 672         { "s6", QCOM_SMD_RPM_SMPA, 6, &pm8998_ftsmps, "vdd_s6" },
 673         { "s7", QCOM_SMD_RPM_SMPA, 7, &pm8998_ftsmps, "vdd_s7" },
 674         { "s8", QCOM_SMD_RPM_SMPA, 8, &pm8998_ftsmps, "vdd_s8" },
 675         { "s9", QCOM_SMD_RPM_SMPA, 9, &pm8998_ftsmps, "vdd_s9" },
 676         { "s10", QCOM_SMD_RPM_SMPA, 10, &pm8998_ftsmps, "vdd_s10" },
 677         { "s11", QCOM_SMD_RPM_SMPA, 11, &pm8998_ftsmps, "vdd_s11" },
 678         { "s12", QCOM_SMD_RPM_SMPA, 12, &pm8998_ftsmps, "vdd_s12" },
 679         { "s13", QCOM_SMD_RPM_SMPA, 13, &pm8998_ftsmps, "vdd_s13" },
 680         { "l1", QCOM_SMD_RPM_LDOA, 1, &pm8998_nldo, "vdd_l1_l27" },
 681         { "l2", QCOM_SMD_RPM_LDOA, 2, &pm8998_nldo, "vdd_l2_l8_l17" },
 682         { "l3", QCOM_SMD_RPM_LDOA, 3, &pm8998_nldo, "vdd_l3_l11" },
 683         { "l4", QCOM_SMD_RPM_LDOA, 4, &pm8998_nldo, "vdd_l4_l5" },
 684         { "l5", QCOM_SMD_RPM_LDOA, 5, &pm8998_nldo, "vdd_l4_l5" },
 685         { "l6", QCOM_SMD_RPM_LDOA, 6, &pm8998_pldo, "vdd_l6" },
 686         { "l7", QCOM_SMD_RPM_LDOA, 7, &pm8998_pldo_lv, "vdd_l7_l12_l14_l15" },
 687         { "l8", QCOM_SMD_RPM_LDOA, 8, &pm8998_nldo, "vdd_l2_l8_l17" },
 688         { "l9", QCOM_SMD_RPM_LDOA, 9, &pm8998_pldo, "vdd_l9" },
 689         { "l10", QCOM_SMD_RPM_LDOA, 10, &pm8998_pldo, "vdd_l10_l23_l25" },
 690         { "l11", QCOM_SMD_RPM_LDOA, 11, &pm8998_nldo, "vdd_l3_l11" },
 691         { "l12", QCOM_SMD_RPM_LDOA, 12, &pm8998_pldo_lv, "vdd_l7_l12_l14_l15" },
 692         { "l13", QCOM_SMD_RPM_LDOA, 13, &pm8998_pldo, "vdd_l13_l19_l21" },
 693         { "l14", QCOM_SMD_RPM_LDOA, 14, &pm8998_pldo_lv, "vdd_l7_l12_l14_l15" },
 694         { "l15", QCOM_SMD_RPM_LDOA, 15, &pm8998_pldo_lv, "vdd_l7_l12_l14_l15" },
 695         { "l16", QCOM_SMD_RPM_LDOA, 16, &pm8998_pldo, "vdd_l16_l28" },
 696         { "l17", QCOM_SMD_RPM_LDOA, 17, &pm8998_nldo, "vdd_l2_l8_l17" },
 697         { "l18", QCOM_SMD_RPM_LDOA, 18, &pm8998_pldo, "vdd_l18_l22" },
 698         { "l19", QCOM_SMD_RPM_LDOA, 19, &pm8998_pldo, "vdd_l13_l19_l21" },
 699         { "l20", QCOM_SMD_RPM_LDOA, 20, &pm8998_pldo, "vdd_l20_l24" },
 700         { "l21", QCOM_SMD_RPM_LDOA, 21, &pm8998_pldo, "vdd_l13_l19_l21" },
 701         { "l22", QCOM_SMD_RPM_LDOA, 22, &pm8998_pldo, "vdd_l18_l22" },
 702         { "l23", QCOM_SMD_RPM_LDOA, 23, &pm8998_pldo, "vdd_l10_l23_l25" },
 703         { "l24", QCOM_SMD_RPM_LDOA, 24, &pm8998_pldo, "vdd_l20_l24" },
 704         { "l25", QCOM_SMD_RPM_LDOA, 25, &pm8998_pldo, "vdd_l10_l23_l25" },
 705         { "l26", QCOM_SMD_RPM_LDOA, 26, &pm8998_nldo, "vdd_l26" },
 706         { "l27", QCOM_SMD_RPM_LDOA, 27, &pm8998_nldo, "vdd_l1_l27" },
 707         { "l28", QCOM_SMD_RPM_LDOA, 28, &pm8998_pldo, "vdd_l16_l28" },
 708         { "lvs1", QCOM_SMD_RPM_VSA, 1, &pm8998_switch, "vdd_lvs1_lvs2" },
 709         { "lvs2", QCOM_SMD_RPM_VSA, 2, &pm8998_switch, "vdd_lvs1_lvs2" },
 710         {}
 711 };
 712
 713 static const struct rpm_regulator_data rpm_pmi8998_regulators[] = {
 714         { "bob", QCOM_SMD_RPM_BOBB, 1, &pmi8998_bob, "vdd_bob" },
 715         {}
 716 };
 717
 718 static const struct rpm_regulator_data rpm_pms405_regulators[] = {
 719         { "s1", QCOM_SMD_RPM_SMPA, 1, &pms405_hfsmps3, "vdd_s1" },
 720         { "s2", QCOM_SMD_RPM_SMPA, 2, &pms405_hfsmps3, "vdd_s2" },
 721         { "s3", QCOM_SMD_RPM_SMPA, 3, &pms405_hfsmps3, "vdd_s3" },
 722         { "s4", QCOM_SMD_RPM_SMPA, 4, &pms405_hfsmps3, "vdd_s4" },
 723         { "s5", QCOM_SMD_RPM_SMPA, 5, &pms405_hfsmps3, "vdd_s5" },
 724         { "l1", QCOM_SMD_RPM_LDOA, 1, &pms405_nldo1200, "vdd_l1_l2" },
 725         { "l2", QCOM_SMD_RPM_LDOA, 2, &pms405_nldo1200, "vdd_l1_l2" },
 726         { "l3", QCOM_SMD_RPM_LDOA, 3, &pms405_nldo1200, "vdd_l3_l8" },
 727         { "l4", QCOM_SMD_RPM_LDOA, 4, &pms405_nldo300, "vdd_l4" },
 728         { "l5", QCOM_SMD_RPM_LDOA, 5, &pms405_pldo600, "vdd_l5_l6" },
 729         { "l6", QCOM_SMD_RPM_LDOA, 6, &pms405_pldo600, "vdd_l5_l6" },
 730         { "l7", QCOM_SMD_RPM_LDOA, 7, &pms405_pldo150, "vdd_l7" },
 731         { "l8", QCOM_SMD_RPM_LDOA, 8, &pms405_nldo1200, "vdd_l3_l8" },
 732         { "l9", QCOM_SMD_RPM_LDOA, 9, &pms405_nldo1200, "vdd_l9" },
 733         { "l10", QCOM_SMD_RPM_LDOA, 10, &pms405_pldo50, "vdd_l10_l11_l12_l13" },
 734         { "l11", QCOM_SMD_RPM_LDOA, 11, &pms405_pldo150, "vdd_l10_l11_l12_l13" },
 735         { "l12", QCOM_SMD_RPM_LDOA, 12, &pms405_pldo150, "vdd_l10_l11_l12_l13" },
 736         { "l13", QCOM_SMD_RPM_LDOA, 13, &pms405_pldo150, "vdd_l10_l11_l12_l13" },
 737         {}
 738 };
 739
 740 static const struct of_device_id rpm_of_match[] = {
 741         { .compatible = "qcom,rpm-pm8841-regulators", .data = &rpm_pm8841_regulators },
 742         { .compatible = "qcom,rpm-pm8916-regulators", .data = &rpm_pm8916_regulators },
 743         { .compatible = "qcom,rpm-pm8941-regulators", .data = &rpm_pm8941_regulators },
 744         { .compatible = "qcom,rpm-pm8994-regulators", .data = &rpm_pm8994_regulators },
 745         { .compatible = "qcom,rpm-pm8998-regulators", .data = &rpm_pm8998_regulators },
 746         { .compatible = "qcom,rpm-pma8084-regulators", .data = &rpm_pma8084_regulators },
 747         { .compatible = "qcom,rpm-pmi8998-regulators", .data = &rpm_pmi8998_regulators },
 748         { .compatible = "qcom,rpm-pms405-regulators", .data = &rpm_pms405_regulators },
 749         {}
 750 };
 751 MODULE_DEVICE_TABLE(of, rpm_of_match);
 752
 753 static int rpm_reg_probe(struct platform_device *pdev)
 754 {
 755         const struct rpm_regulator_data *reg;
 756         const struct of_device_id *match;
 757         struct regulator_config config = { };
 758         struct regulator_dev *rdev;
 759         struct qcom_rpm_reg *vreg;
 760         struct qcom_smd_rpm *rpm;
 761
 762         rpm = dev_get_drvdata(pdev->dev.parent);
 763         if (!rpm) {
 764                 dev_err(&pdev->dev, "unable to retrieve handle to rpm\n");
 765                 return -ENODEV;
 766         }
 767
 768         match = of_match_device(rpm_of_match, &pdev->dev);
 769         if (!match) {
 770                 dev_err(&pdev->dev, "failed to match device\n");
 771                 return -ENODEV;
 772         }
 773
 774         for (reg = match->data; reg->name; reg++) {
 775                 vreg = devm_kzalloc(&pdev->dev, sizeof(*vreg), GFP_KERNEL);
 776                 if (!vreg)
 777                         return -ENOMEM;
 778
 779                 vreg->dev = &pdev->dev;
 780                 vreg->type = reg->type;
 781                 vreg->id = reg->id;
 782                 vreg->rpm = rpm;
 783
 784                 memcpy(&vreg->desc, reg->desc, sizeof(vreg->desc));
 785
 786                 vreg->desc.id = -1;
 787                 vreg->desc.owner = THIS_MODULE;
 788                 vreg->desc.type = REGULATOR_VOLTAGE;
 789                 vreg->desc.name = reg->name;
 790                 vreg->desc.supply_name = reg->supply;
 791                 vreg->desc.of_match = reg->name;
 792
 793                 config.dev = &pdev->dev;
 794                 config.driver_data = vreg;
 795                 rdev = devm_regulator_register(&pdev->dev, &vreg->desc, &config);
 796                 if (IS_ERR(rdev)) {
 797                         dev_err(&pdev->dev, "failed to register %s\n", reg->name);
 798                         return PTR_ERR(rdev);
 799                 }
 800         }
 801
 802         return 0;
 803 }
 804
 805 static struct platform_driver rpm_reg_driver = {
 806         .probe = rpm_reg_probe,
 807         .driver = {
 808                 .name  = "qcom_rpm_smd_regulator",
 809                 .of_match_table = rpm_of_match,
 810         },
 811 };
 812
 813 static int __init rpm_reg_init(void)
 814 {
 815         return platform_driver_register(&rpm_reg_driver);
 816 }
 817 subsys_initcall(rpm_reg_init);
 818
 819 static void __exit rpm_reg_exit(void)
 820 {
 821         platform_driver_unregister(&rpm_reg_driver);
 822 }
 823 module_exit(rpm_reg_exit)
 824
 825 MODULE_DESCRIPTION("Qualcomm RPM regulator driver");
 826 MODULE_LICENSE("GPL v2");