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
setup_timings(struct fp9931_data * data)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
fp9931_hwmon_read(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,long * temp)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
fp9931_hwmon_is_visible(const void * data,enum hwmon_sensor_types type,u32 attr,int channel)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
fp9931_runtime_suspend(struct device * dev)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
fp9931_runtime_resume(struct device * dev)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
fp9931_volatile_reg(struct device * dev,unsigned int reg)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
disable_nopm(void * d)231 static void disable_nopm(void *d)
232 {
233 struct fp9931_data *data = d;
234
235 fp9931_runtime_suspend(data->dev);
236 }
237
fp9931_v3p3_enable(struct regulator_dev * rdev)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
fp9931_v3p3_disable(struct regulator_dev * rdev)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
fp9931_v3p3_is_enabled(struct regulator_dev * rdev)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
fp9931_check_powergood(struct regulator_dev * rdev)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
fp9931_get_voltage_sel(struct regulator_dev * rdev)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
fp9931_set_voltage_sel(struct regulator_dev * rdev,unsigned int selector)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
pgood_handler(int irq,void * dev_id)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
fp9931_set_enable(struct regulator_dev * rdev)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
fp9931_clear_enable(struct regulator_dev * rdev)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 .regulators_node = of_match_ptr("regulators"),
395 .id = 0,
396 .ops = &fp9931_v3p3ops,
397 .type = REGULATOR_VOLTAGE,
398 .owner = THIS_MODULE,
399 .enable_reg = FP9931_REG_CONTROL_REG1,
400 .enable_mask = BIT(1),
401 .n_voltages = 1,
402 .min_uV = 3300000
403 },
404 {
405 .name = "vposneg",
406 .of_match = of_match_ptr("vposneg"),
407 .regulators_node = of_match_ptr("regulators"),
408 .id = 1,
409 .ops = &fp9931_vposneg_ops,
410 .type = REGULATOR_VOLTAGE,
411 .owner = THIS_MODULE,
412 .n_voltages = ARRAY_SIZE(VPOSNEG_table),
413 .vsel_reg = FP9931_REG_VPOSNEG_SETTING,
414 .vsel_mask = 0x3F,
415 .volt_table = VPOSNEG_table,
416 },
417 {
418 .name = "vcom",
419 .of_match = of_match_ptr("vcom"),
420 .regulators_node = of_match_ptr("regulators"),
421 .id = 2,
422 .ops = &fp9931_vcom_ops,
423 .type = REGULATOR_VOLTAGE,
424 .owner = THIS_MODULE,
425 .n_voltages = 255,
426 .min_uV = 0,
427 .uV_step = 5000000 / 255,
428 .vsel_reg = FP9931_REG_VCOM_SETTING,
429 .vsel_mask = 0xFF
430 },
431 };
432
fp9931_probe(struct i2c_client * client)433 static int fp9931_probe(struct i2c_client *client)
434 {
435 struct fp9931_data *data;
436 struct regulator_config config = { };
437 struct regulator_dev *rdev;
438 int ret = 0;
439 int i;
440
441 data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
442 data->regmap = devm_regmap_init_i2c(client, ®map_config);
443 if (IS_ERR(data->regmap))
444 return dev_err_probe(&client->dev, PTR_ERR(data->regmap),
445 "failed to allocate regmap!\n");
446
447 data->vin_reg = devm_regulator_get_optional(&client->dev, "vin");
448 if (IS_ERR(data->vin_reg))
449 return dev_err_probe(&client->dev, PTR_ERR(data->vin_reg),
450 "failed to get vin regulator\n");
451
452 data->pgood_gpio = devm_gpiod_get(&client->dev, "pg", GPIOD_IN);
453 if (IS_ERR(data->pgood_gpio))
454 return dev_err_probe(&client->dev,
455 PTR_ERR(data->pgood_gpio),
456 "failed to get power good gpio\n");
457
458 data->pgood_irq = gpiod_to_irq(data->pgood_gpio);
459 if (data->pgood_irq < 0)
460 return data->pgood_irq;
461
462 data->en_gpio = devm_gpiod_get(&client->dev, "enable", GPIOD_OUT_LOW);
463 if (IS_ERR(data->en_gpio))
464 return dev_err_probe(&client->dev, PTR_ERR(data->en_gpio),
465 "failed to get en gpio\n");
466
467 data->en_ts_gpio = devm_gpiod_get_optional(&client->dev, "en-ts", GPIOD_OUT_LOW);
468 if (IS_ERR(data->en_ts_gpio))
469 return dev_err_probe(&client->dev,
470 PTR_ERR(data->en_ts_gpio),
471 "failed to get en gpio\n");
472
473 data->dev = &client->dev;
474 i2c_set_clientdata(client, data);
475
476 init_completion(&data->pgood_completion);
477
478 ret = devm_request_threaded_irq(&client->dev, data->pgood_irq, NULL,
479 pgood_handler,
480 IRQF_TRIGGER_RISING | IRQF_ONESHOT,
481 "PGOOD", data);
482 if (ret)
483 return dev_err_probe(&client->dev, ret,
484 "failed to request irq\n");
485
486 if (IS_ENABLED(CONFIG_PM)) {
487 devm_pm_runtime_enable(&client->dev);
488 pm_runtime_set_autosuspend_delay(&client->dev, 4000);
489 pm_runtime_use_autosuspend(&client->dev);
490 } else {
491 ret = fp9931_runtime_resume(&client->dev);
492 if (ret < 0)
493 return ret;
494
495 devm_add_action_or_reset(&client->dev, disable_nopm, data);
496 }
497
498 ret = setup_timings(data);
499 if (ret)
500 return dev_err_probe(&client->dev, ret, "failed to setup timings\n");
501
502 config.driver_data = data;
503 config.dev = &client->dev;
504 config.regmap = data->regmap;
505
506 for (i = 0; i < ARRAY_SIZE(regulators); i++) {
507 rdev = devm_regulator_register(&client->dev, ®ulators[i],
508 &config);
509 if (IS_ERR(rdev))
510 return dev_err_probe(&client->dev, PTR_ERR(rdev),
511 "failed to register %s regulator\n",
512 regulators[i].name);
513 }
514
515 if (IS_REACHABLE(CONFIG_HWMON)) {
516 struct device *hwmon_dev;
517
518 hwmon_dev = devm_hwmon_device_register_with_info(&client->dev, "fp9931", data,
519 &fp9931_chip_info, NULL);
520 if (IS_ERR(hwmon_dev))
521 dev_notice(&client->dev, "failed to register hwmon\n");
522 }
523
524 return 0;
525 }
526
527 static const struct dev_pm_ops fp9931_pm_ops = {
528 SET_RUNTIME_PM_OPS(fp9931_runtime_suspend, fp9931_runtime_resume, NULL)
529 };
530
531 static const struct of_device_id fp9931_dt_ids[] = {
532 {
533 .compatible = "fitipower,fp9931",
534 }, {
535 /* sentinel */
536 }
537 };
538 MODULE_DEVICE_TABLE(of, fp9931_dt_ids);
539
540 static struct i2c_driver fp9931_i2c_driver = {
541 .driver = {
542 .name = "fp9931",
543 .of_match_table = fp9931_dt_ids,
544 .pm = &fp9931_pm_ops,
545 },
546 .probe = fp9931_probe,
547 };
548
549 module_i2c_driver(fp9931_i2c_driver);
550
551 /* Module information */
552 MODULE_DESCRIPTION("FP9931 regulator driver");
553 MODULE_LICENSE("GPL");
554
555