drivers/regulator/qcom_rpm-regulator.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2014, Sony Mobile Communications AB.
   4  * Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
   5  */
   6
   7 #include <linux/module.h>
   8 #include <linux/platform_device.h>
   9 #include <linux/of.h>
  10 #include <linux/of_device.h>
  11 #include <linux/regulator/driver.h>
  12 #include <linux/regulator/machine.h>
  13 #include <linux/regulator/of_regulator.h>
  14 #include <linux/mfd/qcom_rpm.h>
  15
  16 #include <dt-bindings/mfd/qcom-rpm.h>
  17
  18 #define MAX_REQUEST_LEN 2
  19
  20 struct request_member {
  21         int             word;
  22         unsigned int    mask;
  23         int             shift;
  24 };
  25
  26 struct rpm_reg_parts {
  27         struct request_member mV;               /* used if voltage is in mV */
  28         struct request_member uV;               /* used if voltage is in uV */
  29         struct request_member ip;               /* peak current in mA */
  30         struct request_member pd;               /* pull down enable */
  31         struct request_member ia;               /* average current in mA */
  32         struct request_member fm;               /* force mode */
  33         struct request_member pm;               /* power mode */
  34         struct request_member pc;               /* pin control */
  35         struct request_member pf;               /* pin function */
  36         struct request_member enable_state;     /* NCP and switch */
  37         struct request_member comp_mode;        /* NCP */
  38         struct request_member freq;             /* frequency: NCP and SMPS */
  39         struct request_member freq_clk_src;     /* clock source: SMPS */
  40         struct request_member hpm;              /* switch: control OCP and SS */
  41         int request_len;
  42 };
  43
  44 #define FORCE_MODE_IS_2_BITS(reg) \
  45         (((reg)->parts->fm.mask >> (reg)->parts->fm.shift) == 3)
  46
  47 struct qcom_rpm_reg {
  48         struct qcom_rpm *rpm;
  49
  50         struct mutex lock;
  51         struct device *dev;
  52         struct regulator_desc desc;
  53         const struct rpm_reg_parts *parts;
  54
  55         int resource;
  56         u32 val[MAX_REQUEST_LEN];
  57
  58         int uV;
  59         int is_enabled;
  60
  61         bool supports_force_mode_auto;
  62         bool supports_force_mode_bypass;
  63 };
  64
  65 static const struct rpm_reg_parts rpm8660_ldo_parts = {
  66         .request_len    = 2,
  67         .mV             = { 0, 0x00000FFF,  0 },
  68         .ip             = { 0, 0x00FFF000, 12 },
  69         .fm             = { 0, 0x03000000, 24 },
  70         .pc             = { 0, 0x3C000000, 26 },
  71         .pf             = { 0, 0xC0000000, 30 },
  72         .pd             = { 1, 0x00000001,  0 },
  73         .ia             = { 1, 0x00001FFE,  1 },
  74 };
  75
  76 static const struct rpm_reg_parts rpm8660_smps_parts = {
  77         .request_len    = 2,
  78         .mV             = { 0, 0x00000FFF,  0 },
  79         .ip             = { 0, 0x00FFF000, 12 },
  80         .fm             = { 0, 0x03000000, 24 },
  81         .pc             = { 0, 0x3C000000, 26 },
  82         .pf             = { 0, 0xC0000000, 30 },
  83         .pd             = { 1, 0x00000001,  0 },
  84         .ia             = { 1, 0x00001FFE,  1 },
  85         .freq           = { 1, 0x001FE000, 13 },
  86         .freq_clk_src   = { 1, 0x00600000, 21 },
  87 };
  88
  89 static const struct rpm_reg_parts rpm8660_switch_parts = {
  90         .request_len    = 1,
  91         .enable_state   = { 0, 0x00000001,  0 },
  92         .pd             = { 0, 0x00000002,  1 },
  93         .pc             = { 0, 0x0000003C,  2 },
  94         .pf             = { 0, 0x000000C0,  6 },
  95         .hpm            = { 0, 0x00000300,  8 },
  96 };
  97
  98 static const struct rpm_reg_parts rpm8660_ncp_parts = {
  99         .request_len    = 1,
 100         .mV             = { 0, 0x00000FFF,  0 },
 101         .enable_state   = { 0, 0x00001000, 12 },
 102         .comp_mode      = { 0, 0x00002000, 13 },
 103         .freq           = { 0, 0x003FC000, 14 },
 104 };
 105
 106 static const struct rpm_reg_parts rpm8960_ldo_parts = {
 107         .request_len    = 2,
 108         .uV             = { 0, 0x007FFFFF,  0 },
 109         .pd             = { 0, 0x00800000, 23 },
 110         .pc             = { 0, 0x0F000000, 24 },
 111         .pf             = { 0, 0xF0000000, 28 },
 112         .ip             = { 1, 0x000003FF,  0 },
 113         .ia             = { 1, 0x000FFC00, 10 },
 114         .fm             = { 1, 0x00700000, 20 },
 115 };
 116
 117 static const struct rpm_reg_parts rpm8960_smps_parts = {
 118         .request_len    = 2,
 119         .uV             = { 0, 0x007FFFFF,  0 },
 120         .pd             = { 0, 0x00800000, 23 },
 121         .pc             = { 0, 0x0F000000, 24 },
 122         .pf             = { 0, 0xF0000000, 28 },
 123         .ip             = { 1, 0x000003FF,  0 },
 124         .ia             = { 1, 0x000FFC00, 10 },
 125         .fm             = { 1, 0x00700000, 20 },
 126         .pm             = { 1, 0x00800000, 23 },
 127         .freq           = { 1, 0x1F000000, 24 },
 128         .freq_clk_src   = { 1, 0x60000000, 29 },
 129 };
 130
 131 static const struct rpm_reg_parts rpm8960_switch_parts = {
 132         .request_len    = 1,
 133         .enable_state   = { 0, 0x00000001,  0 },
 134         .pd             = { 0, 0x00000002,  1 },
 135         .pc             = { 0, 0x0000003C,  2 },
 136         .pf             = { 0, 0x000003C0,  6 },
 137         .hpm            = { 0, 0x00000C00, 10 },
 138 };
 139
 140 static const struct rpm_reg_parts rpm8960_ncp_parts = {
 141         .request_len    = 1,
 142         .uV             = { 0, 0x007FFFFF,  0 },
 143         .enable_state   = { 0, 0x00800000, 23 },
 144         .comp_mode      = { 0, 0x01000000, 24 },
 145         .freq           = { 0, 0x3E000000, 25 },
 146 };
 147
 148 /*
 149  * Physically available PMIC regulator voltage ranges
 150  */
 151 static const struct linear_range pldo_ranges[] = {
 152         REGULATOR_LINEAR_RANGE( 750000,   0,  59, 12500),
 153         REGULATOR_LINEAR_RANGE(1500000,  60, 123, 25000),
 154         REGULATOR_LINEAR_RANGE(3100000, 124, 160, 50000),
 155 };
 156
 157 static const struct linear_range nldo_ranges[] = {
 158         REGULATOR_LINEAR_RANGE( 750000,   0,  63, 12500),
 159 };
 160
 161 static const struct linear_range nldo1200_ranges[] = {
 162         REGULATOR_LINEAR_RANGE( 375000,   0,  59,  6250),
 163         REGULATOR_LINEAR_RANGE( 750000,  60, 123, 12500),
 164 };
 165
 166 static const struct linear_range smps_ranges[] = {
 167         REGULATOR_LINEAR_RANGE( 375000,   0,  29, 12500),
 168         REGULATOR_LINEAR_RANGE( 750000,  30,  89, 12500),
 169         REGULATOR_LINEAR_RANGE(1500000,  90, 153, 25000),
 170 };
 171
 172 static const struct linear_range ftsmps_ranges[] = {
 173         REGULATOR_LINEAR_RANGE( 350000,   0,   6, 50000),
 174         REGULATOR_LINEAR_RANGE( 700000,   7,  63, 12500),
 175         REGULATOR_LINEAR_RANGE(1500000,  64, 100, 50000),
 176 };
 177
 178 static const struct linear_range smb208_ranges[] = {
 179         REGULATOR_LINEAR_RANGE( 375000,   0,  29, 12500),
 180         REGULATOR_LINEAR_RANGE( 750000,  30,  89, 12500),
 181         REGULATOR_LINEAR_RANGE(1500000,  90, 153, 25000),
 182         REGULATOR_LINEAR_RANGE(3100000, 154, 234, 25000),
 183 };
 184
 185 static const struct linear_range ncp_ranges[] = {
 186         REGULATOR_LINEAR_RANGE(1500000,   0,  31, 50000),
 187 };
 188
 189 static int rpm_reg_write(struct qcom_rpm_reg *vreg,
 190                          const struct request_member *req,
 191                          const int value)
 192 {
 193         if (WARN_ON((value << req->shift) & ~req->mask))
 194                 return -EINVAL;
 195
 196         vreg->val[req->word] &= ~req->mask;
 197         vreg->val[req->word] |= value << req->shift;
 198
 199         return qcom_rpm_write(vreg->rpm,
 200                               QCOM_RPM_ACTIVE_STATE,
 201                               vreg->resource,
 202                               vreg->val,
 203                               vreg->parts->request_len);
 204 }
 205
 206 static int rpm_reg_set_mV_sel(struct regulator_dev *rdev,
 207                               unsigned selector)
 208 {
 209         struct qcom_rpm_reg *vreg = rdev_get_drvdata(rdev);
 210         const struct rpm_reg_parts *parts = vreg->parts;
 211         const struct request_member *req = &parts->mV;
 212         int ret = 0;
 213         int uV;
 214
 215         if (req->mask == 0)
 216                 return -EINVAL;
 217
 218         uV = regulator_list_voltage_linear_range(rdev, selector);
 219         if (uV < 0)
 220                 return uV;
 221
 222         mutex_lock(&vreg->lock);
 223         if (vreg->is_enabled)
 224                 ret = rpm_reg_write(vreg, req, uV / 1000);
 225
 226         if (!ret)
 227                 vreg->uV = uV;
 228         mutex_unlock(&vreg->lock);
 229
 230         return ret;
 231 }
 232
 233 static int rpm_reg_set_uV_sel(struct regulator_dev *rdev,
 234                               unsigned selector)
 235 {
 236         struct qcom_rpm_reg *vreg = rdev_get_drvdata(rdev);
 237         const struct rpm_reg_parts *parts = vreg->parts;
 238         const struct request_member *req = &parts->uV;
 239         int ret = 0;
 240         int uV;
 241
 242         if (req->mask == 0)
 243                 return -EINVAL;
 244
 245         uV = regulator_list_voltage_linear_range(rdev, selector);
 246         if (uV < 0)
 247                 return uV;
 248
 249         mutex_lock(&vreg->lock);
 250         if (vreg->is_enabled)
 251                 ret = rpm_reg_write(vreg, req, uV);
 252
 253         if (!ret)
 254                 vreg->uV = uV;
 255         mutex_unlock(&vreg->lock);
 256
 257         return ret;
 258 }
 259
 260 static int rpm_reg_get_voltage(struct regulator_dev *rdev)
 261 {
 262         struct qcom_rpm_reg *vreg = rdev_get_drvdata(rdev);
 263
 264         return vreg->uV;
 265 }
 266
 267 static int rpm_reg_mV_enable(struct regulator_dev *rdev)
 268 {
 269         struct qcom_rpm_reg *vreg = rdev_get_drvdata(rdev);
 270         const struct rpm_reg_parts *parts = vreg->parts;
 271         const struct request_member *req = &parts->mV;
 272         int ret;
 273
 274         if (req->mask == 0)
 275                 return -EINVAL;
 276
 277         mutex_lock(&vreg->lock);
 278         ret = rpm_reg_write(vreg, req, vreg->uV / 1000);
 279         if (!ret)
 280                 vreg->is_enabled = 1;
 281         mutex_unlock(&vreg->lock);
 282
 283         return ret;
 284 }
 285
 286 static int rpm_reg_uV_enable(struct regulator_dev *rdev)
 287 {
 288         struct qcom_rpm_reg *vreg = rdev_get_drvdata(rdev);
 289         const struct rpm_reg_parts *parts = vreg->parts;
 290         const struct request_member *req = &parts->uV;
 291         int ret;
 292
 293         if (req->mask == 0)
 294                 return -EINVAL;
 295
 296         mutex_lock(&vreg->lock);
 297         ret = rpm_reg_write(vreg, req, vreg->uV);
 298         if (!ret)
 299                 vreg->is_enabled = 1;
 300         mutex_unlock(&vreg->lock);
 301
 302         return ret;
 303 }
 304
 305 static int rpm_reg_switch_enable(struct regulator_dev *rdev)
 306 {
 307         struct qcom_rpm_reg *vreg = rdev_get_drvdata(rdev);
 308         const struct rpm_reg_parts *parts = vreg->parts;
 309         const struct request_member *req = &parts->enable_state;
 310         int ret;
 311
 312         if (req->mask == 0)
 313                 return -EINVAL;
 314
 315         mutex_lock(&vreg->lock);
 316         ret = rpm_reg_write(vreg, req, 1);
 317         if (!ret)
 318                 vreg->is_enabled = 1;
 319         mutex_unlock(&vreg->lock);
 320
 321         return ret;
 322 }
 323
 324 static int rpm_reg_mV_disable(struct regulator_dev *rdev)
 325 {
 326         struct qcom_rpm_reg *vreg = rdev_get_drvdata(rdev);
 327         const struct rpm_reg_parts *parts = vreg->parts;
 328         const struct request_member *req = &parts->mV;
 329         int ret;
 330
 331         if (req->mask == 0)
 332                 return -EINVAL;
 333
 334         mutex_lock(&vreg->lock);
 335         ret = rpm_reg_write(vreg, req, 0);
 336         if (!ret)
 337                 vreg->is_enabled = 0;
 338         mutex_unlock(&vreg->lock);
 339
 340         return ret;
 341 }
 342
 343 static int rpm_reg_uV_disable(struct regulator_dev *rdev)
 344 {
 345         struct qcom_rpm_reg *vreg = rdev_get_drvdata(rdev);
 346         const struct rpm_reg_parts *parts = vreg->parts;
 347         const struct request_member *req = &parts->uV;
 348         int ret;
 349
 350         if (req->mask == 0)
 351                 return -EINVAL;
 352
 353         mutex_lock(&vreg->lock);
 354         ret = rpm_reg_write(vreg, req, 0);
 355         if (!ret)
 356                 vreg->is_enabled = 0;
 357         mutex_unlock(&vreg->lock);
 358
 359         return ret;
 360 }
 361
 362 static int rpm_reg_switch_disable(struct regulator_dev *rdev)
 363 {
 364         struct qcom_rpm_reg *vreg = rdev_get_drvdata(rdev);
 365         const struct rpm_reg_parts *parts = vreg->parts;
 366         const struct request_member *req = &parts->enable_state;
 367         int ret;
 368
 369         if (req->mask == 0)
 370                 return -EINVAL;
 371
 372         mutex_lock(&vreg->lock);
 373         ret = rpm_reg_write(vreg, req, 0);
 374         if (!ret)
 375                 vreg->is_enabled = 0;
 376         mutex_unlock(&vreg->lock);
 377
 378         return ret;
 379 }
 380
 381 static int rpm_reg_is_enabled(struct regulator_dev *rdev)
 382 {
 383         struct qcom_rpm_reg *vreg = rdev_get_drvdata(rdev);
 384
 385         return vreg->is_enabled;
 386 }
 387
 388 static int rpm_reg_set_load(struct regulator_dev *rdev, int load_uA)
 389 {
 390         struct qcom_rpm_reg *vreg = rdev_get_drvdata(rdev);
 391         const struct rpm_reg_parts *parts = vreg->parts;
 392         const struct request_member *req = &parts->ia;
 393         int load_mA = load_uA / 1000;
 394         int max_mA = req->mask >> req->shift;
 395         int ret;
 396
 397         if (req->mask == 0)
 398                 return -EINVAL;
 399
 400         if (load_mA > max_mA)
 401                 load_mA = max_mA;
 402
 403         mutex_lock(&vreg->lock);
 404         ret = rpm_reg_write(vreg, req, load_mA);
 405         mutex_unlock(&vreg->lock);
 406
 407         return ret;
 408 }
 409
 410 static const struct regulator_ops uV_ops = {
 411         .list_voltage = regulator_list_voltage_linear_range,
 412
 413         .set_voltage_sel = rpm_reg_set_uV_sel,
 414         .get_voltage = rpm_reg_get_voltage,
 415
 416         .enable = rpm_reg_uV_enable,
 417         .disable = rpm_reg_uV_disable,
 418         .is_enabled = rpm_reg_is_enabled,
 419
 420         .set_load = rpm_reg_set_load,
 421 };
 422
 423 static const struct regulator_ops mV_ops = {
 424         .list_voltage = regulator_list_voltage_linear_range,
 425
 426         .set_voltage_sel = rpm_reg_set_mV_sel,
 427         .get_voltage = rpm_reg_get_voltage,
 428
 429         .enable = rpm_reg_mV_enable,
 430         .disable = rpm_reg_mV_disable,
 431         .is_enabled = rpm_reg_is_enabled,
 432
 433         .set_load = rpm_reg_set_load,
 434 };
 435
 436 static const struct regulator_ops switch_ops = {
 437         .enable = rpm_reg_switch_enable,
 438         .disable = rpm_reg_switch_disable,
 439         .is_enabled = rpm_reg_is_enabled,
 440 };
 441
 442 /*
 443  * PM8018 regulators
 444  */
 445 static const struct qcom_rpm_reg pm8018_pldo = {
 446         .desc.linear_ranges = pldo_ranges,
 447         .desc.n_linear_ranges = ARRAY_SIZE(pldo_ranges),
 448         .desc.n_voltages = 161,
 449         .desc.ops = &uV_ops,
 450         .parts = &rpm8960_ldo_parts,
 451         .supports_force_mode_auto = false,
 452         .supports_force_mode_bypass = false,
 453 };
 454
 455 static const struct qcom_rpm_reg pm8018_nldo = {
 456         .desc.linear_ranges = nldo_ranges,
 457         .desc.n_linear_ranges = ARRAY_SIZE(nldo_ranges),
 458         .desc.n_voltages = 64,
 459         .desc.ops = &uV_ops,
 460         .parts = &rpm8960_ldo_parts,
 461         .supports_force_mode_auto = false,
 462         .supports_force_mode_bypass = false,
 463 };
 464
 465 static const struct qcom_rpm_reg pm8018_smps = {
 466         .desc.linear_ranges = smps_ranges,
 467         .desc.n_linear_ranges = ARRAY_SIZE(smps_ranges),
 468         .desc.n_voltages = 154,
 469         .desc.ops = &uV_ops,
 470         .parts = &rpm8960_smps_parts,
 471         .supports_force_mode_auto = false,
 472         .supports_force_mode_bypass = false,
 473 };
 474
 475 static const struct qcom_rpm_reg pm8018_switch = {
 476         .desc.ops = &switch_ops,
 477         .parts = &rpm8960_switch_parts,
 478 };
 479
 480 /*
 481  * PM8058 regulators
 482  */
 483 static const struct qcom_rpm_reg pm8058_pldo = {
 484         .desc.linear_ranges = pldo_ranges,
 485         .desc.n_linear_ranges = ARRAY_SIZE(pldo_ranges),
 486         .desc.n_voltages = 161,
 487         .desc.ops = &mV_ops,
 488         .parts = &rpm8660_ldo_parts,
 489         .supports_force_mode_auto = false,
 490         .supports_force_mode_bypass = false,
 491 };
 492
 493 static const struct qcom_rpm_reg pm8058_nldo = {
 494         .desc.linear_ranges = nldo_ranges,
 495         .desc.n_linear_ranges = ARRAY_SIZE(nldo_ranges),
 496         .desc.n_voltages = 64,
 497         .desc.ops = &mV_ops,
 498         .parts = &rpm8660_ldo_parts,
 499         .supports_force_mode_auto = false,
 500         .supports_force_mode_bypass = false,
 501 };
 502
 503 static const struct qcom_rpm_reg pm8058_smps = {
 504         .desc.linear_ranges = smps_ranges,
 505         .desc.n_linear_ranges = ARRAY_SIZE(smps_ranges),
 506         .desc.n_voltages = 154,
 507         .desc.ops = &mV_ops,
 508         .parts = &rpm8660_smps_parts,
 509         .supports_force_mode_auto = false,
 510         .supports_force_mode_bypass = false,
 511 };
 512
 513 static const struct qcom_rpm_reg pm8058_ncp = {
 514         .desc.linear_ranges = ncp_ranges,
 515         .desc.n_linear_ranges = ARRAY_SIZE(ncp_ranges),
 516         .desc.n_voltages = 32,
 517         .desc.ops = &mV_ops,
 518         .parts = &rpm8660_ncp_parts,
 519 };
 520
 521 static const struct qcom_rpm_reg pm8058_switch = {
 522         .desc.ops = &switch_ops,
 523         .parts = &rpm8660_switch_parts,
 524 };
 525
 526 /*
 527  * PM8901 regulators
 528  */
 529 static const struct qcom_rpm_reg pm8901_pldo = {
 530         .desc.linear_ranges = pldo_ranges,
 531         .desc.n_linear_ranges = ARRAY_SIZE(pldo_ranges),
 532         .desc.n_voltages = 161,
 533         .desc.ops = &mV_ops,
 534         .parts = &rpm8660_ldo_parts,
 535         .supports_force_mode_auto = false,
 536         .supports_force_mode_bypass = true,
 537 };
 538
 539 static const struct qcom_rpm_reg pm8901_nldo = {
 540         .desc.linear_ranges = nldo_ranges,
 541         .desc.n_linear_ranges = ARRAY_SIZE(nldo_ranges),
 542         .desc.n_voltages = 64,
 543         .desc.ops = &mV_ops,
 544         .parts = &rpm8660_ldo_parts,
 545         .supports_force_mode_auto = false,
 546         .supports_force_mode_bypass = true,
 547 };
 548
 549 static const struct qcom_rpm_reg pm8901_ftsmps = {
 550         .desc.linear_ranges = ftsmps_ranges,
 551         .desc.n_linear_ranges = ARRAY_SIZE(ftsmps_ranges),
 552         .desc.n_voltages = 101,
 553         .desc.ops = &mV_ops,
 554         .parts = &rpm8660_smps_parts,
 555         .supports_force_mode_auto = true,
 556         .supports_force_mode_bypass = false,
 557 };
 558
 559 static const struct qcom_rpm_reg pm8901_switch = {
 560         .desc.ops = &switch_ops,
 561         .parts = &rpm8660_switch_parts,
 562 };
 563
 564 /*
 565  * PM8921 regulators
 566  */
 567 static const struct qcom_rpm_reg pm8921_pldo = {
 568         .desc.linear_ranges = pldo_ranges,
 569         .desc.n_linear_ranges = ARRAY_SIZE(pldo_ranges),
 570         .desc.n_voltages = 161,
 571         .desc.ops = &uV_ops,
 572         .parts = &rpm8960_ldo_parts,
 573         .supports_force_mode_auto = false,
 574         .supports_force_mode_bypass = true,
 575 };
 576
 577 static const struct qcom_rpm_reg pm8921_nldo = {
 578         .desc.linear_ranges = nldo_ranges,
 579         .desc.n_linear_ranges = ARRAY_SIZE(nldo_ranges),
 580         .desc.n_voltages = 64,
 581         .desc.ops = &uV_ops,
 582         .parts = &rpm8960_ldo_parts,
 583         .supports_force_mode_auto = false,
 584         .supports_force_mode_bypass = true,
 585 };
 586
 587 static const struct qcom_rpm_reg pm8921_nldo1200 = {
 588         .desc.linear_ranges = nldo1200_ranges,
 589         .desc.n_linear_ranges = ARRAY_SIZE(nldo1200_ranges),
 590         .desc.n_voltages = 124,
 591         .desc.ops = &uV_ops,
 592         .parts = &rpm8960_ldo_parts,
 593         .supports_force_mode_auto = false,
 594         .supports_force_mode_bypass = true,
 595 };
 596
 597 static const struct qcom_rpm_reg pm8921_smps = {
 598         .desc.linear_ranges = smps_ranges,
 599         .desc.n_linear_ranges = ARRAY_SIZE(smps_ranges),
 600         .desc.n_voltages = 154,
 601         .desc.ops = &uV_ops,
 602         .parts = &rpm8960_smps_parts,
 603         .supports_force_mode_auto = true,
 604         .supports_force_mode_bypass = false,
 605 };
 606
 607 static const struct qcom_rpm_reg pm8921_ncp = {
 608         .desc.linear_ranges = ncp_ranges,
 609         .desc.n_linear_ranges = ARRAY_SIZE(ncp_ranges),
 610         .desc.n_voltages = 32,
 611         .desc.ops = &uV_ops,
 612         .parts = &rpm8960_ncp_parts,
 613 };
 614
 615 static const struct qcom_rpm_reg pm8921_switch = {
 616         .desc.ops = &switch_ops,
 617         .parts = &rpm8960_switch_parts,
 618 };
 619
 620 static const struct qcom_rpm_reg smb208_smps = {
 621         .desc.linear_ranges = smb208_ranges,
 622         .desc.n_linear_ranges = ARRAY_SIZE(smb208_ranges),
 623         .desc.n_voltages = 235,
 624         .desc.ops = &uV_ops,
 625         .parts = &rpm8960_smps_parts,
 626         .supports_force_mode_auto = false,
 627         .supports_force_mode_bypass = false,
 628 };
 629
 630 static int rpm_reg_set(struct qcom_rpm_reg *vreg,
 631                        const struct request_member *req,
 632                        const int value)
 633 {
 634         if (req->mask == 0 || (value << req->shift) & ~req->mask)
 635                 return -EINVAL;
 636
 637         vreg->val[req->word] &= ~req->mask;
 638         vreg->val[req->word] |= value << req->shift;
 639
 640         return 0;
 641 }
 642
 643 static int rpm_reg_of_parse_freq(struct device *dev,
 644                                  struct device_node *node,
 645                                  struct qcom_rpm_reg *vreg)
 646 {
 647         static const int freq_table[] = {
 648                 19200000, 9600000, 6400000, 4800000, 3840000, 3200000, 2740000,
 649                 2400000, 2130000, 1920000, 1750000, 1600000, 1480000, 1370000,
 650                 1280000, 1200000,
 651
 652         };
 653         const char *key;
 654         u32 freq;
 655         int ret;
 656         int i;
 657
 658         key = "qcom,switch-mode-frequency";
 659         ret = of_property_read_u32(node, key, &freq);
 660         if (ret) {
 661                 dev_err(dev, "regulator requires %s property\n", key);
 662                 return -EINVAL;
 663         }
 664
 665         for (i = 0; i < ARRAY_SIZE(freq_table); i++) {
 666                 if (freq == freq_table[i]) {
 667                         rpm_reg_set(vreg, &vreg->parts->freq, i + 1);
 668                         return 0;
 669                 }
 670         }
 671
 672         dev_err(dev, "invalid frequency %d\n", freq);
 673         return -EINVAL;
 674 }
 675
 676 static int rpm_reg_of_parse(struct device_node *node,
 677                             const struct regulator_desc *desc,
 678                             struct regulator_config *config)
 679 {
 680         struct qcom_rpm_reg *vreg = config->driver_data;
 681         struct device *dev = config->dev;
 682         const char *key;
 683         u32 force_mode;
 684         bool pwm;
 685         u32 val;
 686         int ret;
 687
 688         key = "bias-pull-down";
 689         if (of_property_read_bool(node, key)) {
 690                 ret = rpm_reg_set(vreg, &vreg->parts->pd, 1);
 691                 if (ret) {
 692                         dev_err(dev, "%s is invalid", key);
 693                         return ret;
 694                 }
 695         }
 696
 697         if (vreg->parts->freq.mask) {
 698                 ret = rpm_reg_of_parse_freq(dev, node, vreg);
 699                 if (ret < 0)
 700                         return ret;
 701         }
 702
 703         if (vreg->parts->pm.mask) {
 704                 key = "qcom,power-mode-hysteretic";
 705                 pwm = !of_property_read_bool(node, key);
 706
 707                 ret = rpm_reg_set(vreg, &vreg->parts->pm, pwm);
 708                 if (ret) {
 709                         dev_err(dev, "failed to set power mode\n");
 710                         return ret;
 711                 }
 712         }
 713
 714         if (vreg->parts->fm.mask) {
 715                 force_mode = -1;
 716
 717                 key = "qcom,force-mode";
 718                 ret = of_property_read_u32(node, key, &val);
 719                 if (ret == -EINVAL) {
 720                         val = QCOM_RPM_FORCE_MODE_NONE;
 721                 } else if (ret < 0) {
 722                         dev_err(dev, "failed to read %s\n", key);
 723                         return ret;
 724                 }
 725
 726                 /*
 727                  * If force-mode is encoded as 2 bits then the
 728                  * possible register values are:
 729                  * NONE, LPM, HPM
 730                  * otherwise:
 731                  * NONE, LPM, AUTO, HPM, BYPASS
 732                  */
 733                 switch (val) {
 734                 case QCOM_RPM_FORCE_MODE_NONE:
 735                         force_mode = 0;
 736                         break;
 737                 case QCOM_RPM_FORCE_MODE_LPM:
 738                         force_mode = 1;
 739                         break;
 740                 case QCOM_RPM_FORCE_MODE_HPM:
 741                         if (FORCE_MODE_IS_2_BITS(vreg))
 742                                 force_mode = 2;
 743                         else
 744                                 force_mode = 3;
 745                         break;
 746                 case QCOM_RPM_FORCE_MODE_AUTO:
 747                         if (vreg->supports_force_mode_auto)
 748                                 force_mode = 2;
 749                         break;
 750                 case QCOM_RPM_FORCE_MODE_BYPASS:
 751                         if (vreg->supports_force_mode_bypass)
 752                                 force_mode = 4;
 753                         break;
 754                 }
 755
 756                 if (force_mode == -1) {
 757                         dev_err(dev, "invalid force mode\n");
 758                         return -EINVAL;
 759                 }
 760
 761                 ret = rpm_reg_set(vreg, &vreg->parts->fm, force_mode);
 762                 if (ret) {
 763                         dev_err(dev, "failed to set force mode\n");
 764                         return ret;
 765                 }
 766         }
 767
 768         return 0;
 769 }
 770
 771 struct rpm_regulator_data {
 772         const char *name;
 773         int resource;
 774         const struct qcom_rpm_reg *template;
 775         const char *supply;
 776 };
 777
 778 static const struct rpm_regulator_data rpm_pm8018_regulators[] = {
 779         { "s1",  QCOM_RPM_PM8018_SMPS1, &pm8018_smps, "vdd_s1" },
 780         { "s2",  QCOM_RPM_PM8018_SMPS2, &pm8018_smps, "vdd_s2" },
 781         { "s3",  QCOM_RPM_PM8018_SMPS3, &pm8018_smps, "vdd_s3" },
 782         { "s4",  QCOM_RPM_PM8018_SMPS4, &pm8018_smps, "vdd_s4" },
 783         { "s5",  QCOM_RPM_PM8018_SMPS5, &pm8018_smps, "vdd_s5" },
 784
 785         { "l2",  QCOM_RPM_PM8018_LDO2,  &pm8018_pldo, "vdd_l2" },
 786         { "l3",  QCOM_RPM_PM8018_LDO3,  &pm8018_pldo, "vdd_l3" },
 787         { "l4",  QCOM_RPM_PM8018_LDO4,  &pm8018_pldo, "vdd_l4" },
 788         { "l5",  QCOM_RPM_PM8018_LDO5,  &pm8018_pldo, "vdd_l5" },
 789         { "l6",  QCOM_RPM_PM8018_LDO6,  &pm8018_pldo, "vdd_l7" },
 790         { "l7",  QCOM_RPM_PM8018_LDO7,  &pm8018_pldo, "vdd_l7" },
 791         { "l8",  QCOM_RPM_PM8018_LDO8,  &pm8018_nldo, "vdd_l8" },
 792         { "l9",  QCOM_RPM_PM8018_LDO9,  &pm8921_nldo1200,
 793                                                       "vdd_l9_l10_l11_l12" },
 794         { "l10", QCOM_RPM_PM8018_LDO10, &pm8018_nldo, "vdd_l9_l10_l11_l12" },
 795         { "l11", QCOM_RPM_PM8018_LDO11, &pm8018_nldo, "vdd_l9_l10_l11_l12" },
 796         { "l12", QCOM_RPM_PM8018_LDO12, &pm8018_nldo, "vdd_l9_l10_l11_l12" },
 797         { "l14", QCOM_RPM_PM8018_LDO14, &pm8018_pldo, "vdd_l14" },
 798
 799         { "lvs1", QCOM_RPM_PM8018_LVS1, &pm8018_switch, "lvs1_in" },
 800
 801         { }
 802 };
 803
 804 static const struct rpm_regulator_data rpm_pm8058_regulators[] = {
 805         { "l0",   QCOM_RPM_PM8058_LDO0,   &pm8058_nldo, "vdd_l0_l1_lvs" },
 806         { "l1",   QCOM_RPM_PM8058_LDO1,   &pm8058_nldo, "vdd_l0_l1_lvs" },
 807         { "l2",   QCOM_RPM_PM8058_LDO2,   &pm8058_pldo, "vdd_l2_l11_l12" },
 808         { "l3",   QCOM_RPM_PM8058_LDO3,   &pm8058_pldo, "vdd_l3_l4_l5" },
 809         { "l4",   QCOM_RPM_PM8058_LDO4,   &pm8058_pldo, "vdd_l3_l4_l5" },
 810         { "l5",   QCOM_RPM_PM8058_LDO5,   &pm8058_pldo, "vdd_l3_l4_l5" },
 811         { "l6",   QCOM_RPM_PM8058_LDO6,   &pm8058_pldo, "vdd_l6_l7" },
 812         { "l7",   QCOM_RPM_PM8058_LDO7,   &pm8058_pldo, "vdd_l6_l7" },
 813         { "l8",   QCOM_RPM_PM8058_LDO8,   &pm8058_pldo, "vdd_l8" },
 814         { "l9",   QCOM_RPM_PM8058_LDO9,   &pm8058_pldo, "vdd_l9" },
 815         { "l10",  QCOM_RPM_PM8058_LDO10,  &pm8058_pldo, "vdd_l10" },
 816         { "l11",  QCOM_RPM_PM8058_LDO11,  &pm8058_pldo, "vdd_l2_l11_l12" },
 817         { "l12",  QCOM_RPM_PM8058_LDO12,  &pm8058_pldo, "vdd_l2_l11_l12" },
 818         { "l13",  QCOM_RPM_PM8058_LDO13,  &pm8058_pldo, "vdd_l13_l16" },
 819         { "l14",  QCOM_RPM_PM8058_LDO14,  &pm8058_pldo, "vdd_l14_l15" },
 820         { "l15",  QCOM_RPM_PM8058_LDO15,  &pm8058_pldo, "vdd_l14_l15" },
 821         { "l16",  QCOM_RPM_PM8058_LDO16,  &pm8058_pldo, "vdd_l13_l16" },
 822         { "l17",  QCOM_RPM_PM8058_LDO17,  &pm8058_pldo, "vdd_l17_l18" },
 823         { "l18",  QCOM_RPM_PM8058_LDO18,  &pm8058_pldo, "vdd_l17_l18" },
 824         { "l19",  QCOM_RPM_PM8058_LDO19,  &pm8058_pldo, "vdd_l19_l20" },
 825         { "l20",  QCOM_RPM_PM8058_LDO20,  &pm8058_pldo, "vdd_l19_l20" },
 826         { "l21",  QCOM_RPM_PM8058_LDO21,  &pm8058_nldo, "vdd_l21" },
 827         { "l22",  QCOM_RPM_PM8058_LDO22,  &pm8058_nldo, "vdd_l22" },
 828         { "l23",  QCOM_RPM_PM8058_LDO23,  &pm8058_nldo, "vdd_l23_l24_l25" },
 829         { "l24",  QCOM_RPM_PM8058_LDO24,  &pm8058_nldo, "vdd_l23_l24_l25" },
 830         { "l25",  QCOM_RPM_PM8058_LDO25,  &pm8058_nldo, "vdd_l23_l24_l25" },
 831
 832         { "s0",   QCOM_RPM_PM8058_SMPS0,  &pm8058_smps, "vdd_s0" },
 833         { "s1",   QCOM_RPM_PM8058_SMPS1,  &pm8058_smps, "vdd_s1" },
 834         { "s2",   QCOM_RPM_PM8058_SMPS2,  &pm8058_smps, "vdd_s2" },
 835         { "s3",   QCOM_RPM_PM8058_SMPS3,  &pm8058_smps, "vdd_s3" },
 836         { "s4",   QCOM_RPM_PM8058_SMPS4,  &pm8058_smps, "vdd_s4" },
 837
 838         { "lvs0", QCOM_RPM_PM8058_LVS0, &pm8058_switch, "vdd_l0_l1_lvs" },
 839         { "lvs1", QCOM_RPM_PM8058_LVS1, &pm8058_switch, "vdd_l0_l1_lvs" },
 840
 841         { "ncp",  QCOM_RPM_PM8058_NCP, &pm8058_ncp, "vdd_ncp" },
 842         { }
 843 };
 844
 845 static const struct rpm_regulator_data rpm_pm8901_regulators[] = {
 846         { "l0",   QCOM_RPM_PM8901_LDO0, &pm8901_nldo, "vdd_l0" },
 847         { "l1",   QCOM_RPM_PM8901_LDO1, &pm8901_pldo, "vdd_l1" },
 848         { "l2",   QCOM_RPM_PM8901_LDO2, &pm8901_pldo, "vdd_l2" },
 849         { "l3",   QCOM_RPM_PM8901_LDO3, &pm8901_pldo, "vdd_l3" },
 850         { "l4",   QCOM_RPM_PM8901_LDO4, &pm8901_pldo, "vdd_l4" },
 851         { "l5",   QCOM_RPM_PM8901_LDO5, &pm8901_pldo, "vdd_l5" },
 852         { "l6",   QCOM_RPM_PM8901_LDO6, &pm8901_pldo, "vdd_l6" },
 853
 854         { "s0",   QCOM_RPM_PM8901_SMPS0, &pm8901_ftsmps, "vdd_s0" },
 855         { "s1",   QCOM_RPM_PM8901_SMPS1, &pm8901_ftsmps, "vdd_s1" },
 856         { "s2",   QCOM_RPM_PM8901_SMPS2, &pm8901_ftsmps, "vdd_s2" },
 857         { "s3",   QCOM_RPM_PM8901_SMPS3, &pm8901_ftsmps, "vdd_s3" },
 858         { "s4",   QCOM_RPM_PM8901_SMPS4, &pm8901_ftsmps, "vdd_s4" },
 859
 860         { "lvs0", QCOM_RPM_PM8901_LVS0, &pm8901_switch, "lvs0_in" },
 861         { "lvs1", QCOM_RPM_PM8901_LVS1, &pm8901_switch, "lvs1_in" },
 862         { "lvs2", QCOM_RPM_PM8901_LVS2, &pm8901_switch, "lvs2_in" },
 863         { "lvs3", QCOM_RPM_PM8901_LVS3, &pm8901_switch, "lvs3_in" },
 864
 865         { "mvs", QCOM_RPM_PM8901_MVS, &pm8901_switch, "mvs_in" },
 866         { }
 867 };
 868
 869 static const struct rpm_regulator_data rpm_pm8921_regulators[] = {
 870         { "s1",  QCOM_RPM_PM8921_SMPS1, &pm8921_smps, "vdd_s1" },
 871         { "s2",  QCOM_RPM_PM8921_SMPS2, &pm8921_smps, "vdd_s2" },
 872         { "s3",  QCOM_RPM_PM8921_SMPS3, &pm8921_smps },
 873         { "s4",  QCOM_RPM_PM8921_SMPS4, &pm8921_smps, "vdd_s4" },
 874         { "s7",  QCOM_RPM_PM8921_SMPS7, &pm8921_smps, "vdd_s7" },
 875         { "s8",  QCOM_RPM_PM8921_SMPS8, &pm8921_smps, "vdd_s8"  },
 876
 877         { "l1",  QCOM_RPM_PM8921_LDO1, &pm8921_nldo, "vdd_l1_l2_l12_l18" },
 878         { "l2",  QCOM_RPM_PM8921_LDO2, &pm8921_nldo, "vdd_l1_l2_l12_l18" },
 879         { "l3",  QCOM_RPM_PM8921_LDO3, &pm8921_pldo, "vdd_l3_l15_l17" },
 880         { "l4",  QCOM_RPM_PM8921_LDO4, &pm8921_pldo, "vdd_l4_l14" },
 881         { "l5",  QCOM_RPM_PM8921_LDO5, &pm8921_pldo, "vdd_l5_l8_l16" },
 882         { "l6",  QCOM_RPM_PM8921_LDO6, &pm8921_pldo, "vdd_l6_l7" },
 883         { "l7",  QCOM_RPM_PM8921_LDO7, &pm8921_pldo, "vdd_l6_l7" },
 884         { "l8",  QCOM_RPM_PM8921_LDO8, &pm8921_pldo, "vdd_l5_l8_l16" },
 885         { "l9",  QCOM_RPM_PM8921_LDO9, &pm8921_pldo, "vdd_l9_l11" },
 886         { "l10", QCOM_RPM_PM8921_LDO10, &pm8921_pldo, "vdd_l10_l22" },
 887         { "l11", QCOM_RPM_PM8921_LDO11, &pm8921_pldo, "vdd_l9_l11" },
 888         { "l12", QCOM_RPM_PM8921_LDO12, &pm8921_nldo, "vdd_l1_l2_l12_l18" },
 889         { "l14", QCOM_RPM_PM8921_LDO14, &pm8921_pldo, "vdd_l4_l14" },
 890         { "l15", QCOM_RPM_PM8921_LDO15, &pm8921_pldo, "vdd_l3_l15_l17" },
 891         { "l16", QCOM_RPM_PM8921_LDO16, &pm8921_pldo, "vdd_l5_l8_l16" },
 892         { "l17", QCOM_RPM_PM8921_LDO17, &pm8921_pldo, "vdd_l3_l15_l17" },
 893         { "l18", QCOM_RPM_PM8921_LDO18, &pm8921_nldo, "vdd_l1_l2_l12_l18" },
 894         { "l21", QCOM_RPM_PM8921_LDO21, &pm8921_pldo, "vdd_l21_l23_l29" },
 895         { "l22", QCOM_RPM_PM8921_LDO22, &pm8921_pldo, "vdd_l10_l22" },
 896         { "l23", QCOM_RPM_PM8921_LDO23, &pm8921_pldo, "vdd_l21_l23_l29" },
 897         { "l24", QCOM_RPM_PM8921_LDO24, &pm8921_nldo1200, "vdd_l24" },
 898         { "l25", QCOM_RPM_PM8921_LDO25, &pm8921_nldo1200, "vdd_l25" },
 899         { "l26", QCOM_RPM_PM8921_LDO26, &pm8921_nldo1200, "vdd_l26" },
 900         { "l27", QCOM_RPM_PM8921_LDO27, &pm8921_nldo1200, "vdd_l27" },
 901         { "l28", QCOM_RPM_PM8921_LDO28, &pm8921_nldo1200, "vdd_l28" },
 902         { "l29", QCOM_RPM_PM8921_LDO29, &pm8921_pldo, "vdd_l21_l23_l29" },
 903
 904         { "lvs1", QCOM_RPM_PM8921_LVS1, &pm8921_switch, "vin_lvs1_3_6" },
 905         { "lvs2", QCOM_RPM_PM8921_LVS2, &pm8921_switch, "vin_lvs2" },
 906         { "lvs3", QCOM_RPM_PM8921_LVS3, &pm8921_switch, "vin_lvs1_3_6" },
 907         { "lvs4", QCOM_RPM_PM8921_LVS4, &pm8921_switch, "vin_lvs4_5_7" },
 908         { "lvs5", QCOM_RPM_PM8921_LVS5, &pm8921_switch, "vin_lvs4_5_7" },
 909         { "lvs6", QCOM_RPM_PM8921_LVS6, &pm8921_switch, "vin_lvs1_3_6" },
 910         { "lvs7", QCOM_RPM_PM8921_LVS7, &pm8921_switch, "vin_lvs4_5_7" },
 911
 912         { "usb-switch", QCOM_RPM_USB_OTG_SWITCH, &pm8921_switch, "vin_5vs" },
 913         { "hdmi-switch", QCOM_RPM_HDMI_SWITCH, &pm8921_switch, "vin_5vs" },
 914         { "ncp", QCOM_RPM_PM8921_NCP, &pm8921_ncp, "vdd_ncp" },
 915         { }
 916 };
 917
 918 static const struct rpm_regulator_data rpm_smb208_regulators[] = {
 919         { "s1a",  QCOM_RPM_SMB208_S1a, &smb208_smps, "vin_s1a" },
 920         { "s1b",  QCOM_RPM_SMB208_S1b, &smb208_smps, "vin_s1b" },
 921         { "s2a",  QCOM_RPM_SMB208_S2a, &smb208_smps, "vin_s2a" },
 922         { "s2b",  QCOM_RPM_SMB208_S2b, &smb208_smps, "vin_s2b" },
 923         { }
 924 };
 925
 926 static const struct of_device_id rpm_of_match[] = {
 927         { .compatible = "qcom,rpm-pm8018-regulators",
 928                 .data = &rpm_pm8018_regulators },
 929         { .compatible = "qcom,rpm-pm8058-regulators", .data = &rpm_pm8058_regulators },
 930         { .compatible = "qcom,rpm-pm8901-regulators", .data = &rpm_pm8901_regulators },
 931         { .compatible = "qcom,rpm-pm8921-regulators", .data = &rpm_pm8921_regulators },
 932         { .compatible = "qcom,rpm-smb208-regulators", .data = &rpm_smb208_regulators },
 933         { }
 934 };
 935 MODULE_DEVICE_TABLE(of, rpm_of_match);
 936
 937 static int rpm_reg_probe(struct platform_device *pdev)
 938 {
 939         const struct rpm_regulator_data *reg;
 940         const struct of_device_id *match;
 941         struct regulator_config config = { };
 942         struct regulator_dev *rdev;
 943         struct qcom_rpm_reg *vreg;
 944         struct qcom_rpm *rpm;
 945
 946         rpm = dev_get_drvdata(pdev->dev.parent);
 947         if (!rpm) {
 948                 dev_err(&pdev->dev, "unable to retrieve handle to rpm\n");
 949                 return -ENODEV;
 950         }
 951
 952         match = of_match_device(rpm_of_match, &pdev->dev);
 953         if (!match) {
 954                 dev_err(&pdev->dev, "failed to match device\n");
 955                 return -ENODEV;
 956         }
 957
 958         for (reg = match->data; reg->name; reg++) {
 959                 vreg = devm_kmalloc(&pdev->dev, sizeof(*vreg), GFP_KERNEL);
 960                 if (!vreg)
 961                         return -ENOMEM;
 962
 963                 memcpy(vreg, reg->template, sizeof(*vreg));
 964                 mutex_init(&vreg->lock);
 965
 966                 vreg->dev = &pdev->dev;
 967                 vreg->resource = reg->resource;
 968                 vreg->rpm = rpm;
 969
 970                 vreg->desc.id = -1;
 971                 vreg->desc.owner = THIS_MODULE;
 972                 vreg->desc.type = REGULATOR_VOLTAGE;
 973                 vreg->desc.name = reg->name;
 974                 vreg->desc.supply_name = reg->supply;
 975                 vreg->desc.of_match = reg->name;
 976                 vreg->desc.of_parse_cb = rpm_reg_of_parse;
 977
 978                 config.dev = &pdev->dev;
 979                 config.driver_data = vreg;
 980                 rdev = devm_regulator_register(&pdev->dev, &vreg->desc, &config);
 981                 if (IS_ERR(rdev)) {
 982                         dev_err(&pdev->dev, "failed to register %s\n", reg->name);
 983                         return PTR_ERR(rdev);
 984                 }
 985         }
 986
 987         return 0;
 988 }
 989
 990 static struct platform_driver rpm_reg_driver = {
 991         .probe          = rpm_reg_probe,
 992         .driver  = {
 993                 .name  = "qcom_rpm_reg",
 994                 .of_match_table = of_match_ptr(rpm_of_match),
 995         },
 996 };
 997
 998 static int __init rpm_reg_init(void)
 999 {
1000         return platform_driver_register(&rpm_reg_driver);
1001 }
1002 subsys_initcall(rpm_reg_init);
1003
1004 static void __exit rpm_reg_exit(void)
1005 {
1006         platform_driver_unregister(&rpm_reg_driver);
1007 }
1008 module_exit(rpm_reg_exit)
1009
1010 MODULE_DESCRIPTION("Qualcomm RPM regulator driver");
1011 MODULE_LICENSE("GPL v2");