drivers/regulator/bd9576-regulator.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 // Copyright (C) 2020 ROHM Semiconductors
   3 // ROHM BD9576MUF/BD9573MUF regulator driver
   4
   5 #include <linux/err.h>
   6 #include <linux/gpio/consumer.h>
   7 #include <linux/interrupt.h>
   8 #include <linux/jiffies.h>
   9 #include <linux/kernel.h>
  10 #include <linux/mfd/rohm-bd957x.h>
  11 #include <linux/mfd/rohm-generic.h>
  12 #include <linux/module.h>
  13 #include <linux/of.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/property.h>
  16 #include <linux/regulator/driver.h>
  17 #include <linux/regulator/machine.h>
  18 #include <linux/regulator/of_regulator.h>
  19 #include <linux/slab.h>
  20 #include <linux/spinlock.h>
  21 #include <linux/workqueue.h>
  22
  23 #define BD957X_VOUTS1_VOLT      3300000
  24 #define BD957X_VOUTS4_BASE_VOLT 1030000
  25 #define BD957X_VOUTS34_NUM_VOLT 32
  26
  27 #define BD9576_THERM_IRQ_MASK_TW        BIT(5)
  28 #define BD9576_xVD_IRQ_MASK_VOUTL1      BIT(5)
  29 #define BD9576_UVD_IRQ_MASK_VOUTS1_OCW  BIT(6)
  30 #define BD9576_xVD_IRQ_MASK_VOUT1TO4    0x0F
  31
  32 static const unsigned int vout1_volt_table[] = {
  33         5000000, 4900000, 4800000, 4700000, 4600000,
  34         4500000, 4500000, 4500000, 5000000, 5100000,
  35         5200000, 5300000, 5400000, 5500000, 5500000,
  36         5500000
  37 };
  38
  39 static const unsigned int vout2_volt_table[] = {
  40         1800000, 1780000, 1760000, 1740000, 1720000,
  41         1700000, 1680000, 1660000, 1800000, 1820000,
  42         1840000, 1860000, 1880000, 1900000, 1920000,
  43         1940000
  44 };
  45
  46 static const unsigned int voutl1_volt_table[] = {
  47         2500000, 2540000, 2580000, 2620000, 2660000,
  48         2700000, 2740000, 2780000, 2500000, 2460000,
  49         2420000, 2380000, 2340000, 2300000, 2260000,
  50         2220000
  51 };
  52
  53 static const struct linear_range vout1_xvd_ranges[] = {
  54         REGULATOR_LINEAR_RANGE(225000, 0x01, 0x2b, 0),
  55         REGULATOR_LINEAR_RANGE(225000, 0x2c, 0x54, 5000),
  56         REGULATOR_LINEAR_RANGE(425000, 0x55, 0x7f, 0),
  57 };
  58
  59 static const struct linear_range vout234_xvd_ranges[] = {
  60         REGULATOR_LINEAR_RANGE(17000, 0x01, 0x0f, 0),
  61         REGULATOR_LINEAR_RANGE(17000, 0x10, 0x6d, 1000),
  62         REGULATOR_LINEAR_RANGE(110000, 0x6e, 0x7f, 0),
  63 };
  64
  65 static const struct linear_range voutL1_xvd_ranges[] = {
  66         REGULATOR_LINEAR_RANGE(34000, 0x01, 0x0f, 0),
  67         REGULATOR_LINEAR_RANGE(34000, 0x10, 0x6d, 2000),
  68         REGULATOR_LINEAR_RANGE(220000, 0x6e, 0x7f, 0),
  69 };
  70
  71 static struct linear_range voutS1_ocw_ranges_internal[] = {
  72         REGULATOR_LINEAR_RANGE(200000, 0x01, 0x04, 0),
  73         REGULATOR_LINEAR_RANGE(250000, 0x05, 0x18, 50000),
  74         REGULATOR_LINEAR_RANGE(1200000, 0x19, 0x3f, 0),
  75 };
  76
  77 static struct linear_range voutS1_ocw_ranges[] = {
  78         REGULATOR_LINEAR_RANGE(50000, 0x01, 0x04, 0),
  79         REGULATOR_LINEAR_RANGE(60000, 0x05, 0x18, 10000),
  80         REGULATOR_LINEAR_RANGE(250000, 0x19, 0x3f, 0),
  81 };
  82
  83 static struct linear_range voutS1_ocp_ranges_internal[] = {
  84         REGULATOR_LINEAR_RANGE(300000, 0x01, 0x06, 0),
  85         REGULATOR_LINEAR_RANGE(350000, 0x7, 0x1b, 50000),
  86         REGULATOR_LINEAR_RANGE(1350000, 0x1c, 0x3f, 0),
  87 };
  88
  89 static struct linear_range voutS1_ocp_ranges[] = {
  90         REGULATOR_LINEAR_RANGE(70000, 0x01, 0x06, 0),
  91         REGULATOR_LINEAR_RANGE(80000, 0x7, 0x1b, 10000),
  92         REGULATOR_LINEAR_RANGE(280000, 0x1c, 0x3f, 0),
  93 };
  94
  95 struct bd957x_regulator_data {
  96         struct regulator_desc desc;
  97         int base_voltage;
  98         struct regulator_dev *rdev;
  99         int ovd_notif;
 100         int uvd_notif;
 101         int temp_notif;
 102         int ovd_err;
 103         int uvd_err;
 104         int temp_err;
 105         const struct linear_range *xvd_ranges;
 106         int num_xvd_ranges;
 107         bool oc_supported;
 108         unsigned int ovd_reg;
 109         unsigned int uvd_reg;
 110         unsigned int xvd_mask;
 111         unsigned int ocp_reg;
 112         unsigned int ocp_mask;
 113         unsigned int ocw_reg;
 114         unsigned int ocw_mask;
 115         unsigned int ocw_rfet;
 116 };
 117
 118 #define BD9576_NUM_REGULATORS 6
 119 #define BD9576_NUM_OVD_REGULATORS 5
 120
 121 struct bd957x_data {
 122         struct bd957x_regulator_data regulator_data[BD9576_NUM_REGULATORS];
 123         struct regmap *regmap;
 124         struct delayed_work therm_irq_suppress;
 125         struct delayed_work ovd_irq_suppress;
 126         struct delayed_work uvd_irq_suppress;
 127         unsigned int therm_irq;
 128         unsigned int ovd_irq;
 129         unsigned int uvd_irq;
 130         spinlock_t err_lock;
 131         int regulator_global_err;
 132 };
 133
 134 static int bd957x_vout34_list_voltage(struct regulator_dev *rdev,
 135                                       unsigned int selector)
 136 {
 137         const struct regulator_desc *desc = rdev->desc;
 138         int multiplier = selector & desc->vsel_mask & 0x7f;
 139         int tune;
 140
 141         /* VOUT3 and 4 has 10mV step */
 142         tune = multiplier * 10000;
 143
 144         if (!(selector & 0x80))
 145                 return desc->fixed_uV - tune;
 146
 147         return desc->fixed_uV + tune;
 148 }
 149
 150 static int bd957x_list_voltage(struct regulator_dev *rdev,
 151                                unsigned int selector)
 152 {
 153         const struct regulator_desc *desc = rdev->desc;
 154         int index = selector & desc->vsel_mask & 0x7f;
 155
 156         if (!(selector & 0x80))
 157                 index += desc->n_voltages/2;
 158
 159         if (index >= desc->n_voltages)
 160                 return -EINVAL;
 161
 162         return desc->volt_table[index];
 163 }
 164
 165 static void bd9576_fill_ovd_flags(struct bd957x_regulator_data *data,
 166                                   bool warn)
 167 {
 168         if (warn) {
 169                 data->ovd_notif = REGULATOR_EVENT_OVER_VOLTAGE_WARN;
 170                 data->ovd_err = REGULATOR_ERROR_OVER_VOLTAGE_WARN;
 171         } else {
 172                 data->ovd_notif = REGULATOR_EVENT_REGULATION_OUT;
 173                 data->ovd_err = REGULATOR_ERROR_REGULATION_OUT;
 174         }
 175 }
 176
 177 static void bd9576_fill_ocp_flags(struct bd957x_regulator_data *data,
 178                                   bool warn)
 179 {
 180         if (warn) {
 181                 data->uvd_notif = REGULATOR_EVENT_OVER_CURRENT_WARN;
 182                 data->uvd_err = REGULATOR_ERROR_OVER_CURRENT_WARN;
 183         } else {
 184                 data->uvd_notif = REGULATOR_EVENT_OVER_CURRENT;
 185                 data->uvd_err = REGULATOR_ERROR_OVER_CURRENT;
 186         }
 187 }
 188
 189 static void bd9576_fill_uvd_flags(struct bd957x_regulator_data *data,
 190                                   bool warn)
 191 {
 192         if (warn) {
 193                 data->uvd_notif = REGULATOR_EVENT_UNDER_VOLTAGE_WARN;
 194                 data->uvd_err = REGULATOR_ERROR_UNDER_VOLTAGE_WARN;
 195         } else {
 196                 data->uvd_notif = REGULATOR_EVENT_UNDER_VOLTAGE;
 197                 data->uvd_err = REGULATOR_ERROR_UNDER_VOLTAGE;
 198         }
 199 }
 200
 201 static void bd9576_fill_temp_flags(struct bd957x_regulator_data *data,
 202                                    bool enable, bool warn)
 203 {
 204         if (!enable) {
 205                 data->temp_notif = 0;
 206                 data->temp_err = 0;
 207         } else if (warn) {
 208                 data->temp_notif = REGULATOR_EVENT_OVER_TEMP_WARN;
 209                 data->temp_err = REGULATOR_ERROR_OVER_TEMP_WARN;
 210         } else {
 211                 data->temp_notif = REGULATOR_EVENT_OVER_TEMP;
 212                 data->temp_err = REGULATOR_ERROR_OVER_TEMP;
 213         }
 214 }
 215
 216 static int bd9576_set_limit(const struct linear_range *r, int num_ranges,
 217                             struct regmap *regmap, int reg, int mask, int lim)
 218 {
 219         int ret;
 220         bool found;
 221         int sel = 0;
 222
 223         if (lim) {
 224
 225                 ret = linear_range_get_selector_low_array(r, num_ranges,
 226                                                           lim, &sel, &found);
 227                 if (ret)
 228                         return ret;
 229
 230                 if (!found)
 231                         dev_warn(regmap_get_device(regmap),
 232                                  "limit %d out of range. Setting lower\n",
 233                                  lim);
 234         }
 235
 236         return regmap_update_bits(regmap, reg, mask, sel);
 237 }
 238
 239 static bool check_ocp_flag_mismatch(struct regulator_dev *rdev, int severity,
 240                                     struct bd957x_regulator_data *r)
 241 {
 242         if ((severity == REGULATOR_SEVERITY_ERR &&
 243             r->uvd_notif != REGULATOR_EVENT_OVER_CURRENT) ||
 244             (severity == REGULATOR_SEVERITY_WARN &&
 245             r->uvd_notif != REGULATOR_EVENT_OVER_CURRENT_WARN)) {
 246                 dev_warn(rdev_get_dev(rdev),
 247                          "Can't support both OCP WARN and ERR\n");
 248                 /* Do not overwrite ERR config with WARN */
 249                 if (severity == REGULATOR_SEVERITY_WARN)
 250                         return true;
 251
 252                 bd9576_fill_ocp_flags(r, 0);
 253         }
 254
 255         return false;
 256 }
 257
 258 static bool check_uvd_flag_mismatch(struct regulator_dev *rdev, int severity,
 259                                     struct bd957x_regulator_data *r)
 260 {
 261         if ((severity == REGULATOR_SEVERITY_ERR &&
 262              r->uvd_notif != REGULATOR_EVENT_UNDER_VOLTAGE) ||
 263              (severity == REGULATOR_SEVERITY_WARN &&
 264              r->uvd_notif != REGULATOR_EVENT_UNDER_VOLTAGE_WARN)) {
 265                 dev_warn(rdev_get_dev(rdev),
 266                          "Can't support both UVD WARN and ERR\n");
 267                 if (severity == REGULATOR_SEVERITY_WARN)
 268                         return true;
 269
 270                 bd9576_fill_uvd_flags(r, 0);
 271         }
 272
 273         return false;
 274 }
 275
 276 static bool check_ovd_flag_mismatch(struct regulator_dev *rdev, int severity,
 277                                     struct bd957x_regulator_data *r)
 278 {
 279         if ((severity == REGULATOR_SEVERITY_ERR &&
 280              r->ovd_notif != REGULATOR_EVENT_REGULATION_OUT) ||
 281              (severity == REGULATOR_SEVERITY_WARN &&
 282              r->ovd_notif != REGULATOR_EVENT_OVER_VOLTAGE_WARN)) {
 283                 dev_warn(rdev_get_dev(rdev),
 284                          "Can't support both OVD WARN and ERR\n");
 285                 if (severity == REGULATOR_SEVERITY_WARN)
 286                         return true;
 287
 288                 bd9576_fill_ovd_flags(r, 0);
 289         }
 290
 291         return false;
 292 }
 293
 294 static bool check_temp_flag_mismatch(struct regulator_dev *rdev, int severity,
 295                                     struct bd957x_regulator_data *r)
 296 {
 297         if ((severity == REGULATOR_SEVERITY_ERR &&
 298              r->temp_notif != REGULATOR_EVENT_OVER_TEMP) ||
 299              (severity == REGULATOR_SEVERITY_WARN &&
 300              r->temp_notif != REGULATOR_EVENT_OVER_TEMP_WARN)) {
 301                 dev_warn(rdev_get_dev(rdev),
 302                          "Can't support both thermal WARN and ERR\n");
 303                 if (severity == REGULATOR_SEVERITY_WARN)
 304                         return true;
 305         }
 306
 307         return false;
 308 }
 309
 310 static int bd9576_set_ocp(struct regulator_dev *rdev, int lim_uA, int severity,
 311                           bool enable)
 312 {
 313         struct bd957x_data *d;
 314         struct bd957x_regulator_data *r;
 315         int reg, mask;
 316         int Vfet, rfet;
 317         const struct linear_range *range;
 318         int num_ranges;
 319
 320         if ((lim_uA && !enable) || (!lim_uA && enable))
 321                 return -EINVAL;
 322
 323         r = container_of(rdev->desc, struct bd957x_regulator_data, desc);
 324         if (!r->oc_supported)
 325                 return -EINVAL;
 326
 327         d = rdev_get_drvdata(rdev);
 328
 329         if (severity == REGULATOR_SEVERITY_PROT) {
 330                 reg = r->ocp_reg;
 331                 mask = r->ocp_mask;
 332                 if (r->ocw_rfet) {
 333                         range = voutS1_ocp_ranges;
 334                         num_ranges = ARRAY_SIZE(voutS1_ocp_ranges);
 335                         rfet = r->ocw_rfet / 1000;
 336                 } else {
 337                         range = voutS1_ocp_ranges_internal;
 338                         num_ranges = ARRAY_SIZE(voutS1_ocp_ranges_internal);
 339                         /* Internal values are already micro-amperes */
 340                         rfet = 1000;
 341                 }
 342         } else {
 343                 reg = r->ocw_reg;
 344                 mask = r->ocw_mask;
 345
 346                 if (r->ocw_rfet) {
 347                         range = voutS1_ocw_ranges;
 348                         num_ranges = ARRAY_SIZE(voutS1_ocw_ranges);
 349                         rfet = r->ocw_rfet / 1000;
 350                 } else {
 351                         range = voutS1_ocw_ranges_internal;
 352                         num_ranges = ARRAY_SIZE(voutS1_ocw_ranges_internal);
 353                         /* Internal values are already micro-amperes */
 354                         rfet = 1000;
 355                 }
 356
 357                 /* We abuse uvd fields for OCW on VoutS1 */
 358                 if (r->uvd_notif) {
 359                         /*
 360                          * If both warning and error are requested, prioritize
 361                          * ERROR configuration
 362                          */
 363                         if (check_ocp_flag_mismatch(rdev, severity, r))
 364                                 return 0;
 365                 } else {
 366                         bool warn = severity == REGULATOR_SEVERITY_WARN;
 367
 368                         bd9576_fill_ocp_flags(r, warn);
 369                 }
 370         }
 371
 372         /*
 373          * limits are given in uA, rfet is mOhm
 374          * Divide lim_uA by 1000 to get Vfet in uV.
 375          * (We expect both Rfet and limit uA to be magnitude of hundreds of
 376          * milli Amperes & milli Ohms => we should still have decent accuracy)
 377          */
 378         Vfet = lim_uA/1000 * rfet;
 379
 380         return bd9576_set_limit(range, num_ranges, d->regmap,
 381                                 reg, mask, Vfet);
 382 }
 383
 384 static int bd9576_set_uvp(struct regulator_dev *rdev, int lim_uV, int severity,
 385                           bool enable)
 386 {
 387         struct bd957x_data *d;
 388         struct bd957x_regulator_data *r;
 389         int mask, reg;
 390
 391         if (severity == REGULATOR_SEVERITY_PROT) {
 392                 if (!enable || lim_uV)
 393                         return -EINVAL;
 394                 return 0;
 395         }
 396
 397         /*
 398          * BD9576 has enable control as a special value in limit reg. Can't
 399          * set limit but keep feature disabled or enable W/O given limit.
 400          */
 401         if ((lim_uV && !enable) || (!lim_uV && enable))
 402                 return -EINVAL;
 403
 404         r = container_of(rdev->desc, struct bd957x_regulator_data, desc);
 405         d = rdev_get_drvdata(rdev);
 406
 407         mask = r->xvd_mask;
 408         reg = r->uvd_reg;
 409         /*
 410          * Check that there is no mismatch for what the detection IRQs are to
 411          * be used.
 412          */
 413         if (r->uvd_notif) {
 414                 if (check_uvd_flag_mismatch(rdev, severity, r))
 415                         return 0;
 416         } else {
 417                 bd9576_fill_uvd_flags(r, severity == REGULATOR_SEVERITY_WARN);
 418         }
 419
 420         return bd9576_set_limit(r->xvd_ranges, r->num_xvd_ranges, d->regmap,
 421                                 reg, mask, lim_uV);
 422 }
 423
 424 static int bd9576_set_ovp(struct regulator_dev *rdev, int lim_uV, int severity,
 425                           bool enable)
 426 {
 427         struct bd957x_data *d;
 428         struct bd957x_regulator_data *r;
 429         int mask, reg;
 430
 431         if (severity == REGULATOR_SEVERITY_PROT) {
 432                 if (!enable || lim_uV)
 433                         return -EINVAL;
 434                 return 0;
 435         }
 436
 437         /*
 438          * BD9576 has enable control as a special value in limit reg. Can't
 439          * set limit but keep feature disabled or enable W/O given limit.
 440          */
 441         if ((lim_uV && !enable) || (!lim_uV && enable))
 442                 return -EINVAL;
 443
 444         r = container_of(rdev->desc, struct bd957x_regulator_data, desc);
 445         d = rdev_get_drvdata(rdev);
 446
 447         mask = r->xvd_mask;
 448         reg = r->ovd_reg;
 449         /*
 450          * Check that there is no mismatch for what the detection IRQs are to
 451          * be used.
 452          */
 453         if (r->ovd_notif) {
 454                 if (check_ovd_flag_mismatch(rdev, severity, r))
 455                         return 0;
 456         } else {
 457                 bd9576_fill_ovd_flags(r, severity == REGULATOR_SEVERITY_WARN);
 458         }
 459
 460         return bd9576_set_limit(r->xvd_ranges, r->num_xvd_ranges, d->regmap,
 461                                 reg, mask, lim_uV);
 462 }
 463
 464
 465 static int bd9576_set_tw(struct regulator_dev *rdev, int lim, int severity,
 466                           bool enable)
 467 {
 468         struct bd957x_data *d;
 469         struct bd957x_regulator_data *r;
 470         int i;
 471
 472         /*
 473          * BD9576MUF has fixed temperature limits
 474          * The detection can only be enabled/disabled
 475          */
 476         if (lim)
 477                 return -EINVAL;
 478
 479         /* Protection can't be disabled */
 480         if (severity == REGULATOR_SEVERITY_PROT) {
 481                 if (!enable)
 482                         return -EINVAL;
 483                 else
 484                         return 0;
 485         }
 486
 487         r = container_of(rdev->desc, struct bd957x_regulator_data, desc);
 488         d = rdev_get_drvdata(rdev);
 489
 490         /*
 491          * Check that there is no mismatch for what the detection IRQs are to
 492          * be used.
 493          */
 494         if (r->temp_notif)
 495                 if (check_temp_flag_mismatch(rdev, severity, r))
 496                         return 0;
 497
 498         bd9576_fill_temp_flags(r, enable, severity == REGULATOR_SEVERITY_WARN);
 499
 500         if (enable)
 501                 return regmap_update_bits(d->regmap, BD957X_REG_INT_THERM_MASK,
 502                                          BD9576_THERM_IRQ_MASK_TW, 0);
 503
 504         /*
 505          * If any of the regulators is interested in thermal warning we keep IRQ
 506          * enabled.
 507          */
 508         for (i = 0; i < BD9576_NUM_REGULATORS; i++)
 509                 if (d->regulator_data[i].temp_notif)
 510                         return 0;
 511
 512         return regmap_update_bits(d->regmap, BD957X_REG_INT_THERM_MASK,
 513                                   BD9576_THERM_IRQ_MASK_TW,
 514                                   BD9576_THERM_IRQ_MASK_TW);
 515 }
 516
 517 static const struct regulator_ops bd9573_vout34_ops = {
 518         .is_enabled = regulator_is_enabled_regmap,
 519         .list_voltage = bd957x_vout34_list_voltage,
 520         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 521 };
 522
 523 static const struct regulator_ops bd9576_vout34_ops = {
 524         .is_enabled = regulator_is_enabled_regmap,
 525         .list_voltage = bd957x_vout34_list_voltage,
 526         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 527         .set_over_voltage_protection = bd9576_set_ovp,
 528         .set_under_voltage_protection = bd9576_set_uvp,
 529         .set_thermal_protection = bd9576_set_tw,
 530 };
 531
 532 static const struct regulator_ops bd9573_vouts1_regulator_ops = {
 533         .is_enabled = regulator_is_enabled_regmap,
 534 };
 535
 536 static const struct regulator_ops bd9576_vouts1_regulator_ops = {
 537         .is_enabled = regulator_is_enabled_regmap,
 538         .set_over_current_protection = bd9576_set_ocp,
 539 };
 540
 541 static const struct regulator_ops bd9573_ops = {
 542         .is_enabled = regulator_is_enabled_regmap,
 543         .list_voltage = bd957x_list_voltage,
 544         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 545 };
 546
 547 static const struct regulator_ops bd9576_ops = {
 548         .is_enabled = regulator_is_enabled_regmap,
 549         .list_voltage = bd957x_list_voltage,
 550         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 551         .set_over_voltage_protection = bd9576_set_ovp,
 552         .set_under_voltage_protection = bd9576_set_uvp,
 553         .set_thermal_protection = bd9576_set_tw,
 554 };
 555
 556 static const struct regulator_ops  *bd9573_ops_arr[] = {
 557         [BD957X_VD50]   = &bd9573_ops,
 558         [BD957X_VD18]   = &bd9573_ops,
 559         [BD957X_VDDDR]  = &bd9573_vout34_ops,
 560         [BD957X_VD10]   = &bd9573_vout34_ops,
 561         [BD957X_VOUTL1] = &bd9573_ops,
 562         [BD957X_VOUTS1] = &bd9573_vouts1_regulator_ops,
 563 };
 564
 565 static const struct regulator_ops  *bd9576_ops_arr[] = {
 566         [BD957X_VD50]   = &bd9576_ops,
 567         [BD957X_VD18]   = &bd9576_ops,
 568         [BD957X_VDDDR]  = &bd9576_vout34_ops,
 569         [BD957X_VD10]   = &bd9576_vout34_ops,
 570         [BD957X_VOUTL1] = &bd9576_ops,
 571         [BD957X_VOUTS1] = &bd9576_vouts1_regulator_ops,
 572 };
 573
 574 static int vouts1_get_fet_res(struct device_node *np,
 575                                 const struct regulator_desc *desc,
 576                                 struct regulator_config *cfg)
 577 {
 578         struct bd957x_regulator_data *data;
 579         int ret;
 580         u32 uohms;
 581
 582         data = container_of(desc, struct bd957x_regulator_data, desc);
 583
 584         ret = of_property_read_u32(np, "rohm,ocw-fet-ron-micro-ohms", &uohms);
 585         if (ret) {
 586                 if (ret != -EINVAL)
 587                         return ret;
 588
 589                 return 0;
 590         }
 591         data->ocw_rfet = uohms;
 592         return 0;
 593 }
 594
 595 static struct bd957x_data bd957x_regulators = {
 596         .regulator_data = {
 597                 {
 598                         .desc = {
 599                                 .name = "VD50",
 600                                 .of_match = of_match_ptr("regulator-vd50"),
 601                                 .regulators_node = of_match_ptr("regulators"),
 602                                 .id = BD957X_VD50,
 603                                 .type = REGULATOR_VOLTAGE,
 604                                 .volt_table = &vout1_volt_table[0],
 605                                 .n_voltages = ARRAY_SIZE(vout1_volt_table),
 606                                 .vsel_reg = BD957X_REG_VOUT1_TUNE,
 607                                 .vsel_mask = BD957X_MASK_VOUT1_TUNE,
 608                                 .enable_reg = BD957X_REG_POW_TRIGGER1,
 609                                 .enable_mask = BD957X_REGULATOR_EN_MASK,
 610                                 .enable_val = BD957X_REGULATOR_DIS_VAL,
 611                                 .enable_is_inverted = true,
 612                                 .owner = THIS_MODULE,
 613                         },
 614                         .xvd_ranges = vout1_xvd_ranges,
 615                         .num_xvd_ranges = ARRAY_SIZE(vout1_xvd_ranges),
 616                         .ovd_reg = BD9576_REG_VOUT1_OVD,
 617                         .uvd_reg = BD9576_REG_VOUT1_UVD,
 618                         .xvd_mask = BD9576_MASK_XVD,
 619                 },
 620                 {
 621                         .desc = {
 622                                 .name = "VD18",
 623                                 .of_match = of_match_ptr("regulator-vd18"),
 624                                 .regulators_node = of_match_ptr("regulators"),
 625                                 .id = BD957X_VD18,
 626                                 .type = REGULATOR_VOLTAGE,
 627                                 .volt_table = &vout2_volt_table[0],
 628                                 .n_voltages = ARRAY_SIZE(vout2_volt_table),
 629                                 .vsel_reg = BD957X_REG_VOUT2_TUNE,
 630                                 .vsel_mask = BD957X_MASK_VOUT2_TUNE,
 631                                 .enable_reg = BD957X_REG_POW_TRIGGER2,
 632                                 .enable_mask = BD957X_REGULATOR_EN_MASK,
 633                                 .enable_val = BD957X_REGULATOR_DIS_VAL,
 634                                 .enable_is_inverted = true,
 635                                 .owner = THIS_MODULE,
 636                         },
 637                         .xvd_ranges = vout234_xvd_ranges,
 638                         .num_xvd_ranges = ARRAY_SIZE(vout234_xvd_ranges),
 639                         .ovd_reg = BD9576_REG_VOUT2_OVD,
 640                         .uvd_reg = BD9576_REG_VOUT2_UVD,
 641                         .xvd_mask = BD9576_MASK_XVD,
 642                 },
 643                 {
 644                         .desc = {
 645                                 .name = "VDDDR",
 646                                 .of_match = of_match_ptr("regulator-vdddr"),
 647                                 .regulators_node = of_match_ptr("regulators"),
 648                                 .id = BD957X_VDDDR,
 649                                 .type = REGULATOR_VOLTAGE,
 650                                 .n_voltages = BD957X_VOUTS34_NUM_VOLT,
 651                                 .vsel_reg = BD957X_REG_VOUT3_TUNE,
 652                                 .vsel_mask = BD957X_MASK_VOUT3_TUNE,
 653                                 .enable_reg = BD957X_REG_POW_TRIGGER3,
 654                                 .enable_mask = BD957X_REGULATOR_EN_MASK,
 655                                 .enable_val = BD957X_REGULATOR_DIS_VAL,
 656                                 .enable_is_inverted = true,
 657                                 .owner = THIS_MODULE,
 658                         },
 659                         .ovd_reg = BD9576_REG_VOUT3_OVD,
 660                         .uvd_reg = BD9576_REG_VOUT3_UVD,
 661                         .xvd_mask = BD9576_MASK_XVD,
 662                         .xvd_ranges = vout234_xvd_ranges,
 663                         .num_xvd_ranges = ARRAY_SIZE(vout234_xvd_ranges),
 664                 },
 665                 {
 666                         .desc = {
 667                                 .name = "VD10",
 668                                 .of_match = of_match_ptr("regulator-vd10"),
 669                                 .regulators_node = of_match_ptr("regulators"),
 670                                 .id = BD957X_VD10,
 671                                 .type = REGULATOR_VOLTAGE,
 672                                 .fixed_uV = BD957X_VOUTS4_BASE_VOLT,
 673                                 .n_voltages = BD957X_VOUTS34_NUM_VOLT,
 674                                 .vsel_reg = BD957X_REG_VOUT4_TUNE,
 675                                 .vsel_mask = BD957X_MASK_VOUT4_TUNE,
 676                                 .enable_reg = BD957X_REG_POW_TRIGGER4,
 677                                 .enable_mask = BD957X_REGULATOR_EN_MASK,
 678                                 .enable_val = BD957X_REGULATOR_DIS_VAL,
 679                                 .enable_is_inverted = true,
 680                                 .owner = THIS_MODULE,
 681                         },
 682                         .xvd_ranges = vout234_xvd_ranges,
 683                         .num_xvd_ranges = ARRAY_SIZE(vout234_xvd_ranges),
 684                         .ovd_reg = BD9576_REG_VOUT4_OVD,
 685                         .uvd_reg = BD9576_REG_VOUT4_UVD,
 686                         .xvd_mask = BD9576_MASK_XVD,
 687                 },
 688                 {
 689                         .desc = {
 690                                 .name = "VOUTL1",
 691                                 .of_match = of_match_ptr("regulator-voutl1"),
 692                                 .regulators_node = of_match_ptr("regulators"),
 693                                 .id = BD957X_VOUTL1,
 694                                 .type = REGULATOR_VOLTAGE,
 695                                 .volt_table = &voutl1_volt_table[0],
 696                                 .n_voltages = ARRAY_SIZE(voutl1_volt_table),
 697                                 .vsel_reg = BD957X_REG_VOUTL1_TUNE,
 698                                 .vsel_mask = BD957X_MASK_VOUTL1_TUNE,
 699                                 .enable_reg = BD957X_REG_POW_TRIGGERL1,
 700                                 .enable_mask = BD957X_REGULATOR_EN_MASK,
 701                                 .enable_val = BD957X_REGULATOR_DIS_VAL,
 702                                 .enable_is_inverted = true,
 703                                 .owner = THIS_MODULE,
 704                         },
 705                         .xvd_ranges = voutL1_xvd_ranges,
 706                         .num_xvd_ranges = ARRAY_SIZE(voutL1_xvd_ranges),
 707                         .ovd_reg = BD9576_REG_VOUTL1_OVD,
 708                         .uvd_reg = BD9576_REG_VOUTL1_UVD,
 709                         .xvd_mask = BD9576_MASK_XVD,
 710                 },
 711                 {
 712                         .desc = {
 713                                 .name = "VOUTS1",
 714                                 .of_match = of_match_ptr("regulator-vouts1"),
 715                                 .regulators_node = of_match_ptr("regulators"),
 716                                 .id = BD957X_VOUTS1,
 717                                 .type = REGULATOR_VOLTAGE,
 718                                 .n_voltages = 1,
 719                                 .fixed_uV = BD957X_VOUTS1_VOLT,
 720                                 .enable_reg = BD957X_REG_POW_TRIGGERS1,
 721                                 .enable_mask = BD957X_REGULATOR_EN_MASK,
 722                                 .enable_val = BD957X_REGULATOR_DIS_VAL,
 723                                 .enable_is_inverted = true,
 724                                 .owner = THIS_MODULE,
 725                                 .of_parse_cb = vouts1_get_fet_res,
 726                         },
 727                         .oc_supported = true,
 728                         .ocw_reg = BD9576_REG_VOUT1S_OCW,
 729                         .ocw_mask = BD9576_MASK_VOUT1S_OCW,
 730                         .ocp_reg = BD9576_REG_VOUT1S_OCP,
 731                         .ocp_mask = BD9576_MASK_VOUT1S_OCP,
 732                 },
 733         },
 734 };
 735
 736 static int bd9576_renable(struct regulator_irq_data *rid, int reg, int mask)
 737 {
 738         int val, ret;
 739         struct bd957x_data *d = (struct bd957x_data *)rid->data;
 740
 741         ret = regmap_read(d->regmap, reg, &val);
 742         if (ret)
 743                 return REGULATOR_FAILED_RETRY;
 744
 745         if (rid->opaque && rid->opaque == (val & mask)) {
 746                 /*
 747                  * It seems we stil have same status. Ack and return
 748                  * information that we are still out of limits and core
 749                  * should not enable IRQ
 750                  */
 751                 regmap_write(d->regmap, reg, mask & val);
 752                 return REGULATOR_ERROR_ON;
 753         }
 754         rid->opaque = 0;
 755         /*
 756          * Status was changed. Either prolem was solved or we have new issues.
 757          * Let's re-enable IRQs and be prepared to report problems again
 758          */
 759         return REGULATOR_ERROR_CLEARED;
 760 }
 761
 762 static int bd9576_uvd_renable(struct regulator_irq_data *rid)
 763 {
 764         return bd9576_renable(rid, BD957X_REG_INT_UVD_STAT, UVD_IRQ_VALID_MASK);
 765 }
 766
 767 static int bd9576_ovd_renable(struct regulator_irq_data *rid)
 768 {
 769         return bd9576_renable(rid, BD957X_REG_INT_OVD_STAT, OVD_IRQ_VALID_MASK);
 770 }
 771
 772 static int bd9576_temp_renable(struct regulator_irq_data *rid)
 773 {
 774         return bd9576_renable(rid, BD957X_REG_INT_THERM_STAT,
 775                               BD9576_THERM_IRQ_MASK_TW);
 776 }
 777
 778 static int bd9576_uvd_handler(int irq, struct regulator_irq_data *rid,
 779                               unsigned long *dev_mask)
 780 {
 781         int val, ret, i;
 782         struct bd957x_data *d = (struct bd957x_data *)rid->data;
 783
 784         ret = regmap_read(d->regmap, BD957X_REG_INT_UVD_STAT, &val);
 785         if (ret)
 786                 return REGULATOR_FAILED_RETRY;
 787
 788         *dev_mask = 0;
 789
 790         rid->opaque = val & UVD_IRQ_VALID_MASK;
 791
 792         /*
 793          * Go through the set status bits and report either error or warning
 794          * to the notifier depending on what was flagged in DT
 795          */
 796         *dev_mask = val & BD9576_xVD_IRQ_MASK_VOUT1TO4;
 797         /* There is 1 bit gap in register after Vout1 .. Vout4 statuses */
 798         *dev_mask |= ((val & BD9576_xVD_IRQ_MASK_VOUTL1) >> 1);
 799         /*
 800          * We (ab)use the uvd for OCW notification. DT parsing should
 801          * have added correct OCW flag to uvd_notif and uvd_err for S1
 802          */
 803         *dev_mask |= ((val & BD9576_UVD_IRQ_MASK_VOUTS1_OCW) >> 1);
 804
 805         for_each_set_bit(i, dev_mask, 6) {
 806                 struct bd957x_regulator_data *rdata;
 807                 struct regulator_err_state *stat;
 808
 809                 rdata = &d->regulator_data[i];
 810                 stat  = &rid->states[i];
 811
 812                 stat->notifs    = rdata->uvd_notif;
 813                 stat->errors    = rdata->uvd_err;
 814         }
 815
 816         ret = regmap_write(d->regmap, BD957X_REG_INT_UVD_STAT,
 817                            UVD_IRQ_VALID_MASK & val);
 818
 819         return 0;
 820 }
 821
 822 static int bd9576_ovd_handler(int irq, struct regulator_irq_data *rid,
 823                               unsigned long *dev_mask)
 824 {
 825         int val, ret, i;
 826         struct bd957x_data *d = (struct bd957x_data *)rid->data;
 827
 828         ret = regmap_read(d->regmap, BD957X_REG_INT_OVD_STAT, &val);
 829         if (ret)
 830                 return REGULATOR_FAILED_RETRY;
 831
 832         rid->opaque = val & OVD_IRQ_VALID_MASK;
 833         *dev_mask = 0;
 834
 835         if (!(val & OVD_IRQ_VALID_MASK))
 836                 return 0;
 837
 838         *dev_mask = val & BD9576_xVD_IRQ_MASK_VOUT1TO4;
 839         /* There is 1 bit gap in register after Vout1 .. Vout4 statuses */
 840         *dev_mask |= ((val & BD9576_xVD_IRQ_MASK_VOUTL1) >> 1);
 841
 842         for_each_set_bit(i, dev_mask, 5) {
 843                 struct bd957x_regulator_data *rdata;
 844                 struct regulator_err_state *stat;
 845
 846                 rdata = &d->regulator_data[i];
 847                 stat  = &rid->states[i];
 848
 849                 stat->notifs    = rdata->ovd_notif;
 850                 stat->errors    = rdata->ovd_err;
 851         }
 852
 853         /* Clear the sub-IRQ status */
 854         regmap_write(d->regmap, BD957X_REG_INT_OVD_STAT,
 855                      OVD_IRQ_VALID_MASK & val);
 856
 857         return 0;
 858 }
 859
 860 #define BD9576_DEV_MASK_ALL_REGULATORS 0x3F
 861
 862 static int bd9576_thermal_handler(int irq, struct regulator_irq_data *rid,
 863                                   unsigned long *dev_mask)
 864 {
 865         int val, ret, i;
 866         struct bd957x_data *d = (struct bd957x_data *)rid->data;
 867
 868         ret = regmap_read(d->regmap, BD957X_REG_INT_THERM_STAT, &val);
 869         if (ret)
 870                 return REGULATOR_FAILED_RETRY;
 871
 872         if (!(val & BD9576_THERM_IRQ_MASK_TW)) {
 873                 *dev_mask = 0;
 874                 return 0;
 875         }
 876
 877         *dev_mask = BD9576_DEV_MASK_ALL_REGULATORS;
 878
 879         for (i = 0; i < BD9576_NUM_REGULATORS; i++) {
 880                 struct bd957x_regulator_data *rdata;
 881                 struct regulator_err_state *stat;
 882
 883                 rdata = &d->regulator_data[i];
 884                 stat  = &rid->states[i];
 885
 886                 stat->notifs    = rdata->temp_notif;
 887                 stat->errors    = rdata->temp_err;
 888         }
 889
 890         /* Clear the sub-IRQ status */
 891         regmap_write(d->regmap, BD957X_REG_INT_THERM_STAT,
 892                      BD9576_THERM_IRQ_MASK_TW);
 893
 894         return 0;
 895 }
 896
 897 static int bd957x_probe(struct platform_device *pdev)
 898 {
 899         int i;
 900         unsigned int num_reg_data;
 901         bool vout_mode, ddr_sel, may_have_irqs = false;
 902         struct regmap *regmap;
 903         struct bd957x_data *ic_data;
 904         struct regulator_config config = { 0 };
 905         /* All regulators are related to UVD and thermal IRQs... */
 906         struct regulator_dev *rdevs[BD9576_NUM_REGULATORS];
 907         /* ...But VoutS1 is not flagged by OVD IRQ */
 908         struct regulator_dev *ovd_devs[BD9576_NUM_OVD_REGULATORS];
 909         static const struct regulator_irq_desc bd9576_notif_uvd = {
 910                 .name = "bd9576-uvd",
 911                 .irq_off_ms = 1000,
 912                 .map_event = bd9576_uvd_handler,
 913                 .renable = bd9576_uvd_renable,
 914                 .data = &bd957x_regulators,
 915         };
 916         static const struct regulator_irq_desc bd9576_notif_ovd = {
 917                 .name = "bd9576-ovd",
 918                 .irq_off_ms = 1000,
 919                 .map_event = bd9576_ovd_handler,
 920                 .renable = bd9576_ovd_renable,
 921                 .data = &bd957x_regulators,
 922         };
 923         static const struct regulator_irq_desc bd9576_notif_temp = {
 924                 .name = "bd9576-temp",
 925                 .irq_off_ms = 1000,
 926                 .map_event = bd9576_thermal_handler,
 927                 .renable = bd9576_temp_renable,
 928                 .data = &bd957x_regulators,
 929         };
 930         enum rohm_chip_type chip = platform_get_device_id(pdev)->driver_data;
 931
 932         num_reg_data = ARRAY_SIZE(bd957x_regulators.regulator_data);
 933
 934         ic_data = &bd957x_regulators;
 935
 936         regmap = dev_get_regmap(pdev->dev.parent, NULL);
 937         if (!regmap) {
 938                 dev_err(&pdev->dev, "No regmap\n");
 939                 return -EINVAL;
 940         }
 941
 942         ic_data->regmap = regmap;
 943         vout_mode = device_property_read_bool(pdev->dev.parent,
 944                                               "rohm,vout1-en-low");
 945         if (vout_mode) {
 946                 struct gpio_desc *en;
 947
 948                 dev_dbg(&pdev->dev, "GPIO controlled mode\n");
 949
 950                 /* VOUT1 enable state judged by VOUT1_EN pin */
 951                 /* See if we have GPIO defined */
 952                 en = devm_fwnode_gpiod_get(&pdev->dev,
 953                                            dev_fwnode(pdev->dev.parent),
 954                                            "rohm,vout1-en", GPIOD_OUT_LOW,
 955                                            "vout1-en");
 956
 957                 /* VOUT1_OPS gpio ctrl */
 958                 /*
 959                  * Regulator core prioritizes the ena_gpio over
 960                  * enable/disable/is_enabled callbacks so no need to clear them
 961                  * even if GPIO is used. So, we can still use same ops.
 962                  *
 963                  * In theory it is possible someone wants to set vout1-en LOW
 964                  * during OTP loading and set VOUT1 to be controlled by GPIO -
 965                  * but control the GPIO from some where else than this driver.
 966                  * For that to work we should unset the is_enabled callback
 967                  * here.
 968                  *
 969                  * I believe such case where rohm,vout1-en-low is set and
 970                  * vout1-en-gpios is not is likely to be a misconfiguration.
 971                  * So let's just err out for now.
 972                  */
 973                 if (!IS_ERR(en))
 974                         config.ena_gpiod = en;
 975                 else
 976                         return dev_err_probe(&pdev->dev, PTR_ERR(en),
 977                                         "Failed to get VOUT1 control GPIO\n");
 978         }
 979
 980         /*
 981          * If more than one PMIC needs to be controlled by same processor then
 982          * allocate the regulator data array here and use bd9576_regulators as
 983          * template. At the moment I see no such use-case so I spare some
 984          * bytes and use bd9576_regulators directly for non-constant configs
 985          * like DDR voltage selection.
 986          */
 987         platform_set_drvdata(pdev, ic_data);
 988         ddr_sel = device_property_read_bool(pdev->dev.parent,
 989                                             "rohm,ddr-sel-low");
 990         if (ddr_sel)
 991                 ic_data->regulator_data[2].desc.fixed_uV = 1350000;
 992         else
 993                 ic_data->regulator_data[2].desc.fixed_uV = 1500000;
 994
 995         switch (chip) {
 996         case ROHM_CHIP_TYPE_BD9576:
 997                 may_have_irqs = true;
 998                 dev_dbg(&pdev->dev, "Found BD9576MUF\n");
 999                 break;
1000         case ROHM_CHIP_TYPE_BD9573:
1001                 dev_dbg(&pdev->dev, "Found BD9573MUF\n");
1002                 break;
1003         default:
1004                 dev_err(&pdev->dev, "Unsupported chip type\n");
1005                 return -EINVAL;
1006         }
1007
1008         for (i = 0; i < num_reg_data; i++) {
1009                 struct regulator_desc *d;
1010
1011                 d = &ic_data->regulator_data[i].desc;
1012
1013
1014                 if (may_have_irqs) {
1015                         if (d->id >= ARRAY_SIZE(bd9576_ops_arr))
1016                                 return -EINVAL;
1017
1018                         d->ops = bd9576_ops_arr[d->id];
1019                 } else {
1020                         if (d->id >= ARRAY_SIZE(bd9573_ops_arr))
1021                                 return -EINVAL;
1022
1023                         d->ops = bd9573_ops_arr[d->id];
1024                 }
1025         }
1026
1027         config.dev = pdev->dev.parent;
1028         config.regmap = regmap;
1029         config.driver_data = ic_data;
1030
1031         for (i = 0; i < num_reg_data; i++) {
1032
1033                 struct bd957x_regulator_data *r = &ic_data->regulator_data[i];
1034                 const struct regulator_desc *desc = &r->desc;
1035
1036                 r->rdev = devm_regulator_register(&pdev->dev, desc,
1037                                                            &config);
1038                 if (IS_ERR(r->rdev))
1039                         return dev_err_probe(&pdev->dev, PTR_ERR(r->rdev),
1040                                         "failed to register %s regulator\n",
1041                                         desc->name);
1042                 /*
1043                  * Clear the VOUT1 GPIO setting - rest of the regulators do not
1044                  * support GPIO control
1045                  */
1046                 config.ena_gpiod = NULL;
1047
1048                 if (!may_have_irqs)
1049                         continue;
1050
1051                 rdevs[i] = r->rdev;
1052                 if (i < BD957X_VOUTS1)
1053                         ovd_devs[i] = r->rdev;
1054         }
1055         if (may_have_irqs) {
1056                 void *ret;
1057                 /*
1058                  * We can add both the possible error and warning flags here
1059                  * because the core uses these only for status clearing and
1060                  * if we use warnings - errors are always clear and the other
1061                  * way around. We can also add CURRENT flag for all regulators
1062                  * because it is never set if it is not supported. Same applies
1063                  * to setting UVD for VoutS1 - it is not accidentally cleared
1064                  * as it is never set.
1065                  */
1066                 int uvd_errs = REGULATOR_ERROR_UNDER_VOLTAGE |
1067                                REGULATOR_ERROR_UNDER_VOLTAGE_WARN |
1068                                REGULATOR_ERROR_OVER_CURRENT |
1069                                REGULATOR_ERROR_OVER_CURRENT_WARN;
1070                 int ovd_errs = REGULATOR_ERROR_OVER_VOLTAGE_WARN |
1071                                REGULATOR_ERROR_REGULATION_OUT;
1072                 int temp_errs = REGULATOR_ERROR_OVER_TEMP |
1073                                 REGULATOR_ERROR_OVER_TEMP_WARN;
1074                 int irq;
1075
1076                 irq = platform_get_irq_byname(pdev, "bd9576-uvd");
1077
1078                 /* Register notifiers - can fail if IRQ is not given */
1079                 ret = devm_regulator_irq_helper(&pdev->dev, &bd9576_notif_uvd,
1080                                                 irq, 0, uvd_errs, NULL,
1081                                                 &rdevs[0],
1082                                                 BD9576_NUM_REGULATORS);
1083                 if (IS_ERR(ret)) {
1084                         if (PTR_ERR(ret) == -EPROBE_DEFER)
1085                                 return -EPROBE_DEFER;
1086
1087                         dev_warn(&pdev->dev, "UVD disabled %pe\n", ret);
1088                 }
1089
1090                 irq = platform_get_irq_byname(pdev, "bd9576-ovd");
1091
1092                 ret = devm_regulator_irq_helper(&pdev->dev, &bd9576_notif_ovd,
1093                                                 irq, 0, ovd_errs, NULL,
1094                                                 &ovd_devs[0],
1095                                                 BD9576_NUM_OVD_REGULATORS);
1096                 if (IS_ERR(ret)) {
1097                         if (PTR_ERR(ret) == -EPROBE_DEFER)
1098                                 return -EPROBE_DEFER;
1099
1100                         dev_warn(&pdev->dev, "OVD disabled %pe\n", ret);
1101                 }
1102                 irq = platform_get_irq_byname(pdev, "bd9576-temp");
1103
1104                 ret = devm_regulator_irq_helper(&pdev->dev, &bd9576_notif_temp,
1105                                                 irq, 0, temp_errs, NULL,
1106                                                 &rdevs[0],
1107                                                 BD9576_NUM_REGULATORS);
1108                 if (IS_ERR(ret)) {
1109                         if (PTR_ERR(ret) == -EPROBE_DEFER)
1110                                 return -EPROBE_DEFER;
1111
1112                         dev_warn(&pdev->dev, "Thermal warning disabled %pe\n",
1113                                  ret);
1114                 }
1115         }
1116         return 0;
1117 }
1118
1119 static const struct platform_device_id bd957x_pmic_id[] = {
1120         { "bd9573-regulator", ROHM_CHIP_TYPE_BD9573 },
1121         { "bd9576-regulator", ROHM_CHIP_TYPE_BD9576 },
1122         { },
1123 };
1124 MODULE_DEVICE_TABLE(platform, bd957x_pmic_id);
1125
1126 static struct platform_driver bd957x_regulator = {
1127         .driver = {
1128                 .name = "bd957x-pmic",
1129                 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
1130         },
1131         .probe = bd957x_probe,
1132         .id_table = bd957x_pmic_id,
1133 };
1134
1135 module_platform_driver(bd957x_regulator);
1136
1137 MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
1138 MODULE_DESCRIPTION("ROHM BD9576/BD9573 voltage regulator driver");
1139 MODULE_LICENSE("GPL");
1140 MODULE_ALIAS("platform:bd957x-pmic");