1 // SPDX-License-Identifier: GPL-2.0-only 2 // Copyright (C) 2025 Andreas Kemnade 3 4 /* Datasheet: https://www.fitipower.com/dl/file/flXa6hIchVeu0W3K */ 5 6 #include <linux/cleanup.h> 7 #include <linux/completion.h> 8 #include <linux/gpio/consumer.h> 9 #include <linux/i2c.h> 10 #include <linux/module.h> 11 #include <linux/mutex.h> 12 #include <linux/hwmon.h> 13 #include <linux/pm_runtime.h> 14 #include <linux/property.h> 15 #include <linux/regulator/consumer.h> 16 #include <linux/regulator/driver.h> 17 #include <linux/regulator/machine.h> 18 #include <linux/regmap.h> 19 20 #define FP9931_REG_TMST_VALUE 0 21 #define FP9931_REG_VCOM_SETTING 1 22 #define FP9931_REG_VPOSNEG_SETTING 2 23 #define FP9931_REG_PWRON_DELAY 3 24 #define FP9931_REG_CONTROL_REG1 11 25 26 #define PGOOD_TIMEOUT_MSECS 200 27 28 struct fp9931_data { 29 struct device *dev; 30 struct regmap *regmap; 31 struct regulator *vin_reg; 32 struct gpio_desc *pgood_gpio; 33 struct gpio_desc *en_gpio; 34 struct gpio_desc *en_ts_gpio; 35 struct completion pgood_completion; 36 int pgood_irq; 37 }; 38 39 static const unsigned int VPOSNEG_table[] = { 40 7040000, 41 7040000, 42 7040000, 43 7040000, 44 7040000, 45 7040000, 46 7260000, 47 7490000, 48 7710000, 49 7930000, 50 8150000, 51 8380000, 52 8600000, 53 8820000, 54 9040000, 55 9270000, 56 9490000, 57 9710000, 58 9940000, 59 10160000, 60 10380000, 61 10600000, 62 10830000, 63 11050000, 64 11270000, 65 11490000, 66 11720000, 67 11940000, 68 12160000, 69 12380000, 70 12610000, 71 12830000, 72 13050000, 73 13280000, 74 13500000, 75 13720000, 76 13940000, 77 14170000, 78 14390000, 79 14610000, 80 14830000, 81 15060000, 82 }; 83 84 static const struct hwmon_channel_info *fp9931_info[] = { 85 HWMON_CHANNEL_INFO(chip, HWMON_C_REGISTER_TZ), 86 HWMON_CHANNEL_INFO(temp, HWMON_T_INPUT), 87 NULL 88 }; 89 90 static int setup_timings(struct fp9931_data *data) 91 { 92 u32 tdly[4]; 93 u8 tdlys = 0; 94 int i; 95 int ret; 96 97 ret = device_property_count_u32(data->dev, "fitipower,tdly-ms"); 98 if (ret == -EINVAL) /* property is optional */ 99 return 0; 100 101 if (ret < 0) 102 return ret; 103 104 if (ret != ARRAY_SIZE(tdly)) { 105 dev_err(data->dev, "invalid delay specification"); 106 return -EINVAL; 107 } 108 109 ret = device_property_read_u32_array(data->dev, "fitipower,tdly-ms", 110 tdly, ARRAY_SIZE(tdly)); 111 if (ret) 112 return ret; 113 114 for (i = ARRAY_SIZE(tdly) - 1; i >= 0; i--) { 115 if (tdly[i] > 4 || tdly[i] == 3) 116 return -EINVAL; 117 118 if (tdly[i] == 4) /* convert from ms */ 119 tdly[i] = 3; 120 121 tdlys <<= 2; 122 tdlys |= tdly[i]; 123 } 124 125 ret = pm_runtime_resume_and_get(data->dev); 126 if (ret < 0) 127 return ret; 128 129 ret = regmap_write(data->regmap, FP9931_REG_PWRON_DELAY, tdlys); 130 pm_runtime_put_autosuspend(data->dev); 131 132 return ret; 133 } 134 135 static int fp9931_hwmon_read(struct device *dev, enum hwmon_sensor_types type, 136 u32 attr, int channel, long *temp) 137 { 138 struct fp9931_data *data = dev_get_drvdata(dev); 139 unsigned int val; 140 int ret; 141 142 ret = pm_runtime_resume_and_get(data->dev); 143 if (ret < 0) 144 return ret; 145 146 ret = regmap_read(data->regmap, FP9931_REG_TMST_VALUE, &val); 147 if (ret) 148 return ret; 149 150 pm_runtime_put_autosuspend(data->dev); 151 *temp = (s8)val * 1000; 152 153 return 0; 154 } 155 156 static umode_t fp9931_hwmon_is_visible(const void *data, 157 enum hwmon_sensor_types type, 158 u32 attr, int channel) 159 { 160 return 0444; 161 } 162 163 static const struct hwmon_ops fp9931_hwmon_ops = { 164 .is_visible = fp9931_hwmon_is_visible, 165 .read = fp9931_hwmon_read, 166 }; 167 168 static const struct hwmon_chip_info fp9931_chip_info = { 169 .ops = &fp9931_hwmon_ops, 170 .info = fp9931_info, 171 }; 172 173 static int fp9931_runtime_suspend(struct device *dev) 174 { 175 int ret = 0; 176 struct fp9931_data *data = dev_get_drvdata(dev); 177 178 if (data->en_ts_gpio) 179 gpiod_set_value_cansleep(data->en_ts_gpio, 0); 180 181 if (data->vin_reg) { 182 ret = regulator_disable(data->vin_reg); 183 regcache_mark_dirty(data->regmap); 184 } 185 186 return ret; 187 } 188 189 static int fp9931_runtime_resume(struct device *dev) 190 { 191 int ret = 0; 192 struct fp9931_data *data = dev_get_drvdata(dev); 193 194 if (data->vin_reg) 195 ret = regulator_enable(data->vin_reg); 196 197 if (ret) 198 return ret; 199 200 if (data->en_ts_gpio) { 201 gpiod_set_value_cansleep(data->en_ts_gpio, 1); 202 /* wait for one ADC conversion to have sane temperature */ 203 usleep_range(10000, 15000); 204 } 205 206 ret = regcache_sync(data->regmap); 207 208 return ret; 209 } 210 211 static bool fp9931_volatile_reg(struct device *dev, unsigned int reg) 212 { 213 return reg == FP9931_REG_TMST_VALUE; 214 } 215 216 static const struct reg_default fp9931_reg_default = { 217 .reg = FP9931_REG_VCOM_SETTING, 218 .def = 0x80, 219 }; 220 221 static const struct regmap_config regmap_config = { 222 .reg_bits = 8, 223 .val_bits = 8, 224 .max_register = 12, 225 .cache_type = REGCACHE_FLAT, 226 .volatile_reg = fp9931_volatile_reg, 227 .reg_defaults = &fp9931_reg_default, 228 .num_reg_defaults = 1, 229 }; 230 231 static void disable_nopm(void *d) 232 { 233 struct fp9931_data *data = d; 234 235 fp9931_runtime_suspend(data->dev); 236 } 237 238 static int fp9931_v3p3_enable(struct regulator_dev *rdev) 239 { 240 struct fp9931_data *data = rdev_get_drvdata(rdev); 241 int ret; 242 243 ret = pm_runtime_resume_and_get(data->dev); 244 if (ret < 0) 245 return ret; 246 247 ret = regulator_enable_regmap(rdev); 248 if (ret < 0) 249 pm_runtime_put_autosuspend(data->dev); 250 251 return ret; 252 } 253 254 static int fp9931_v3p3_disable(struct regulator_dev *rdev) 255 { 256 struct fp9931_data *data = rdev_get_drvdata(rdev); 257 int ret; 258 259 ret = regulator_disable_regmap(rdev); 260 pm_runtime_put_autosuspend(data->dev); 261 262 return ret; 263 } 264 265 static int fp9931_v3p3_is_enabled(struct regulator_dev *rdev) 266 { 267 struct fp9931_data *data = rdev_get_drvdata(rdev); 268 int ret; 269 270 if (pm_runtime_status_suspended(data->dev)) 271 return 0; 272 273 ret = pm_runtime_resume_and_get(data->dev); 274 if (ret < 0) 275 return 0; 276 277 ret = regulator_is_enabled_regmap(rdev); 278 279 pm_runtime_put_autosuspend(data->dev); 280 return ret; 281 } 282 283 static const struct regulator_ops fp9931_v3p3ops = { 284 .list_voltage = regulator_list_voltage_linear, 285 .enable = fp9931_v3p3_enable, 286 .disable = fp9931_v3p3_disable, 287 .is_enabled = fp9931_v3p3_is_enabled, 288 }; 289 290 static int fp9931_check_powergood(struct regulator_dev *rdev) 291 { 292 struct fp9931_data *data = rdev_get_drvdata(rdev); 293 294 if (pm_runtime_status_suspended(data->dev)) 295 return 0; 296 297 return gpiod_get_value_cansleep(data->pgood_gpio); 298 } 299 300 static int fp9931_get_voltage_sel(struct regulator_dev *rdev) 301 { 302 struct fp9931_data *data = rdev_get_drvdata(rdev); 303 int ret; 304 305 ret = pm_runtime_resume_and_get(data->dev); 306 if (ret < 0) 307 return ret; 308 309 ret = regulator_get_voltage_sel_regmap(rdev); 310 pm_runtime_put_autosuspend(data->dev); 311 312 return ret; 313 } 314 315 static int fp9931_set_voltage_sel(struct regulator_dev *rdev, unsigned int selector) 316 { 317 struct fp9931_data *data = rdev_get_drvdata(rdev); 318 int ret; 319 320 ret = pm_runtime_resume_and_get(data->dev); 321 if (ret < 0) 322 return ret; 323 324 ret = regulator_set_voltage_sel_regmap(rdev, selector); 325 pm_runtime_put_autosuspend(data->dev); 326 327 return ret; 328 } 329 330 static irqreturn_t pgood_handler(int irq, void *dev_id) 331 { 332 struct fp9931_data *data = dev_id; 333 334 complete(&data->pgood_completion); 335 336 return IRQ_HANDLED; 337 } 338 339 static int fp9931_set_enable(struct regulator_dev *rdev) 340 { 341 struct fp9931_data *data = rdev_get_drvdata(rdev); 342 int ret; 343 344 ret = pm_runtime_resume_and_get(data->dev); 345 if (ret < 0) 346 return ret; 347 348 reinit_completion(&data->pgood_completion); 349 gpiod_set_value_cansleep(data->en_gpio, 1); 350 dev_dbg(data->dev, "turning on..."); 351 wait_for_completion_timeout(&data->pgood_completion, 352 msecs_to_jiffies(PGOOD_TIMEOUT_MSECS)); 353 dev_dbg(data->dev, "turned on"); 354 if (gpiod_get_value_cansleep(data->pgood_gpio) != 1) { 355 pm_runtime_put_autosuspend(data->dev); 356 return -ETIMEDOUT; 357 } 358 359 return 0; 360 } 361 362 static int fp9931_clear_enable(struct regulator_dev *rdev) 363 { 364 struct fp9931_data *data = rdev_get_drvdata(rdev); 365 366 gpiod_set_value_cansleep(data->en_gpio, 0); 367 pm_runtime_put_autosuspend(data->dev); 368 return 0; 369 } 370 371 static const struct regulator_ops fp9931_vcom_ops = { 372 .list_voltage = regulator_list_voltage_linear, 373 .map_voltage = regulator_map_voltage_linear, 374 .enable = fp9931_set_enable, 375 .disable = fp9931_clear_enable, 376 .is_enabled = fp9931_check_powergood, 377 .set_voltage_sel = fp9931_set_voltage_sel, 378 .get_voltage_sel = fp9931_get_voltage_sel, 379 }; 380 381 static const struct regulator_ops fp9931_vposneg_ops = { 382 .list_voltage = regulator_list_voltage_table, 383 .map_voltage = regulator_map_voltage_ascend, 384 /* gets enabled by enabling vcom, too */ 385 .is_enabled = fp9931_check_powergood, 386 .set_voltage_sel = fp9931_set_voltage_sel, 387 .get_voltage_sel = fp9931_get_voltage_sel, 388 }; 389 390 static const struct regulator_desc regulators[] = { 391 { 392 .name = "v3p3", 393 .of_match = of_match_ptr("v3p3"), 394 .id = 0, 395 .ops = &fp9931_v3p3ops, 396 .type = REGULATOR_VOLTAGE, 397 .owner = THIS_MODULE, 398 .enable_reg = FP9931_REG_CONTROL_REG1, 399 .enable_mask = BIT(1), 400 .n_voltages = 1, 401 .min_uV = 3300000 402 }, 403 { 404 .name = "vposneg", 405 .of_match = of_match_ptr("vposneg"), 406 .id = 1, 407 .ops = &fp9931_vposneg_ops, 408 .type = REGULATOR_VOLTAGE, 409 .owner = THIS_MODULE, 410 .n_voltages = ARRAY_SIZE(VPOSNEG_table), 411 .vsel_reg = FP9931_REG_VPOSNEG_SETTING, 412 .vsel_mask = 0x3F, 413 .volt_table = VPOSNEG_table, 414 }, 415 { 416 .name = "vcom", 417 .of_match = of_match_ptr("vcom"), 418 .id = 2, 419 .ops = &fp9931_vcom_ops, 420 .type = REGULATOR_VOLTAGE, 421 .owner = THIS_MODULE, 422 .n_voltages = 255, 423 .min_uV = 0, 424 .uV_step = 5000000 / 255, 425 .vsel_reg = FP9931_REG_VCOM_SETTING, 426 .vsel_mask = 0xFF 427 }, 428 }; 429 430 static int fp9931_probe(struct i2c_client *client) 431 { 432 struct fp9931_data *data; 433 struct regulator_config config = { }; 434 struct regulator_dev *rdev; 435 int ret = 0; 436 int i; 437 438 data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL); 439 data->regmap = devm_regmap_init_i2c(client, ®map_config); 440 if (IS_ERR(data->regmap)) 441 return dev_err_probe(&client->dev, PTR_ERR(data->regmap), 442 "failed to allocate regmap!\n"); 443 444 data->vin_reg = devm_regulator_get_optional(&client->dev, "vin"); 445 if (IS_ERR(data->vin_reg)) 446 return dev_err_probe(&client->dev, PTR_ERR(data->vin_reg), 447 "failed to get vin regulator\n"); 448 449 data->pgood_gpio = devm_gpiod_get(&client->dev, "pg", GPIOD_IN); 450 if (IS_ERR(data->pgood_gpio)) 451 return dev_err_probe(&client->dev, 452 PTR_ERR(data->pgood_gpio), 453 "failed to get power good gpio\n"); 454 455 data->pgood_irq = gpiod_to_irq(data->pgood_gpio); 456 if (data->pgood_irq < 0) 457 return data->pgood_irq; 458 459 data->en_gpio = devm_gpiod_get(&client->dev, "enable", GPIOD_OUT_LOW); 460 if (IS_ERR(data->en_gpio)) 461 return dev_err_probe(&client->dev, PTR_ERR(data->en_gpio), 462 "failed to get en gpio\n"); 463 464 data->en_ts_gpio = devm_gpiod_get_optional(&client->dev, "en-ts", GPIOD_OUT_LOW); 465 if (IS_ERR(data->en_ts_gpio)) 466 return dev_err_probe(&client->dev, 467 PTR_ERR(data->en_ts_gpio), 468 "failed to get en gpio\n"); 469 470 data->dev = &client->dev; 471 i2c_set_clientdata(client, data); 472 473 init_completion(&data->pgood_completion); 474 475 ret = devm_request_threaded_irq(&client->dev, data->pgood_irq, NULL, 476 pgood_handler, 477 IRQF_TRIGGER_RISING | IRQF_ONESHOT, 478 "PGOOD", data); 479 if (ret) 480 return dev_err_probe(&client->dev, ret, 481 "failed to request irq\n"); 482 483 if (IS_ENABLED(CONFIG_PM)) { 484 devm_pm_runtime_enable(&client->dev); 485 pm_runtime_set_autosuspend_delay(&client->dev, 4000); 486 pm_runtime_use_autosuspend(&client->dev); 487 } else { 488 ret = fp9931_runtime_resume(&client->dev); 489 if (ret < 0) 490 return ret; 491 492 devm_add_action_or_reset(&client->dev, disable_nopm, data); 493 } 494 495 ret = setup_timings(data); 496 if (ret) 497 return dev_err_probe(&client->dev, ret, "failed to setup timings\n"); 498 499 config.driver_data = data; 500 config.dev = &client->dev; 501 config.regmap = data->regmap; 502 503 for (i = 0; i < ARRAY_SIZE(regulators); i++) { 504 rdev = devm_regulator_register(&client->dev, ®ulators[i], 505 &config); 506 if (IS_ERR(rdev)) 507 return dev_err_probe(&client->dev, PTR_ERR(rdev), 508 "failed to register %s regulator\n", 509 regulators[i].name); 510 } 511 512 if (IS_REACHABLE(CONFIG_HWMON)) { 513 struct device *hwmon_dev; 514 515 hwmon_dev = devm_hwmon_device_register_with_info(&client->dev, "fp9931", data, 516 &fp9931_chip_info, NULL); 517 if (IS_ERR(hwmon_dev)) 518 dev_notice(&client->dev, "failed to register hwmon\n"); 519 } 520 521 return 0; 522 } 523 524 static const struct dev_pm_ops fp9931_pm_ops = { 525 SET_RUNTIME_PM_OPS(fp9931_runtime_suspend, fp9931_runtime_resume, NULL) 526 }; 527 528 static const struct of_device_id fp9931_dt_ids[] = { 529 { 530 .compatible = "fitipower,fp9931", 531 }, { 532 /* sentinel */ 533 } 534 }; 535 MODULE_DEVICE_TABLE(of, fp9931_dt_ids); 536 537 static struct i2c_driver fp9931_i2c_driver = { 538 .driver = { 539 .name = "fp9931", 540 .of_match_table = fp9931_dt_ids, 541 .pm = &fp9931_pm_ops, 542 }, 543 .probe = fp9931_probe, 544 }; 545 546 module_i2c_driver(fp9931_i2c_driver); 547 548 /* Module information */ 549 MODULE_DESCRIPTION("FP9931 regulator driver"); 550 MODULE_LICENSE("GPL"); 551 552