drivers/regulator/max77857-regulator.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2023 Analog Devices, Inc.
   4  * ADI Regulator driver for the MAX77857
   5  * MAX77859 and MAX77831.
   6  */
   7 #include <linux/bitfield.h>
   8 #include <linux/i2c.h>
   9 #include <linux/interrupt.h>
  10 #include <linux/module.h>
  11 #include <linux/regmap.h>
  12 #include <linux/regulator/driver.h>
  13 #include <linux/regulator/machine.h>
  14 #include <linux/regulator/of_regulator.h>
  15 #include <linux/util_macros.h>
  16
  17 #define MAX77857_REG_INT_SRC            0x10
  18 #define MAX77857_REG_INT_MASK           0x11
  19 #define MAX77857_REG_CONT1              0x12
  20 #define MAX77857_REG_CONT2              0x13
  21 #define MAX77857_REG_CONT3              0x14
  22
  23 #define MAX77857_INT_SRC_OCP            BIT(0)
  24 #define MAX77857_INT_SRC_THS            BIT(1)
  25 #define MAX77857_INT_SRC_HARDSHORT      BIT(2)
  26 #define MAX77857_INT_SRC_OVP            BIT(3)
  27 #define MAX77857_INT_SRC_POK            BIT(4)
  28
  29 #define MAX77857_ILIM_MASK              GENMASK(2, 0)
  30 #define MAX77857_CONT1_FREQ             GENMASK(4, 3)
  31 #define MAX77857_CONT3_FPWM             BIT(5)
  32
  33 #define MAX77859_REG_INT_SRC            0x11
  34 #define MAX77859_REG_CONT1              0x13
  35 #define MAX77859_REG_CONT2              0x14
  36 #define MAX77859_REG_CONT3              0x15
  37 #define MAX77859_REG_CONT5              0x17
  38 #define MAX77859_CONT2_FPWM             BIT(2)
  39 #define MAX77859_CONT2_INTB             BIT(3)
  40 #define MAX77859_CONT3_DVS_START        BIT(2)
  41 #define MAX77859_VOLTAGE_SEL_MASK       GENMASK(9, 0)
  42
  43 #define MAX77859_CURRENT_MIN            1000000
  44 #define MAX77859_CURRENT_MAX            5000000
  45 #define MAX77859_CURRENT_STEP           50000
  46
  47 enum max77857_id {
  48         ID_MAX77831 = 1,
  49         ID_MAX77857,
  50         ID_MAX77859,
  51         ID_MAX77859A,
  52 };
  53
  54 static bool max77857_volatile_reg(struct device *dev, unsigned int reg)
  55 {
  56         enum max77857_id id = (uintptr_t)dev_get_drvdata(dev);
  57
  58         switch (id) {
  59         case ID_MAX77831:
  60         case ID_MAX77857:
  61                 return reg == MAX77857_REG_INT_SRC;
  62         case ID_MAX77859:
  63         case ID_MAX77859A:
  64                 return reg == MAX77859_REG_INT_SRC;
  65         default:
  66                 return true;
  67         }
  68 }
  69
  70 static const struct regmap_config max77857_regmap_config = {
  71         .reg_bits = 8,
  72         .val_bits = 8,
  73         .cache_type = REGCACHE_MAPLE,
  74         .volatile_reg = max77857_volatile_reg,
  75 };
  76
  77 static int max77857_get_status(struct regulator_dev *rdev)
  78 {
  79         unsigned int val;
  80         int ret;
  81
  82         ret = regmap_read(rdev->regmap, MAX77857_REG_INT_SRC, &val);
  83         if (ret)
  84                 return ret;
  85
  86         if (FIELD_GET(MAX77857_INT_SRC_POK, val))
  87                 return REGULATOR_STATUS_ON;
  88
  89         return REGULATOR_STATUS_ERROR;
  90 }
  91
  92 static unsigned int max77857_get_mode(struct regulator_dev *rdev)
  93 {
  94         enum max77857_id id = (uintptr_t)rdev_get_drvdata(rdev);
  95         unsigned int regval;
  96         int ret;
  97
  98         switch (id) {
  99         case ID_MAX77831:
 100         case ID_MAX77857:
 101                 ret = regmap_read(rdev->regmap, MAX77857_REG_CONT3, &regval);
 102                 if (ret)
 103                         return ret;
 104
 105                 if (FIELD_GET(MAX77857_CONT3_FPWM, regval))
 106                         return REGULATOR_MODE_FAST;
 107
 108                 break;
 109         case ID_MAX77859:
 110         case ID_MAX77859A:
 111                 ret = regmap_read(rdev->regmap, MAX77859_REG_CONT2, &regval);
 112                 if (ret)
 113                         return ret;
 114
 115                 if (FIELD_GET(MAX77859_CONT2_FPWM, regval))
 116                         return REGULATOR_MODE_FAST;
 117
 118                 break;
 119         default:
 120                 return -EINVAL;
 121         }
 122
 123         return REGULATOR_MODE_NORMAL;
 124 }
 125
 126 static int max77857_set_mode(struct regulator_dev *rdev, unsigned int mode)
 127 {
 128         enum max77857_id id = (uintptr_t)rdev_get_drvdata(rdev);
 129         unsigned int reg, val;
 130
 131         switch (id) {
 132         case ID_MAX77831:
 133         case ID_MAX77857:
 134                 reg = MAX77857_REG_CONT3;
 135                 val = MAX77857_CONT3_FPWM;
 136                 break;
 137         case ID_MAX77859:
 138         case ID_MAX77859A:
 139                 reg = MAX77859_REG_CONT2;
 140                 val = MAX77859_CONT2_FPWM;
 141                 break;
 142         default:
 143                 return -EINVAL;
 144         }
 145
 146         switch (mode) {
 147         case REGULATOR_MODE_FAST:
 148                 return regmap_set_bits(rdev->regmap, reg, val);
 149         case REGULATOR_MODE_NORMAL:
 150                 return regmap_clear_bits(rdev->regmap, reg, val);
 151         default:
 152                 return -EINVAL;
 153         }
 154 }
 155
 156 static int max77857_get_error_flags(struct regulator_dev *rdev,
 157                                     unsigned int *flags)
 158 {
 159         unsigned int val;
 160         int ret;
 161
 162         ret = regmap_read(rdev->regmap, MAX77857_REG_INT_SRC, &val);
 163         if (ret)
 164                 return ret;
 165
 166         *flags = 0;
 167
 168         if (FIELD_GET(MAX77857_INT_SRC_OVP, val))
 169                 *flags |= REGULATOR_ERROR_OVER_VOLTAGE_WARN;
 170
 171         if (FIELD_GET(MAX77857_INT_SRC_OCP, val) ||
 172             FIELD_GET(MAX77857_INT_SRC_HARDSHORT, val))
 173                 *flags |= REGULATOR_ERROR_OVER_CURRENT;
 174
 175         if (FIELD_GET(MAX77857_INT_SRC_THS, val))
 176                 *flags |= REGULATOR_ERROR_OVER_TEMP;
 177
 178         if (!FIELD_GET(MAX77857_INT_SRC_POK, val))
 179                 *flags |= REGULATOR_ERROR_FAIL;
 180
 181         return 0;
 182 }
 183
 184 static struct linear_range max77859_lin_ranges[] = {
 185         REGULATOR_LINEAR_RANGE(3200000, 0x0A0, 0x320, 20000)
 186 };
 187
 188 static const unsigned int max77859_ramp_table[4] = {
 189         1000, 500, 250, 125
 190 };
 191
 192 static int max77859_set_voltage_sel(struct regulator_dev *rdev,
 193                                     unsigned int sel)
 194 {
 195         __be16 reg;
 196         int ret;
 197
 198         reg = cpu_to_be16(sel);
 199
 200         ret = regmap_bulk_write(rdev->regmap, MAX77859_REG_CONT3, &reg, 2);
 201         if (ret)
 202                 return ret;
 203
 204         /* actually apply new voltage */
 205         return regmap_set_bits(rdev->regmap, MAX77859_REG_CONT3,
 206                                MAX77859_CONT3_DVS_START);
 207 }
 208
 209 static int max77859_get_voltage_sel(struct regulator_dev *rdev)
 210 {
 211         __be16 reg;
 212         int ret;
 213
 214         ret = regmap_bulk_read(rdev->regmap, MAX77859_REG_CONT3, &reg, 2);
 215         if (ret)
 216                 return ret;
 217
 218         return FIELD_GET(MAX77859_VOLTAGE_SEL_MASK, __be16_to_cpu(reg));
 219 }
 220
 221 static int max77859_set_current_limit(struct regulator_dev *rdev, int min_uA, int max_uA)
 222 {
 223         u32 selector;
 224
 225         if (max_uA < MAX77859_CURRENT_MIN)
 226                 return -EINVAL;
 227
 228         selector = 0x12 + (max_uA - MAX77859_CURRENT_MIN) / MAX77859_CURRENT_STEP;
 229
 230         selector = clamp_val(selector, 0x00, 0x7F);
 231
 232         return regmap_write(rdev->regmap, MAX77859_REG_CONT5, selector);
 233 }
 234
 235 static int max77859_get_current_limit(struct regulator_dev *rdev)
 236 {
 237         u32 selector;
 238         int ret;
 239
 240         ret = regmap_read(rdev->regmap, MAX77859_REG_CONT5, &selector);
 241         if (ret)
 242                 return ret;
 243
 244         if (selector <= 0x12)
 245                 return MAX77859_CURRENT_MIN;
 246
 247         if (selector >= 0x64)
 248                 return MAX77859_CURRENT_MAX;
 249
 250         return MAX77859_CURRENT_MIN + (selector - 0x12) * MAX77859_CURRENT_STEP;
 251 }
 252
 253 static const struct regulator_ops max77859_regulator_ops = {
 254         .list_voltage = regulator_list_voltage_linear_range,
 255         .set_voltage_sel = max77859_set_voltage_sel,
 256         .get_voltage_sel = max77859_get_voltage_sel,
 257         .set_ramp_delay = regulator_set_ramp_delay_regmap,
 258         .get_status = max77857_get_status,
 259         .set_mode = max77857_set_mode,
 260         .get_mode = max77857_get_mode,
 261         .get_error_flags = max77857_get_error_flags,
 262 };
 263
 264 static const struct regulator_ops max77859a_regulator_ops = {
 265         .list_voltage = regulator_list_voltage_linear_range,
 266         .set_voltage_sel = max77859_set_voltage_sel,
 267         .get_voltage_sel = max77859_get_voltage_sel,
 268         .set_current_limit = max77859_set_current_limit,
 269         .get_current_limit = max77859_get_current_limit,
 270         .set_ramp_delay = regulator_set_ramp_delay_regmap,
 271         .get_status = max77857_get_status,
 272         .set_mode = max77857_set_mode,
 273         .get_mode = max77857_get_mode,
 274         .get_error_flags = max77857_get_error_flags,
 275 };
 276
 277 static const struct regulator_ops max77857_regulator_ops = {
 278         .list_voltage = regulator_list_voltage_linear_range,
 279         .set_voltage_sel = regulator_set_voltage_sel_regmap,
 280         .get_voltage_sel = regulator_get_voltage_sel_regmap,
 281         .set_ramp_delay = regulator_set_ramp_delay_regmap,
 282         .get_status = max77857_get_status,
 283         .set_mode = max77857_set_mode,
 284         .get_mode = max77857_get_mode,
 285         .get_error_flags = max77857_get_error_flags,
 286 };
 287
 288 static struct linear_range max77857_lin_ranges[] = {
 289         REGULATOR_LINEAR_RANGE(4485000, 0x3D, 0xCC, 73500)
 290 };
 291
 292 static const unsigned int max77857_switch_freq[] = {
 293         1200000, 1500000, 1800000, 2100000
 294 };
 295
 296 #define RAMAP_DELAY_INIT_VAL 1333
 297
 298 static const unsigned int max77857_ramp_table[2][4] = {
 299         { RAMAP_DELAY_INIT_VAL, 667, 333, 227 }, /* when switch freq is 1.8MHz or 2.1MHz */
 300         { 1166, 667, 333, 167 }, /* when switch freq is 1.2MHz or 1.5MHz */
 301 };
 302
 303 static struct regulator_desc max77857_regulator_desc = {
 304         .ops = &max77857_regulator_ops,
 305         .name = "max77857",
 306         .linear_ranges = max77857_lin_ranges,
 307         .n_linear_ranges = ARRAY_SIZE(max77857_lin_ranges),
 308         .vsel_mask = 0xFF,
 309         .vsel_reg = MAX77857_REG_CONT2,
 310         .ramp_delay_table = max77857_ramp_table[0],
 311         .n_ramp_values = ARRAY_SIZE(max77857_ramp_table[0]),
 312         .ramp_reg = MAX77857_REG_CONT3,
 313         .ramp_mask = GENMASK(1, 0),
 314         .ramp_delay = RAMAP_DELAY_INIT_VAL,
 315         .owner = THIS_MODULE,
 316 };
 317
 318 static void max77857_calc_range(struct device *dev, enum max77857_id id)
 319 {
 320         struct linear_range *range;
 321         unsigned long vref_step;
 322         u32 rtop = 0;
 323         u32 rbot = 0;
 324
 325         device_property_read_u32(dev, "adi,rtop-ohms", &rtop);
 326         device_property_read_u32(dev, "adi,rbot-ohms", &rbot);
 327
 328         if (!rbot || !rtop)
 329                 return;
 330
 331         switch (id) {
 332         case ID_MAX77831:
 333         case ID_MAX77857:
 334                 range = max77857_lin_ranges;
 335                 vref_step = 4900UL;
 336                 break;
 337         case ID_MAX77859:
 338         case ID_MAX77859A:
 339                 range = max77859_lin_ranges;
 340                 vref_step = 1250UL;
 341                 break;
 342         }
 343
 344         range->step = DIV_ROUND_CLOSEST(vref_step * (rbot + rtop), rbot);
 345         range->min = range->step * range->min_sel;
 346 }
 347
 348 static int max77857_probe(struct i2c_client *client)
 349 {
 350         const struct i2c_device_id *i2c_id;
 351         struct device *dev = &client->dev;
 352         struct regulator_config cfg = { };
 353         struct regulator_dev *rdev;
 354         struct regmap *regmap;
 355         enum max77857_id id;
 356         u32 switch_freq = 0;
 357         int ret;
 358
 359         i2c_id = i2c_client_get_device_id(client);
 360         if (!i2c_id)
 361                 return -EINVAL;
 362
 363         id = i2c_id->driver_data;
 364
 365         dev_set_drvdata(dev, (void *)id);
 366
 367         if (id == ID_MAX77859 || id == ID_MAX77859A) {
 368                 max77857_regulator_desc.ops = &max77859_regulator_ops;
 369                 max77857_regulator_desc.linear_ranges = max77859_lin_ranges;
 370                 max77857_regulator_desc.ramp_delay_table = max77859_ramp_table;
 371                 max77857_regulator_desc.ramp_delay = max77859_ramp_table[0];
 372         }
 373
 374         if (id == ID_MAX77859A)
 375                 max77857_regulator_desc.ops = &max77859a_regulator_ops;
 376
 377         max77857_calc_range(dev, id);
 378
 379         regmap = devm_regmap_init_i2c(client, &max77857_regmap_config);
 380         if (IS_ERR(regmap))
 381                 return dev_err_probe(dev, PTR_ERR(regmap),
 382                                      "cannot initialize regmap\n");
 383
 384         device_property_read_u32(dev, "adi,switch-frequency-hz", &switch_freq);
 385         if (switch_freq) {
 386                 switch_freq = find_closest(switch_freq, max77857_switch_freq,
 387                                            ARRAY_SIZE(max77857_switch_freq));
 388
 389                 if (id == ID_MAX77831 && switch_freq == 3)
 390                         switch_freq = 2;
 391
 392                 switch (id) {
 393                 case ID_MAX77831:
 394                 case ID_MAX77857:
 395                         ret = regmap_update_bits(regmap, MAX77857_REG_CONT1,
 396                                                  MAX77857_CONT1_FREQ, switch_freq);
 397
 398                         if (switch_freq >= 2)
 399                                 break;
 400
 401                         max77857_regulator_desc.ramp_delay_table = max77857_ramp_table[1];
 402                         max77857_regulator_desc.ramp_delay = max77857_ramp_table[1][0];
 403                         break;
 404                 case ID_MAX77859:
 405                 case ID_MAX77859A:
 406                         ret = regmap_update_bits(regmap, MAX77859_REG_CONT1,
 407                                                  MAX77857_CONT1_FREQ, switch_freq);
 408                         break;
 409                 }
 410                 if (ret)
 411                         return ret;
 412         }
 413
 414         cfg.dev = dev;
 415         cfg.driver_data = (void *)id;
 416         cfg.regmap = regmap;
 417         cfg.init_data = of_get_regulator_init_data(dev, dev->of_node,
 418                                                    &max77857_regulator_desc);
 419         if (!cfg.init_data)
 420                 return -ENOMEM;
 421
 422         rdev = devm_regulator_register(dev, &max77857_regulator_desc, &cfg);
 423         if (IS_ERR(rdev))
 424                 return dev_err_probe(dev, PTR_ERR(rdev),
 425                                      "cannot register regulator\n");
 426
 427         return 0;
 428 }
 429
 430 static const struct i2c_device_id max77857_id[] = {
 431         { "max77831", ID_MAX77831 },
 432         { "max77857", ID_MAX77857 },
 433         { "max77859", ID_MAX77859 },
 434         { "max77859a", ID_MAX77859A },
 435         { }
 436 };
 437 MODULE_DEVICE_TABLE(i2c, max77857_id);
 438
 439 static const struct of_device_id max77857_of_id[] = {
 440         { .compatible = "adi,max77831", .data = (void *)ID_MAX77831 },
 441         { .compatible = "adi,max77857", .data = (void *)ID_MAX77857 },
 442         { .compatible = "adi,max77859", .data = (void *)ID_MAX77859 },
 443         { .compatible = "adi,max77859a", .data = (void *)ID_MAX77859A },
 444         { }
 445 };
 446 MODULE_DEVICE_TABLE(of, max77857_of_id);
 447
 448 static struct i2c_driver max77857_driver = {
 449         .driver = {
 450                 .name = "max77857",
 451                 .of_match_table = max77857_of_id,
 452         },
 453         .id_table = max77857_id,
 454         .probe = max77857_probe,
 455 };
 456 module_i2c_driver(max77857_driver);
 457
 458 MODULE_DESCRIPTION("Analog Devices MAX77857 Buck-Boost Converter Driver");
 459 MODULE_AUTHOR("Ibrahim Tilki <Ibrahim.Tilki@analog.com>");
 460 MODULE_AUTHOR("Okan Sahin <Okan.Sahin@analog.com>");
 461 MODULE_LICENSE("GPL");