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
28struct 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
39static 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
84static 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
90static 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(dev: data->dev, propname: "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(dev: data->dev, propname: "fitipower,tdly-ms",
110 val: 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(dev: data->dev);
126 if (ret < 0)
127 return ret;
128
129 ret = regmap_write(map: data->regmap, FP9931_REG_PWRON_DELAY, val: tdlys);
130 pm_runtime_put_autosuspend(dev: data->dev);
131
132 return ret;
133}
134
135static 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(dev: data->dev);
143 if (ret < 0)
144 return ret;
145
146 ret = regmap_read(map: data->regmap, FP9931_REG_TMST_VALUE, val: &val);
147 if (ret)
148 return ret;
149
150 pm_runtime_put_autosuspend(dev: data->dev);
151 *temp = (s8)val * 1000;
152
153 return 0;
154}
155
156static 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
163static const struct hwmon_ops fp9931_hwmon_ops = {
164 .is_visible = fp9931_hwmon_is_visible,
165 .read = fp9931_hwmon_read,
166};
167
168static const struct hwmon_chip_info fp9931_chip_info = {
169 .ops = &fp9931_hwmon_ops,
170 .info = fp9931_info,
171};
172
173static 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(desc: data->en_ts_gpio, value: 0);
180
181 if (data->vin_reg) {
182 ret = regulator_disable(regulator: data->vin_reg);
183 regcache_mark_dirty(map: data->regmap);
184 }
185
186 return ret;
187}
188
189static 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(regulator: data->vin_reg);
196
197 if (ret)
198 return ret;
199
200 if (data->en_ts_gpio) {
201 gpiod_set_value_cansleep(desc: data->en_ts_gpio, value: 1);
202 /* wait for one ADC conversion to have sane temperature */
203 usleep_range(min: 10000, max: 15000);
204 }
205
206 ret = regcache_sync(map: data->regmap);
207
208 return ret;
209}
210
211static bool fp9931_volatile_reg(struct device *dev, unsigned int reg)
212{
213 return reg == FP9931_REG_TMST_VALUE;
214}
215
216static const struct reg_default fp9931_reg_default = {
217 .reg = FP9931_REG_VCOM_SETTING,
218 .def = 0x80,
219};
220
221static 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
231static void disable_nopm(void *d)
232{
233 struct fp9931_data *data = d;
234
235 fp9931_runtime_suspend(dev: data->dev);
236}
237
238static 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(dev: 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(dev: data->dev);
250
251 return ret;
252}
253
254static 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(dev: data->dev);
261
262 return ret;
263}
264
265static 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(dev: data->dev))
271 return 0;
272
273 ret = pm_runtime_resume_and_get(dev: data->dev);
274 if (ret < 0)
275 return 0;
276
277 ret = regulator_is_enabled_regmap(rdev);
278
279 pm_runtime_put_autosuspend(dev: data->dev);
280 return ret;
281}
282
283static 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
290static 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(dev: data->dev))
295 return 0;
296
297 return gpiod_get_value_cansleep(desc: data->pgood_gpio);
298}
299
300static 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(dev: data->dev);
306 if (ret < 0)
307 return ret;
308
309 ret = regulator_get_voltage_sel_regmap(rdev);
310 pm_runtime_put_autosuspend(dev: data->dev);
311
312 return ret;
313}
314
315static 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(dev: data->dev);
321 if (ret < 0)
322 return ret;
323
324 ret = regulator_set_voltage_sel_regmap(rdev, sel: selector);
325 pm_runtime_put_autosuspend(dev: data->dev);
326
327 return ret;
328}
329
330static 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
339static 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(dev: data->dev);
345 if (ret < 0)
346 return ret;
347
348 reinit_completion(x: &data->pgood_completion);
349 gpiod_set_value_cansleep(desc: data->en_gpio, value: 1);
350 dev_dbg(data->dev, "turning on...");
351 wait_for_completion_timeout(x: &data->pgood_completion,
352 timeout: msecs_to_jiffies(PGOOD_TIMEOUT_MSECS));
353 dev_dbg(data->dev, "turned on");
354 if (gpiod_get_value_cansleep(desc: data->pgood_gpio) != 1) {
355 pm_runtime_put_autosuspend(dev: data->dev);
356 return -ETIMEDOUT;
357 }
358
359 return 0;
360}
361
362static int fp9931_clear_enable(struct regulator_dev *rdev)
363{
364 struct fp9931_data *data = rdev_get_drvdata(rdev);
365
366 gpiod_set_value_cansleep(desc: data->en_gpio, value: 0);
367 pm_runtime_put_autosuspend(dev: data->dev);
368 return 0;
369}
370
371static 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
381static 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
390static 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
433static 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(dev: &client->dev, size: sizeof(*data), GFP_KERNEL);
442 if (!data)
443 return -ENOMEM;
444
445 data->regmap = devm_regmap_init_i2c(client, &regmap_config);
446 if (IS_ERR(ptr: data->regmap))
447 return dev_err_probe(dev: &client->dev, err: PTR_ERR(ptr: data->regmap),
448 fmt: "failed to allocate regmap!\n");
449
450 data->vin_reg = devm_regulator_get_optional(dev: &client->dev, id: "vin");
451 if (IS_ERR(ptr: data->vin_reg))
452 return dev_err_probe(dev: &client->dev, err: PTR_ERR(ptr: data->vin_reg),
453 fmt: "failed to get vin regulator\n");
454
455 data->pgood_gpio = devm_gpiod_get(dev: &client->dev, con_id: "pg", flags: GPIOD_IN);
456 if (IS_ERR(ptr: data->pgood_gpio))
457 return dev_err_probe(dev: &client->dev,
458 err: PTR_ERR(ptr: data->pgood_gpio),
459 fmt: "failed to get power good gpio\n");
460
461 data->pgood_irq = gpiod_to_irq(desc: data->pgood_gpio);
462 if (data->pgood_irq < 0)
463 return data->pgood_irq;
464
465 data->en_gpio = devm_gpiod_get(dev: &client->dev, con_id: "enable", flags: GPIOD_OUT_LOW);
466 if (IS_ERR(ptr: data->en_gpio))
467 return dev_err_probe(dev: &client->dev, err: PTR_ERR(ptr: data->en_gpio),
468 fmt: "failed to get en gpio\n");
469
470 data->en_ts_gpio = devm_gpiod_get_optional(dev: &client->dev, con_id: "en-ts", flags: GPIOD_OUT_LOW);
471 if (IS_ERR(ptr: data->en_ts_gpio))
472 return dev_err_probe(dev: &client->dev,
473 err: PTR_ERR(ptr: data->en_ts_gpio),
474 fmt: "failed to get en gpio\n");
475
476 data->dev = &client->dev;
477 i2c_set_clientdata(client, data);
478
479 init_completion(x: &data->pgood_completion);
480
481 ret = devm_request_threaded_irq(dev: &client->dev, irq: data->pgood_irq, NULL,
482 thread_fn: pgood_handler,
483 IRQF_TRIGGER_RISING | IRQF_ONESHOT,
484 devname: "PGOOD", dev_id: data);
485 if (ret)
486 return dev_err_probe(dev: &client->dev, err: ret,
487 fmt: "failed to request irq\n");
488
489 if (IS_ENABLED(CONFIG_PM)) {
490 devm_pm_runtime_enable(dev: &client->dev);
491 pm_runtime_set_autosuspend_delay(dev: &client->dev, delay: 4000);
492 pm_runtime_use_autosuspend(dev: &client->dev);
493 } else {
494 ret = fp9931_runtime_resume(dev: &client->dev);
495 if (ret < 0)
496 return ret;
497
498 devm_add_action_or_reset(&client->dev, disable_nopm, data);
499 }
500
501 ret = setup_timings(data);
502 if (ret)
503 return dev_err_probe(dev: &client->dev, err: ret, fmt: "failed to setup timings\n");
504
505 config.driver_data = data;
506 config.dev = &client->dev;
507 config.regmap = data->regmap;
508
509 for (i = 0; i < ARRAY_SIZE(regulators); i++) {
510 rdev = devm_regulator_register(dev: &client->dev, regulator_desc: &regulators[i],
511 config: &config);
512 if (IS_ERR(ptr: rdev))
513 return dev_err_probe(dev: &client->dev, err: PTR_ERR(ptr: rdev),
514 fmt: "failed to register %s regulator\n",
515 regulators[i].name);
516 }
517
518 if (IS_REACHABLE(CONFIG_HWMON)) {
519 struct device *hwmon_dev;
520
521 hwmon_dev = devm_hwmon_device_register_with_info(dev: &client->dev, name: "fp9931", drvdata: data,
522 info: &fp9931_chip_info, NULL);
523 if (IS_ERR(ptr: hwmon_dev))
524 dev_notice(&client->dev, "failed to register hwmon\n");
525 }
526
527 return 0;
528}
529
530static const struct dev_pm_ops fp9931_pm_ops = {
531 SET_RUNTIME_PM_OPS(fp9931_runtime_suspend, fp9931_runtime_resume, NULL)
532};
533
534static const struct of_device_id fp9931_dt_ids[] = {
535 {
536 .compatible = "fitipower,fp9931",
537 }, {
538 /* sentinel */
539 }
540};
541MODULE_DEVICE_TABLE(of, fp9931_dt_ids);
542
543static struct i2c_driver fp9931_i2c_driver = {
544 .driver = {
545 .name = "fp9931",
546 .of_match_table = fp9931_dt_ids,
547 .pm = &fp9931_pm_ops,
548 },
549 .probe = fp9931_probe,
550};
551
552module_i2c_driver(fp9931_i2c_driver);
553
554/* Module information */
555MODULE_DESCRIPTION("FP9931 regulator driver");
556MODULE_LICENSE("GPL");
557
558

source code of linux/drivers/regulator/fp9931.c