1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2022 Richtek Technology Corp. 4 * 5 * Author: ChiYuan Huang <cy_huang@richtek.com> 6 * 7 */ 8 9 #include <linux/bits.h> 10 #include <linux/delay.h> 11 #include <linux/gpio/consumer.h> 12 #include <linux/i2c.h> 13 #include <linux/interrupt.h> 14 #include <linux/kernel.h> 15 #include <linux/mod_devicetable.h> 16 #include <linux/module.h> 17 #include <linux/pm_runtime.h> 18 #include <linux/regmap.h> 19 #include <linux/regulator/consumer.h> 20 #include <linux/regulator/driver.h> 21 #include <linux/regulator/of_regulator.h> 22 23 #define RT6190_REG_VID 0x00 24 #define RT6190_REG_OUTV 0x01 25 #define RT6190_REG_OUTC 0x03 26 #define RT6190_REG_SET1 0x0D 27 #define RT6190_REG_SET2 0x0E 28 #define RT6190_REG_SET4 0x10 29 #define RT6190_REG_RATIO 0x11 30 #define RT6190_REG_OUT_VOLT_L 0x12 31 #define RT6190_REG_TEMP_H 0x1B 32 #define RT6190_REG_STAT1 0x1C 33 #define RT6190_REG_ALERT1 0x1E 34 #define RT6190_REG_ALERT2 0x1F 35 #define RT6190_REG_MASK2 0x21 36 #define RT6190_REG_OCPEN 0x28 37 #define RT6190_REG_SET5 0x29 38 #define RT6190_REG_VBUSC_ADC 0x32 39 #define RT6190_REG_BUSC_VOLT_L 0x33 40 #define RT6190_REG_BUSC_VOLT_H 0x34 41 #define RT6190_REG_STAT3 0x37 42 #define RT6190_REG_ALERT3 0x38 43 #define RT6190_REG_MASK3 0x39 44 45 #define RT6190_ENPWM_MASK BIT(7) 46 #define RT6190_ENDCHG_MASK BIT(4) 47 #define RT6190_ALERT_OTPEVT BIT(6) 48 #define RT6190_ALERT_UVPEVT BIT(5) 49 #define RT6190_ALERT_OVPEVT BIT(4) 50 #define RT6190_ENGCP_MASK BIT(1) 51 #define RT6190_FCCM_MASK BIT(7) 52 53 #define RICHTEK_VID 0x82 54 #define RT6190_OUT_MIN_UV 3000000 55 #define RT6190_OUT_MAX_UV 32000000 56 #define RT6190_OUT_STEP_UV 20000 57 #define RT6190_OUT_N_VOLT (RT6190_OUT_MAX_UV / RT6190_OUT_STEP_UV + 1) 58 #define RT6190_OUTV_MINSEL 150 59 #define RT6190_OUT_MIN_UA 306000 60 #define RT6190_OUT_MAX_UA 12114000 61 #define RT6190_OUT_STEP_UA 24000 62 #define RT6190_OUTC_MINSEL 19 63 #define RT6190_EN_TIME_US 500 64 65 #define RT6190_PSM_MODE 0 66 #define RT6190_FCCM_MODE 1 67 68 struct rt6190_data { 69 struct device *dev; 70 struct regmap *regmap; 71 struct gpio_desc *enable_gpio; 72 unsigned int cached_alert_evt; 73 }; 74 75 static int rt6190_out_set_voltage_sel(struct regulator_dev *rdev, 76 unsigned int selector) 77 { 78 struct regmap *regmap = rdev_get_regmap(rdev); 79 __le16 le_sel = cpu_to_le16(selector); 80 81 return regmap_raw_write(regmap, RT6190_REG_OUTV, &le_sel, 82 sizeof(le_sel)); 83 } 84 85 static int rt6190_out_get_voltage_sel(struct regulator_dev *rdev) 86 { 87 struct regmap *regmap = rdev_get_regmap(rdev); 88 __le16 le_sel; 89 int ret; 90 91 ret = regmap_raw_read(regmap, RT6190_REG_OUTV, &le_sel, sizeof(le_sel)); 92 93 return ret ?: le16_to_cpu(le_sel); 94 } 95 96 static int rt6190_out_enable(struct regulator_dev *rdev) 97 { 98 struct rt6190_data *data = rdev_get_drvdata(rdev); 99 struct regmap *regmap = rdev_get_regmap(rdev); 100 u8 out_cfg[4]; 101 int ret; 102 103 pm_runtime_get_sync(data->dev); 104 105 /* 106 * From off to on, vout config will restore to IC default. 107 * Read vout configs before enable, and restore them after enable 108 */ 109 ret = regmap_raw_read(regmap, RT6190_REG_OUTV, out_cfg, 110 sizeof(out_cfg)); 111 if (ret) 112 return ret; 113 114 ret = regulator_enable_regmap(rdev); 115 if (ret) 116 return ret; 117 118 ret = regmap_raw_write(regmap, RT6190_REG_OUTV, out_cfg, 119 sizeof(out_cfg)); 120 if (ret) 121 return ret; 122 123 return regmap_update_bits(regmap, RT6190_REG_SET5, RT6190_ENGCP_MASK, 124 RT6190_ENGCP_MASK); 125 } 126 127 static int rt6190_out_disable(struct regulator_dev *rdev) 128 { 129 struct rt6190_data *data = rdev_get_drvdata(rdev); 130 struct regmap *regmap = rdev_get_regmap(rdev); 131 int ret; 132 133 ret = regmap_update_bits(regmap, RT6190_REG_SET5, RT6190_ENGCP_MASK, 0); 134 if (ret) 135 return ret; 136 137 ret = regulator_disable_regmap(rdev); 138 if (ret) 139 return ret; 140 141 /* cleared cached alert event */ 142 data->cached_alert_evt = 0; 143 144 pm_runtime_put(data->dev); 145 146 return 0; 147 } 148 149 static int rt6190_out_set_current_limit(struct regulator_dev *rdev, int min_uA, 150 int max_uA) 151 { 152 struct regmap *regmap = rdev_get_regmap(rdev); 153 int csel, clim; 154 __le16 le_csel; 155 156 if (min_uA < RT6190_OUT_MIN_UA || max_uA > RT6190_OUT_MAX_UA) 157 return -EINVAL; 158 159 csel = DIV_ROUND_UP(min_uA - RT6190_OUT_MIN_UA, RT6190_OUT_STEP_UA); 160 161 clim = RT6190_OUT_MIN_UA + RT6190_OUT_STEP_UA * csel; 162 if (clim > max_uA) 163 return -EINVAL; 164 165 csel += RT6190_OUTC_MINSEL; 166 le_csel = cpu_to_le16(csel); 167 168 return regmap_raw_write(regmap, RT6190_REG_OUTC, &le_csel, 169 sizeof(le_csel)); 170 } 171 172 static int rt6190_out_get_current_limit(struct regulator_dev *rdev) 173 { 174 struct regmap *regmap = rdev_get_regmap(rdev); 175 __le16 le_csel; 176 int csel, ret; 177 178 ret = regmap_raw_read(regmap, RT6190_REG_OUTC, &le_csel, 179 sizeof(le_csel)); 180 if (ret) 181 return ret; 182 183 csel = le16_to_cpu(le_csel); 184 csel -= RT6190_OUTC_MINSEL; 185 186 return RT6190_OUT_MIN_UA + RT6190_OUT_STEP_UA * csel; 187 } 188 189 static int rt6190_out_set_mode(struct regulator_dev *rdev, unsigned int mode) 190 { 191 struct regmap *regmap = rdev_get_regmap(rdev); 192 unsigned int val; 193 194 switch (mode) { 195 case REGULATOR_MODE_FAST: 196 val = RT6190_FCCM_MASK; 197 break; 198 case REGULATOR_MODE_NORMAL: 199 val = 0; 200 break; 201 default: 202 return -EINVAL; 203 } 204 205 return regmap_update_bits(regmap, RT6190_REG_SET1, RT6190_FCCM_MASK, 206 val); 207 } 208 209 static unsigned int rt6190_out_get_mode(struct regulator_dev *rdev) 210 { 211 struct regmap *regmap = rdev_get_regmap(rdev); 212 unsigned int config; 213 int ret; 214 215 ret = regmap_read(regmap, RT6190_REG_SET1, &config); 216 if (ret) 217 return REGULATOR_MODE_INVALID; 218 219 if (config & RT6190_FCCM_MASK) 220 return REGULATOR_MODE_FAST; 221 222 return REGULATOR_MODE_NORMAL; 223 } 224 225 static int rt6190_out_get_error_flags(struct regulator_dev *rdev, 226 unsigned int *flags) 227 { 228 struct rt6190_data *data = rdev_get_drvdata(rdev); 229 unsigned int state, rpt_flags = 0; 230 int ret; 231 232 ret = regmap_read(data->regmap, RT6190_REG_STAT1, &state); 233 if (ret) 234 return ret; 235 236 state |= data->cached_alert_evt; 237 238 if (state & RT6190_ALERT_OTPEVT) 239 rpt_flags |= REGULATOR_ERROR_OVER_TEMP; 240 241 if (state & RT6190_ALERT_UVPEVT) 242 rpt_flags |= REGULATOR_ERROR_UNDER_VOLTAGE; 243 244 if (state & RT6190_ALERT_OVPEVT) 245 rpt_flags |= REGULATOR_ERROR_REGULATION_OUT; 246 247 *flags = rpt_flags; 248 249 return 0; 250 } 251 252 static unsigned int rt6190_out_of_map_mode(unsigned int mode) 253 { 254 switch (mode) { 255 case RT6190_PSM_MODE: 256 return REGULATOR_MODE_NORMAL; 257 case RT6190_FCCM_MODE: 258 return REGULATOR_MODE_FAST; 259 default: 260 return REGULATOR_MODE_INVALID; 261 } 262 } 263 264 static const struct regulator_ops rt6190_regulator_ops = { 265 .list_voltage = regulator_list_voltage_linear, 266 .set_voltage_sel = rt6190_out_set_voltage_sel, 267 .get_voltage_sel = rt6190_out_get_voltage_sel, 268 .enable = rt6190_out_enable, 269 .disable = rt6190_out_disable, 270 .is_enabled = regulator_is_enabled_regmap, 271 .set_current_limit = rt6190_out_set_current_limit, 272 .get_current_limit = rt6190_out_get_current_limit, 273 .set_active_discharge = regulator_set_active_discharge_regmap, 274 .set_mode = rt6190_out_set_mode, 275 .get_mode = rt6190_out_get_mode, 276 .get_error_flags = rt6190_out_get_error_flags, 277 }; 278 279 static const struct regulator_desc rt6190_regulator_desc = { 280 .name = "rt6190-regulator", 281 .type = REGULATOR_VOLTAGE, 282 .owner = THIS_MODULE, 283 .ops = &rt6190_regulator_ops, 284 .min_uV = RT6190_OUT_MIN_UV, 285 .uV_step = RT6190_OUT_STEP_UV, 286 .n_voltages = RT6190_OUT_N_VOLT, 287 .linear_min_sel = RT6190_OUTV_MINSEL, 288 .enable_reg = RT6190_REG_SET2, 289 .enable_mask = RT6190_ENPWM_MASK, 290 .active_discharge_reg = RT6190_REG_SET2, 291 .active_discharge_mask = RT6190_ENDCHG_MASK, 292 .active_discharge_on = RT6190_ENDCHG_MASK, 293 .of_map_mode = rt6190_out_of_map_mode, 294 }; 295 296 static bool rt6190_is_volatile_reg(struct device *dev, unsigned int reg) 297 { 298 switch (reg) { 299 case RT6190_REG_OUT_VOLT_L ... RT6190_REG_ALERT2: 300 case RT6190_REG_BUSC_VOLT_L ... RT6190_REG_BUSC_VOLT_H: 301 case RT6190_REG_STAT3 ... RT6190_REG_ALERT3: 302 return true; 303 default: 304 return false; 305 } 306 } 307 308 static const struct regmap_config rt6190_regmap_config = { 309 .name = "rt6190", 310 .cache_type = REGCACHE_FLAT, 311 .reg_bits = 8, 312 .val_bits = 8, 313 .max_register = RT6190_REG_MASK3, 314 .num_reg_defaults_raw = RT6190_REG_MASK3 + 1, 315 .volatile_reg = rt6190_is_volatile_reg, 316 }; 317 318 static irqreturn_t rt6190_irq_handler(int irq, void *devid) 319 { 320 struct regulator_dev *rdev = devid; 321 struct rt6190_data *data = rdev_get_drvdata(rdev); 322 unsigned int alert; 323 int ret; 324 325 ret = regmap_read(data->regmap, RT6190_REG_ALERT1, &alert); 326 if (ret) 327 return IRQ_NONE; 328 329 /* Write clear alert events */ 330 ret = regmap_write(data->regmap, RT6190_REG_ALERT1, alert); 331 if (ret) 332 return IRQ_NONE; 333 334 data->cached_alert_evt |= alert; 335 336 if (alert & RT6190_ALERT_OTPEVT) 337 regulator_notifier_call_chain(rdev, REGULATOR_EVENT_OVER_TEMP, NULL); 338 339 if (alert & RT6190_ALERT_UVPEVT) 340 regulator_notifier_call_chain(rdev, REGULATOR_EVENT_UNDER_VOLTAGE, NULL); 341 342 if (alert & RT6190_ALERT_OVPEVT) 343 regulator_notifier_call_chain(rdev, REGULATOR_EVENT_REGULATION_OUT, NULL); 344 345 return IRQ_HANDLED; 346 } 347 348 static int rt6190_init_registers(struct regmap *regmap) 349 { 350 int ret; 351 352 /* Enable_ADC = 1 */ 353 ret = regmap_write(regmap, RT6190_REG_SET4, 0x82); 354 if (ret) 355 return ret; 356 357 /* Config default VOUT ratio to be higher */ 358 ret = regmap_write(regmap, RT6190_REG_RATIO, 0x20); 359 360 /* Mask unused alert */ 361 ret = regmap_write(regmap, RT6190_REG_MASK2, 0); 362 if (ret) 363 return ret; 364 365 /* OCP config */ 366 ret = regmap_write(regmap, RT6190_REG_OCPEN, 0); 367 if (ret) 368 return ret; 369 370 /* Enable VBUSC ADC */ 371 return regmap_write(regmap, RT6190_REG_VBUSC_ADC, 0x02); 372 } 373 374 static int rt6190_probe(struct i2c_client *i2c) 375 { 376 struct device *dev = &i2c->dev; 377 struct rt6190_data *data; 378 struct gpio_desc *enable_gpio; 379 struct regmap *regmap; 380 struct regulator_dev *rdev; 381 struct regulator_config cfg = {}; 382 unsigned int vid; 383 int ret; 384 385 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 386 if (!data) 387 return -ENOMEM; 388 389 enable_gpio = devm_gpiod_get_optional(dev, "enable", GPIOD_OUT_HIGH); 390 if (IS_ERR(enable_gpio)) 391 return dev_err_probe(dev, PTR_ERR(enable_gpio), "Failed to get 'enable' gpio\n"); 392 else if (enable_gpio) 393 usleep_range(RT6190_EN_TIME_US, RT6190_EN_TIME_US * 2); 394 395 regmap = devm_regmap_init_i2c(i2c, &rt6190_regmap_config); 396 if (IS_ERR(regmap)) 397 return dev_err_probe(dev, PTR_ERR(regmap), "Failed to init regmap\n"); 398 399 data->dev = dev; 400 data->enable_gpio = enable_gpio; 401 data->regmap = regmap; 402 i2c_set_clientdata(i2c, data); 403 404 ret = regmap_read(regmap, RT6190_REG_VID, &vid); 405 if (ret) 406 return dev_err_probe(dev, ret, "Failed to read VID\n"); 407 408 if (vid != RICHTEK_VID) 409 return dev_err_probe(dev, -ENODEV, "Incorrect VID 0x%02x\n", vid); 410 411 ret = rt6190_init_registers(regmap); 412 if (ret) 413 return dev_err_probe(dev, ret, "Failed to init registers\n"); 414 415 pm_runtime_set_active(dev); 416 ret = devm_pm_runtime_enable(dev); 417 if (ret) 418 return dev_err_probe(dev, ret, "Failed to set pm_runtime enable\n"); 419 420 cfg.dev = dev; 421 cfg.of_node = dev->of_node; 422 cfg.driver_data = data; 423 cfg.init_data = of_get_regulator_init_data(dev, dev->of_node, 424 &rt6190_regulator_desc); 425 426 rdev = devm_regulator_register(dev, &rt6190_regulator_desc, &cfg); 427 if (IS_ERR(rdev)) 428 return dev_err_probe(dev, PTR_ERR(rdev), "Failed to register regulator\n"); 429 430 if (i2c->irq) { 431 ret = devm_request_threaded_irq(dev, i2c->irq, NULL, 432 rt6190_irq_handler, 433 IRQF_ONESHOT, dev_name(dev), 434 rdev); 435 if (ret) 436 return dev_err_probe(dev, ret, "Failed to register interrupt\n"); 437 } 438 439 return 0; 440 } 441 442 static int rt6190_runtime_suspend(struct device *dev) 443 { 444 struct rt6190_data *data = dev_get_drvdata(dev); 445 struct regmap *regmap = data->regmap; 446 447 if (!data->enable_gpio) 448 return 0; 449 450 regcache_cache_only(regmap, true); 451 regcache_mark_dirty(regmap); 452 453 gpiod_set_value(data->enable_gpio, 0); 454 455 return 0; 456 } 457 458 static int rt6190_runtime_resume(struct device *dev) 459 { 460 struct rt6190_data *data = dev_get_drvdata(dev); 461 struct regmap *regmap = data->regmap; 462 463 if (!data->enable_gpio) 464 return 0; 465 466 gpiod_set_value(data->enable_gpio, 1); 467 usleep_range(RT6190_EN_TIME_US, RT6190_EN_TIME_US * 2); 468 469 regcache_cache_only(regmap, false); 470 return regcache_sync(regmap); 471 } 472 473 static const struct dev_pm_ops __maybe_unused rt6190_dev_pm = { 474 RUNTIME_PM_OPS(rt6190_runtime_suspend, rt6190_runtime_resume, NULL) 475 }; 476 477 static const struct of_device_id rt6190_of_dev_table[] = { 478 { .compatible = "richtek,rt6190" }, 479 {} 480 }; 481 MODULE_DEVICE_TABLE(of, rt6190_of_dev_table); 482 483 static struct i2c_driver rt6190_driver = { 484 .driver = { 485 .name = "rt6190", 486 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 487 .of_match_table = rt6190_of_dev_table, 488 .pm = pm_ptr(&rt6190_dev_pm), 489 }, 490 .probe_new = rt6190_probe, 491 }; 492 module_i2c_driver(rt6190_driver); 493 494 MODULE_DESCRIPTION("Richtek RT6190 regulator driver"); 495 MODULE_AUTHOR("ChiYuan Huang <cy_huang@richtek.com>"); 496 MODULE_LICENSE("GPL"); 497