1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Core driver for TI TPS65090 PMIC family
4 *
5 * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
6 *
7 * Author: Venu Byravarasu <vbyravarasu@nvidia.com>
8 */
9
10#include <linux/interrupt.h>
11#include <linux/irq.h>
12#include <linux/kernel.h>
13#include <linux/init.h>
14#include <linux/mutex.h>
15#include <linux/slab.h>
16#include <linux/i2c.h>
17#include <linux/mfd/core.h>
18#include <linux/mfd/tps65090.h>
19#include <linux/of.h>
20#include <linux/err.h>
21
22#define NUM_INT_REG 2
23
24#define TPS65090_INT1_MASK_VAC_STATUS_CHANGE		1
25#define TPS65090_INT1_MASK_VSYS_STATUS_CHANGE		2
26#define TPS65090_INT1_MASK_BAT_STATUS_CHANGE		3
27#define TPS65090_INT1_MASK_CHARGING_STATUS_CHANGE	4
28#define TPS65090_INT1_MASK_CHARGING_COMPLETE		5
29#define TPS65090_INT1_MASK_OVERLOAD_DCDC1		6
30#define TPS65090_INT1_MASK_OVERLOAD_DCDC2		7
31#define TPS65090_INT2_MASK_OVERLOAD_DCDC3		0
32#define TPS65090_INT2_MASK_OVERLOAD_FET1		1
33#define TPS65090_INT2_MASK_OVERLOAD_FET2		2
34#define TPS65090_INT2_MASK_OVERLOAD_FET3		3
35#define TPS65090_INT2_MASK_OVERLOAD_FET4		4
36#define TPS65090_INT2_MASK_OVERLOAD_FET5		5
37#define TPS65090_INT2_MASK_OVERLOAD_FET6		6
38#define TPS65090_INT2_MASK_OVERLOAD_FET7		7
39
40static const struct resource charger_resources[] = {
41	{
42		.start  = TPS65090_IRQ_VAC_STATUS_CHANGE,
43		.end    = TPS65090_IRQ_VAC_STATUS_CHANGE,
44		.flags  = IORESOURCE_IRQ,
45	}
46};
47
48enum tps65090_cells {
49	PMIC = 0,
50	CHARGER = 1,
51};
52
53static struct mfd_cell tps65090s[] = {
54	[PMIC] = {
55		.name = "tps65090-pmic",
56	},
57	[CHARGER] = {
58		.name = "tps65090-charger",
59		.num_resources = ARRAY_SIZE(charger_resources),
60		.resources = &charger_resources[0],
61		.of_compatible = "ti,tps65090-charger",
62	},
63};
64
65static const struct regmap_irq tps65090_irqs[] = {
66	/* INT1 IRQs*/
67	[TPS65090_IRQ_VAC_STATUS_CHANGE] = {
68		.mask = TPS65090_INT1_MASK_VAC_STATUS_CHANGE,
69	},
70	[TPS65090_IRQ_VSYS_STATUS_CHANGE] = {
71		.mask = TPS65090_INT1_MASK_VSYS_STATUS_CHANGE,
72	},
73	[TPS65090_IRQ_BAT_STATUS_CHANGE] = {
74		.mask = TPS65090_INT1_MASK_BAT_STATUS_CHANGE,
75	},
76	[TPS65090_IRQ_CHARGING_STATUS_CHANGE] = {
77		.mask = TPS65090_INT1_MASK_CHARGING_STATUS_CHANGE,
78	},
79	[TPS65090_IRQ_CHARGING_COMPLETE] = {
80		.mask = TPS65090_INT1_MASK_CHARGING_COMPLETE,
81	},
82	[TPS65090_IRQ_OVERLOAD_DCDC1] = {
83		.mask = TPS65090_INT1_MASK_OVERLOAD_DCDC1,
84	},
85	[TPS65090_IRQ_OVERLOAD_DCDC2] = {
86		.mask = TPS65090_INT1_MASK_OVERLOAD_DCDC2,
87	},
88	/* INT2 IRQs*/
89	[TPS65090_IRQ_OVERLOAD_DCDC3] = {
90		.reg_offset = 1,
91		.mask = TPS65090_INT2_MASK_OVERLOAD_DCDC3,
92	},
93	[TPS65090_IRQ_OVERLOAD_FET1] = {
94		.reg_offset = 1,
95		.mask = TPS65090_INT2_MASK_OVERLOAD_FET1,
96	},
97	[TPS65090_IRQ_OVERLOAD_FET2] = {
98		.reg_offset = 1,
99		.mask = TPS65090_INT2_MASK_OVERLOAD_FET2,
100	},
101	[TPS65090_IRQ_OVERLOAD_FET3] = {
102		.reg_offset = 1,
103		.mask = TPS65090_INT2_MASK_OVERLOAD_FET3,
104	},
105	[TPS65090_IRQ_OVERLOAD_FET4] = {
106		.reg_offset = 1,
107		.mask = TPS65090_INT2_MASK_OVERLOAD_FET4,
108	},
109	[TPS65090_IRQ_OVERLOAD_FET5] = {
110		.reg_offset = 1,
111		.mask = TPS65090_INT2_MASK_OVERLOAD_FET5,
112	},
113	[TPS65090_IRQ_OVERLOAD_FET6] = {
114		.reg_offset = 1,
115		.mask = TPS65090_INT2_MASK_OVERLOAD_FET6,
116	},
117	[TPS65090_IRQ_OVERLOAD_FET7] = {
118		.reg_offset = 1,
119		.mask = TPS65090_INT2_MASK_OVERLOAD_FET7,
120	},
121};
122
123static struct regmap_irq_chip tps65090_irq_chip = {
124	.name = "tps65090",
125	.irqs = tps65090_irqs,
126	.num_irqs = ARRAY_SIZE(tps65090_irqs),
127	.num_regs = NUM_INT_REG,
128	.status_base = TPS65090_REG_INTR_STS,
129	.unmask_base = TPS65090_REG_INTR_MASK,
130};
131
132static bool is_volatile_reg(struct device *dev, unsigned int reg)
133{
134	/* Nearly all registers have status bits mixed in, except a few */
135	switch (reg) {
136	case TPS65090_REG_INTR_MASK:
137	case TPS65090_REG_INTR_MASK2:
138	case TPS65090_REG_CG_CTRL0:
139	case TPS65090_REG_CG_CTRL1:
140	case TPS65090_REG_CG_CTRL2:
141	case TPS65090_REG_CG_CTRL3:
142	case TPS65090_REG_CG_CTRL4:
143	case TPS65090_REG_CG_CTRL5:
144		return false;
145	}
146	return true;
147}
148
149static const struct regmap_config tps65090_regmap_config = {
150	.reg_bits = 8,
151	.val_bits = 8,
152	.max_register = TPS65090_MAX_REG,
153	.num_reg_defaults_raw = TPS65090_NUM_REGS,
154	.cache_type = REGCACHE_MAPLE,
155	.volatile_reg = is_volatile_reg,
156};
157
158#ifdef CONFIG_OF
159static const struct of_device_id tps65090_of_match[] = {
160	{ .compatible = "ti,tps65090",},
161	{},
162};
163#endif
164
165static int tps65090_i2c_probe(struct i2c_client *client)
166{
167	struct tps65090_platform_data *pdata = dev_get_platdata(&client->dev);
168	int irq_base = 0;
169	struct tps65090 *tps65090;
170	int ret;
171
172	if (!pdata && !client->dev.of_node) {
173		dev_err(&client->dev,
174			"tps65090 requires platform data or of_node\n");
175		return -EINVAL;
176	}
177
178	if (pdata)
179		irq_base = pdata->irq_base;
180
181	tps65090 = devm_kzalloc(&client->dev, sizeof(*tps65090), GFP_KERNEL);
182	if (!tps65090)
183		return -ENOMEM;
184
185	tps65090->dev = &client->dev;
186	i2c_set_clientdata(client, tps65090);
187
188	tps65090->rmap = devm_regmap_init_i2c(client, &tps65090_regmap_config);
189	if (IS_ERR(tps65090->rmap)) {
190		ret = PTR_ERR(tps65090->rmap);
191		dev_err(&client->dev, "regmap_init failed with err: %d\n", ret);
192		return ret;
193	}
194
195	if (client->irq) {
196		ret = regmap_add_irq_chip(tps65090->rmap, client->irq,
197					  IRQF_ONESHOT | IRQF_TRIGGER_LOW, irq_base,
198					  &tps65090_irq_chip, &tps65090->irq_data);
199		if (ret) {
200			dev_err(&client->dev,
201				"IRQ init failed with err: %d\n", ret);
202			return ret;
203		}
204	} else {
205		/* Don't tell children they have an IRQ that'll never fire */
206		tps65090s[CHARGER].num_resources = 0;
207	}
208
209	ret = mfd_add_devices(tps65090->dev, -1, tps65090s,
210			      ARRAY_SIZE(tps65090s), NULL,
211			      0, regmap_irq_get_domain(tps65090->irq_data));
212	if (ret) {
213		dev_err(&client->dev, "add mfd devices failed with err: %d\n",
214			ret);
215		goto err_irq_exit;
216	}
217
218	return 0;
219
220err_irq_exit:
221	if (client->irq)
222		regmap_del_irq_chip(client->irq, tps65090->irq_data);
223	return ret;
224}
225
226
227static const struct i2c_device_id tps65090_id_table[] = {
228	{ "tps65090", 0 },
229	{ },
230};
231
232static struct i2c_driver tps65090_driver = {
233	.driver	= {
234		.name	= "tps65090",
235		.suppress_bind_attrs = true,
236		.of_match_table = of_match_ptr(tps65090_of_match),
237	},
238	.probe		= tps65090_i2c_probe,
239	.id_table	= tps65090_id_table,
240};
241
242static int __init tps65090_init(void)
243{
244	return i2c_add_driver(&tps65090_driver);
245}
246subsys_initcall(tps65090_init);
247