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