Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1// SPDX-License-Identifier: GPL-2.0-only
2// Copyright (C) 2025 Andreas Kemnade
3
4/* Datasheet: https://www.ti.com/lit/gpn/tps65185 */
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 TPS65185_REG_TMST_VALUE 0
21#define TPS65185_REG_ENABLE 1
22#define TPS65185_REG_VADJ 2
23#define TPS65185_REG_VCOM1 3
24#define TPS65185_REG_VCOM2 4
25#define TPS65185_REG_INT_EN1 5
26#define TPS65185_REG_INT_EN2 6
27#define TPS65185_REG_INT1 7
28#define TPS65185_REG_INT2 8
29#define TPS65185_REG_TMST1 0xd
30#define TPS65185_REG_TMST2 0xe
31#define TPS65185_REG_PG 0xf
32#define TPS65185_REG_REVID 0x10
33
34#define TPS65185_READ_THERM BIT(7)
35#define TPS65185_CONV_END BIT(5)
36
37#define TPS65185_ENABLE_ACTIVE BIT(7)
38#define TPS65185_ENABLE_STANDBY BIT(6)
39
40#define PGOOD_TIMEOUT_MSECS 200
41
42struct tps65185_data {
43 struct device *dev;
44 struct regmap *regmap;
45 struct gpio_desc *pgood_gpio;
46 struct gpio_desc *pwrup_gpio;
47 struct gpio_desc *vcom_ctrl_gpio;
48 struct gpio_desc *wakeup_gpio;
49 struct completion pgood_completion;
50 int pgood_irq;
51 struct completion tmst_completion;
52};
53
54static const struct hwmon_channel_info *tps65185_info[] = {
55 HWMON_CHANNEL_INFO(chip, HWMON_C_REGISTER_TZ),
56 HWMON_CHANNEL_INFO(temp, HWMON_T_INPUT),
57 NULL
58};
59
60static int tps65185_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
61 u32 attr, int channel, long *temp)
62{
63 struct tps65185_data *data = dev_get_drvdata(dev);
64 unsigned int val;
65 int ret;
66
67 reinit_completion(&data->tmst_completion);
68 /* start acquisition */
69 regmap_update_bits(data->regmap, TPS65185_REG_TMST1,
70 TPS65185_READ_THERM, TPS65185_READ_THERM);
71 wait_for_completion_timeout(&data->tmst_completion,
72 msecs_to_jiffies(PGOOD_TIMEOUT_MSECS));
73 ret = regmap_read(data->regmap, TPS65185_REG_TMST1, &val);
74 if (!(val & TPS65185_CONV_END))
75 return -ETIMEDOUT;
76
77 ret = regmap_read(data->regmap, TPS65185_REG_TMST_VALUE, &val);
78 if (ret)
79 return ret;
80
81 *temp = (s8)val * 1000;
82
83 return 0;
84}
85
86static umode_t tps65185_hwmon_is_visible(const void *data,
87 enum hwmon_sensor_types type,
88 u32 attr, int channel)
89{
90 return 0444;
91}
92
93static const struct hwmon_ops tps65185_hwmon_ops = {
94 .is_visible = tps65185_hwmon_is_visible,
95 .read = tps65185_hwmon_read,
96};
97
98static const struct hwmon_chip_info tps65185_chip_info = {
99 .ops = &tps65185_hwmon_ops,
100 .info = tps65185_info,
101};
102
103static bool tps65185_volatile_reg(struct device *dev, unsigned int reg)
104{
105 switch (reg) {
106 case TPS65185_REG_TMST_VALUE:
107 case TPS65185_REG_ENABLE:
108 case TPS65185_REG_VCOM2:
109 case TPS65185_REG_INT1:
110 case TPS65185_REG_INT2:
111 case TPS65185_REG_TMST1:
112 return true;
113 default:
114 return false;
115 }
116}
117
118static const struct regmap_config regmap_config = {
119 .reg_bits = 8,
120 .val_bits = 8,
121 .max_register = 0x10,
122 .cache_type = REGCACHE_MAPLE,
123 .volatile_reg = tps65185_volatile_reg,
124};
125
126static const struct regulator_ops tps65185_v3p3ops = {
127 .list_voltage = regulator_list_voltage_linear,
128 .enable = regulator_enable_regmap,
129 .disable = regulator_disable_regmap,
130 .is_enabled = regulator_is_enabled_regmap,
131};
132
133static int tps65185_check_powergood(struct regulator_dev *rdev)
134{
135 struct tps65185_data *data = rdev_get_drvdata(rdev);
136
137 return gpiod_get_value_cansleep(data->pgood_gpio);
138}
139
140static int tps65185_vposneg_get_voltage_sel(struct regulator_dev *rdev)
141{
142 int ret;
143
144 ret = regulator_get_voltage_sel_regmap(rdev);
145 if (ret < 0)
146 return ret;
147
148 /* highest value is lowest voltage */
149 return 6 - ret;
150}
151
152static int tps65185_vposneg_set_voltage_sel(struct regulator_dev *rdev, unsigned int selector)
153{
154 return regulator_set_voltage_sel_regmap(rdev, 6 - selector);
155}
156
157static irqreturn_t pgood_handler(int irq, void *dev_id)
158{
159 struct tps65185_data *data = dev_id;
160
161 complete(&data->pgood_completion);
162
163 return IRQ_HANDLED;
164}
165
166static int tps65185_vposneg_enable(struct regulator_dev *rdev)
167{
168 struct tps65185_data *data = rdev_get_drvdata(rdev);
169 int ret;
170
171 reinit_completion(&data->pgood_completion);
172 if (data->pwrup_gpio)
173 ret = gpiod_set_value_cansleep(data->pwrup_gpio, 1);
174 else
175 ret = regmap_update_bits(data->regmap, TPS65185_REG_ENABLE,
176 TPS65185_ENABLE_ACTIVE,
177 TPS65185_ENABLE_ACTIVE);
178
179 if (ret)
180 return ret;
181
182 dev_dbg(data->dev, "turning on...");
183 wait_for_completion_timeout(&data->pgood_completion,
184 msecs_to_jiffies(PGOOD_TIMEOUT_MSECS));
185 dev_dbg(data->dev, "turned on");
186 if (gpiod_get_value_cansleep(data->pgood_gpio) != 1)
187 return -ETIMEDOUT;
188
189 return 0;
190}
191
192static int tps65185_vposneg_disable(struct regulator_dev *rdev)
193{
194 struct tps65185_data *data = rdev_get_drvdata(rdev);
195 int ret;
196
197 if (data->pwrup_gpio)
198 ret = gpiod_set_value_cansleep(data->pwrup_gpio, 0);
199 else
200 ret = regmap_update_bits(data->regmap, TPS65185_REG_ENABLE,
201 TPS65185_ENABLE_STANDBY,
202 TPS65185_ENABLE_STANDBY);
203
204 return ret;
205}
206
207static int tps65185_vcom_set_voltage_sel(struct regulator_dev *rdev, unsigned int selector)
208{
209 struct tps65185_data *data = rdev_get_drvdata(rdev);
210 int ret;
211
212 ret = regmap_update_bits(data->regmap, TPS65185_REG_VCOM2, BIT(0), selector >> 8);
213 if (ret < 0)
214 return ret;
215
216 return regmap_write(data->regmap, TPS65185_REG_VCOM1, selector & 0xFF);
217}
218
219static int tps65185_vcom_get_voltage_sel(struct regulator_dev *rdev)
220{
221 struct tps65185_data *data = rdev_get_drvdata(rdev);
222 int ret;
223 unsigned int sel, sel2;
224
225 ret = regmap_read(data->regmap, TPS65185_REG_VCOM1, &sel);
226 if (ret < 0)
227 return ret;
228
229 ret = regmap_read(data->regmap, TPS65185_REG_VCOM2, &sel2);
230 if (ret < 0)
231 return ret;
232
233 if (sel2 & BIT(0))
234 sel |= 0x100;
235
236 return sel;
237}
238
239static const struct regulator_ops tps65185_vcom_ops = {
240 .list_voltage = regulator_list_voltage_linear,
241 .map_voltage = regulator_map_voltage_linear,
242 .set_voltage_sel = tps65185_vcom_set_voltage_sel,
243 .get_voltage_sel = tps65185_vcom_get_voltage_sel,
244};
245
246static const struct regulator_ops tps65185_vposneg_ops = {
247 .list_voltage = regulator_list_voltage_linear,
248 .map_voltage = regulator_map_voltage_linear,
249 .enable = tps65185_vposneg_enable,
250 .disable = tps65185_vposneg_disable,
251 .is_enabled = tps65185_check_powergood,
252 .set_voltage_sel = tps65185_vposneg_set_voltage_sel,
253 .get_voltage_sel = tps65185_vposneg_get_voltage_sel,
254};
255
256static const struct regulator_desc regulators[] = {
257 {
258 .name = "v3p3",
259 .of_match = of_match_ptr("v3p3"),
260 .regulators_node = of_match_ptr("regulators"),
261 .id = 0,
262 .ops = &tps65185_v3p3ops,
263 .type = REGULATOR_VOLTAGE,
264 .owner = THIS_MODULE,
265 .enable_reg = TPS65185_REG_ENABLE,
266 .enable_mask = BIT(5),
267 .n_voltages = 1,
268 .min_uV = 3300000,
269 },
270 {
271 .name = "vposneg",
272 .of_match = of_match_ptr("vposneg"),
273 .regulators_node = of_match_ptr("regulators"),
274 .id = 1,
275 .ops = &tps65185_vposneg_ops,
276 .type = REGULATOR_VOLTAGE,
277 .owner = THIS_MODULE,
278 .n_voltages = 4,
279 .vsel_reg = TPS65185_REG_VADJ,
280 .vsel_mask = 0x7,
281 .min_uV = 14250000,
282 .uV_step = 250000,
283 }
284};
285
286static const struct regulator_desc vcom_regulator_desc = {
287 .name = "vcom",
288 .of_match = of_match_ptr("vcom"),
289 .regulators_node = of_match_ptr("regulators"),
290 .supply_name = "vposneg",
291 .id = 2,
292 .ops = &tps65185_vcom_ops,
293 .type = REGULATOR_VOLTAGE,
294 .owner = THIS_MODULE,
295 .n_voltages = 511,
296 .min_uV = 0,
297 .uV_step = 10000,
298};
299
300static irqreturn_t tps65185_irq_thread(int irq, void *dev_id)
301{
302 struct tps65185_data *data = dev_id;
303 unsigned int int_status_1, int_status_2;
304 int ret;
305
306 /* read both status to have irq cleared */
307 ret = regmap_read(data->regmap, TPS65185_REG_INT1, &int_status_1);
308 if (ret)
309 return IRQ_NONE;
310
311 ret = regmap_read(data->regmap, TPS65185_REG_INT2, &int_status_2);
312 if (ret)
313 return IRQ_NONE;
314
315 if (int_status_2 & BIT(0))
316 complete(&data->tmst_completion);
317
318 dev_dbg(data->dev, "irq status %02x %02x\n", int_status_1, int_status_2);
319
320 if (int_status_1 || int_status_2)
321 return IRQ_HANDLED;
322
323 return IRQ_NONE;
324}
325
326static int tps65185_probe(struct i2c_client *client)
327{
328 struct tps65185_data *data;
329 struct regulator_config config = { };
330 struct regulator_dev *rdev;
331 int ret = 0;
332 int i;
333
334 data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
335 if (!data)
336 return -ENOMEM;
337
338 data->regmap = devm_regmap_init_i2c(client, ®map_config);
339 if (IS_ERR(data->regmap))
340 return dev_err_probe(&client->dev, PTR_ERR(data->regmap),
341 "failed to allocate regmap!\n");
342
343 data->pgood_gpio = devm_gpiod_get(&client->dev, "pwr-good", GPIOD_IN);
344 if (IS_ERR(data->pgood_gpio))
345 return dev_err_probe(&client->dev,
346 PTR_ERR(data->pgood_gpio),
347 "failed to get power good gpio\n");
348
349 data->pgood_irq = gpiod_to_irq(data->pgood_gpio);
350 if (data->pgood_irq < 0)
351 return data->pgood_irq;
352
353 data->pwrup_gpio = devm_gpiod_get_optional(&client->dev, "enable", GPIOD_OUT_LOW);
354 if (IS_ERR(data->pwrup_gpio))
355 return dev_err_probe(&client->dev, PTR_ERR(data->pwrup_gpio),
356 "failed to get pwrup gpio\n");
357
358 data->wakeup_gpio = devm_gpiod_get_optional(&client->dev, "wakeup", GPIOD_OUT_HIGH);
359 if (IS_ERR(data->wakeup_gpio))
360 return dev_err_probe(&client->dev,
361 PTR_ERR(data->wakeup_gpio),
362 "failed to get wakeup gpio\n");
363
364 data->vcom_ctrl_gpio = devm_gpiod_get_optional(&client->dev, "vcom-ctrl", GPIOD_OUT_LOW);
365 if (IS_ERR(data->vcom_ctrl_gpio))
366 return dev_err_probe(&client->dev,
367 PTR_ERR(data->vcom_ctrl_gpio),
368 "failed to get vcm ctrl gpio\n");
369
370 ret = devm_regulator_get_enable(&client->dev, "vin");
371 if (ret)
372 return dev_err_probe(&client->dev, ret,
373 "failed to get vin regulator\n");
374
375 data->dev = &client->dev;
376 i2c_set_clientdata(client, data);
377
378 init_completion(&data->pgood_completion);
379 init_completion(&data->tmst_completion);
380
381 ret = devm_request_threaded_irq(&client->dev, data->pgood_irq, NULL,
382 pgood_handler,
383 IRQF_TRIGGER_RISING | IRQF_ONESHOT,
384 "PGOOD", data);
385 if (ret)
386 return dev_err_probe(&client->dev, ret,
387 "failed to request power good irq\n");
388
389 if (client->irq) {
390 ret = devm_request_threaded_irq(&client->dev, client->irq,
391 NULL, tps65185_irq_thread,
392 IRQF_TRIGGER_LOW | IRQF_ONESHOT,
393 "tps65185", data);
394 if (ret)
395 return dev_err_probe(&client->dev, ret,
396 "failed to request irq\n");
397 }
398
399 ret = regmap_update_bits(data->regmap, TPS65185_REG_INT_EN2, BIT(0), BIT(0));
400 if (ret)
401 return dev_err_probe(&client->dev, ret,
402 "failed to enable temp irq\n");
403
404 config.driver_data = data;
405 config.dev = &client->dev;
406 config.regmap = data->regmap;
407
408 for (i = 0; i < ARRAY_SIZE(regulators); i++) {
409 rdev = devm_regulator_register(&client->dev, ®ulators[i],
410 &config);
411 if (IS_ERR(rdev))
412 return dev_err_probe(&client->dev, PTR_ERR(rdev),
413 "failed to register %s regulator\n",
414 regulators[i].name);
415 }
416
417 config.ena_gpiod = data->vcom_ctrl_gpio;
418 rdev = devm_regulator_register(&client->dev, &vcom_regulator_desc, &config);
419 if (IS_ERR(rdev))
420 return dev_err_probe(&client->dev, PTR_ERR(rdev),
421 "failed to register vcom regulator\n");
422
423 if (IS_REACHABLE(CONFIG_HWMON)) {
424 struct device *hwmon_dev;
425
426 hwmon_dev = devm_hwmon_device_register_with_info(&client->dev, "tps65185", data,
427 &tps65185_chip_info, NULL);
428 if (IS_ERR(hwmon_dev))
429 dev_notice(&client->dev, "failed to register hwmon\n");
430 }
431
432 return 0;
433}
434
435static const struct of_device_id tps65185_dt_ids[] = {
436 {
437 .compatible = "ti,tps65185",
438 }, {
439 /* sentinel */
440 }
441};
442MODULE_DEVICE_TABLE(of, tps65185_dt_ids);
443
444static struct i2c_driver tps65185_i2c_driver = {
445 .driver = {
446 .name = "tps65185",
447 .of_match_table = tps65185_dt_ids,
448 },
449 .probe = tps65185_probe,
450};
451
452module_i2c_driver(tps65185_i2c_driver);
453
454/* Module information */
455MODULE_DESCRIPTION("TPS65185 regulator driver");
456MODULE_LICENSE("GPL");
457