xref: /openbmc/linux/drivers/mfd/axp20x.c (revision d7a3d85e)
1 /*
2  * axp20x.c - MFD core driver for the X-Powers' Power Management ICs
3  *
4  * AXP20x typically comprises an adaptive USB-Compatible PWM charger, BUCK DC-DC
5  * converters, LDOs, multiple 12-bit ADCs of voltage, current and temperature
6  * as well as configurable GPIOs.
7  *
8  * Author: Carlo Caione <carlo@caione.org>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License version 2 as
12  * published by the Free Software Foundation.
13  */
14 
15 #include <linux/err.h>
16 #include <linux/i2c.h>
17 #include <linux/interrupt.h>
18 #include <linux/kernel.h>
19 #include <linux/module.h>
20 #include <linux/pm_runtime.h>
21 #include <linux/regmap.h>
22 #include <linux/slab.h>
23 #include <linux/regulator/consumer.h>
24 #include <linux/mfd/axp20x.h>
25 #include <linux/mfd/core.h>
26 #include <linux/of_device.h>
27 #include <linux/of_irq.h>
28 #include <linux/acpi.h>
29 
30 #define AXP20X_OFF	0x80
31 
32 static const char * const axp20x_model_names[] = {
33 	"AXP202",
34 	"AXP209",
35 	"AXP288",
36 };
37 
38 static const struct regmap_range axp20x_writeable_ranges[] = {
39 	regmap_reg_range(AXP20X_DATACACHE(0), AXP20X_IRQ5_STATE),
40 	regmap_reg_range(AXP20X_DCDC_MODE, AXP20X_FG_RES),
41 };
42 
43 static const struct regmap_range axp20x_volatile_ranges[] = {
44 	regmap_reg_range(AXP20X_IRQ1_EN, AXP20X_IRQ5_STATE),
45 };
46 
47 static const struct regmap_access_table axp20x_writeable_table = {
48 	.yes_ranges	= axp20x_writeable_ranges,
49 	.n_yes_ranges	= ARRAY_SIZE(axp20x_writeable_ranges),
50 };
51 
52 static const struct regmap_access_table axp20x_volatile_table = {
53 	.yes_ranges	= axp20x_volatile_ranges,
54 	.n_yes_ranges	= ARRAY_SIZE(axp20x_volatile_ranges),
55 };
56 
57 static const struct regmap_range axp288_writeable_ranges[] = {
58 	regmap_reg_range(AXP20X_DATACACHE(0), AXP20X_IRQ6_STATE),
59 	regmap_reg_range(AXP20X_DCDC_MODE, AXP288_FG_TUNE5),
60 };
61 
62 static const struct regmap_range axp288_volatile_ranges[] = {
63 	regmap_reg_range(AXP20X_IRQ1_EN, AXP20X_IPSOUT_V_HIGH_L),
64 };
65 
66 static const struct regmap_access_table axp288_writeable_table = {
67 	.yes_ranges	= axp288_writeable_ranges,
68 	.n_yes_ranges	= ARRAY_SIZE(axp288_writeable_ranges),
69 };
70 
71 static const struct regmap_access_table axp288_volatile_table = {
72 	.yes_ranges	= axp288_volatile_ranges,
73 	.n_yes_ranges	= ARRAY_SIZE(axp288_volatile_ranges),
74 };
75 
76 static struct resource axp20x_pek_resources[] = {
77 	{
78 		.name	= "PEK_DBR",
79 		.start	= AXP20X_IRQ_PEK_RIS_EDGE,
80 		.end	= AXP20X_IRQ_PEK_RIS_EDGE,
81 		.flags	= IORESOURCE_IRQ,
82 	}, {
83 		.name	= "PEK_DBF",
84 		.start	= AXP20X_IRQ_PEK_FAL_EDGE,
85 		.end	= AXP20X_IRQ_PEK_FAL_EDGE,
86 		.flags	= IORESOURCE_IRQ,
87 	},
88 };
89 
90 static struct resource axp288_fuel_gauge_resources[] = {
91 	{
92 		.start = AXP288_IRQ_QWBTU,
93 		.end   = AXP288_IRQ_QWBTU,
94 		.flags = IORESOURCE_IRQ,
95 	},
96 	{
97 		.start = AXP288_IRQ_WBTU,
98 		.end   = AXP288_IRQ_WBTU,
99 		.flags = IORESOURCE_IRQ,
100 	},
101 	{
102 		.start = AXP288_IRQ_QWBTO,
103 		.end   = AXP288_IRQ_QWBTO,
104 		.flags = IORESOURCE_IRQ,
105 	},
106 	{
107 		.start = AXP288_IRQ_WBTO,
108 		.end   = AXP288_IRQ_WBTO,
109 		.flags = IORESOURCE_IRQ,
110 	},
111 	{
112 		.start = AXP288_IRQ_WL2,
113 		.end   = AXP288_IRQ_WL2,
114 		.flags = IORESOURCE_IRQ,
115 	},
116 	{
117 		.start = AXP288_IRQ_WL1,
118 		.end   = AXP288_IRQ_WL1,
119 		.flags = IORESOURCE_IRQ,
120 	},
121 };
122 
123 static const struct regmap_config axp20x_regmap_config = {
124 	.reg_bits	= 8,
125 	.val_bits	= 8,
126 	.wr_table	= &axp20x_writeable_table,
127 	.volatile_table	= &axp20x_volatile_table,
128 	.max_register	= AXP20X_FG_RES,
129 	.cache_type	= REGCACHE_RBTREE,
130 };
131 
132 static const struct regmap_config axp288_regmap_config = {
133 	.reg_bits	= 8,
134 	.val_bits	= 8,
135 	.wr_table	= &axp288_writeable_table,
136 	.volatile_table	= &axp288_volatile_table,
137 	.max_register	= AXP288_FG_TUNE5,
138 	.cache_type	= REGCACHE_RBTREE,
139 };
140 
141 #define INIT_REGMAP_IRQ(_variant, _irq, _off, _mask)			\
142 	[_variant##_IRQ_##_irq] = { .reg_offset = (_off), .mask = BIT(_mask) }
143 
144 static const struct regmap_irq axp20x_regmap_irqs[] = {
145 	INIT_REGMAP_IRQ(AXP20X, ACIN_OVER_V,		0, 7),
146 	INIT_REGMAP_IRQ(AXP20X, ACIN_PLUGIN,		0, 6),
147 	INIT_REGMAP_IRQ(AXP20X, ACIN_REMOVAL,	        0, 5),
148 	INIT_REGMAP_IRQ(AXP20X, VBUS_OVER_V,		0, 4),
149 	INIT_REGMAP_IRQ(AXP20X, VBUS_PLUGIN,		0, 3),
150 	INIT_REGMAP_IRQ(AXP20X, VBUS_REMOVAL,	        0, 2),
151 	INIT_REGMAP_IRQ(AXP20X, VBUS_V_LOW,		0, 1),
152 	INIT_REGMAP_IRQ(AXP20X, BATT_PLUGIN,		1, 7),
153 	INIT_REGMAP_IRQ(AXP20X, BATT_REMOVAL,	        1, 6),
154 	INIT_REGMAP_IRQ(AXP20X, BATT_ENT_ACT_MODE,	1, 5),
155 	INIT_REGMAP_IRQ(AXP20X, BATT_EXIT_ACT_MODE,	1, 4),
156 	INIT_REGMAP_IRQ(AXP20X, CHARG,		        1, 3),
157 	INIT_REGMAP_IRQ(AXP20X, CHARG_DONE,		1, 2),
158 	INIT_REGMAP_IRQ(AXP20X, BATT_TEMP_HIGH,	        1, 1),
159 	INIT_REGMAP_IRQ(AXP20X, BATT_TEMP_LOW,	        1, 0),
160 	INIT_REGMAP_IRQ(AXP20X, DIE_TEMP_HIGH,	        2, 7),
161 	INIT_REGMAP_IRQ(AXP20X, CHARG_I_LOW,		2, 6),
162 	INIT_REGMAP_IRQ(AXP20X, DCDC1_V_LONG,	        2, 5),
163 	INIT_REGMAP_IRQ(AXP20X, DCDC2_V_LONG,	        2, 4),
164 	INIT_REGMAP_IRQ(AXP20X, DCDC3_V_LONG,	        2, 3),
165 	INIT_REGMAP_IRQ(AXP20X, PEK_SHORT,		2, 1),
166 	INIT_REGMAP_IRQ(AXP20X, PEK_LONG,		2, 0),
167 	INIT_REGMAP_IRQ(AXP20X, N_OE_PWR_ON,		3, 7),
168 	INIT_REGMAP_IRQ(AXP20X, N_OE_PWR_OFF,	        3, 6),
169 	INIT_REGMAP_IRQ(AXP20X, VBUS_VALID,		3, 5),
170 	INIT_REGMAP_IRQ(AXP20X, VBUS_NOT_VALID,	        3, 4),
171 	INIT_REGMAP_IRQ(AXP20X, VBUS_SESS_VALID,	3, 3),
172 	INIT_REGMAP_IRQ(AXP20X, VBUS_SESS_END,	        3, 2),
173 	INIT_REGMAP_IRQ(AXP20X, LOW_PWR_LVL1,	        3, 1),
174 	INIT_REGMAP_IRQ(AXP20X, LOW_PWR_LVL2,	        3, 0),
175 	INIT_REGMAP_IRQ(AXP20X, TIMER,		        4, 7),
176 	INIT_REGMAP_IRQ(AXP20X, PEK_RIS_EDGE,	        4, 6),
177 	INIT_REGMAP_IRQ(AXP20X, PEK_FAL_EDGE,	        4, 5),
178 	INIT_REGMAP_IRQ(AXP20X, GPIO3_INPUT,		4, 3),
179 	INIT_REGMAP_IRQ(AXP20X, GPIO2_INPUT,		4, 2),
180 	INIT_REGMAP_IRQ(AXP20X, GPIO1_INPUT,		4, 1),
181 	INIT_REGMAP_IRQ(AXP20X, GPIO0_INPUT,		4, 0),
182 };
183 
184 /* some IRQs are compatible with axp20x models */
185 static const struct regmap_irq axp288_regmap_irqs[] = {
186 	INIT_REGMAP_IRQ(AXP288, VBUS_FALL,              0, 2),
187 	INIT_REGMAP_IRQ(AXP288, VBUS_RISE,              0, 3),
188 	INIT_REGMAP_IRQ(AXP288, OV,                     0, 4),
189 
190 	INIT_REGMAP_IRQ(AXP288, DONE,                   1, 2),
191 	INIT_REGMAP_IRQ(AXP288, CHARGING,               1, 3),
192 	INIT_REGMAP_IRQ(AXP288, SAFE_QUIT,              1, 4),
193 	INIT_REGMAP_IRQ(AXP288, SAFE_ENTER,             1, 5),
194 	INIT_REGMAP_IRQ(AXP288, ABSENT,                 1, 6),
195 	INIT_REGMAP_IRQ(AXP288, APPEND,                 1, 7),
196 
197 	INIT_REGMAP_IRQ(AXP288, QWBTU,                  2, 0),
198 	INIT_REGMAP_IRQ(AXP288, WBTU,                   2, 1),
199 	INIT_REGMAP_IRQ(AXP288, QWBTO,                  2, 2),
200 	INIT_REGMAP_IRQ(AXP288, WBTO,                   2, 3),
201 	INIT_REGMAP_IRQ(AXP288, QCBTU,                  2, 4),
202 	INIT_REGMAP_IRQ(AXP288, CBTU,                   2, 5),
203 	INIT_REGMAP_IRQ(AXP288, QCBTO,                  2, 6),
204 	INIT_REGMAP_IRQ(AXP288, CBTO,                   2, 7),
205 
206 	INIT_REGMAP_IRQ(AXP288, WL2,                    3, 0),
207 	INIT_REGMAP_IRQ(AXP288, WL1,                    3, 1),
208 	INIT_REGMAP_IRQ(AXP288, GPADC,                  3, 2),
209 	INIT_REGMAP_IRQ(AXP288, OT,                     3, 7),
210 
211 	INIT_REGMAP_IRQ(AXP288, GPIO0,                  4, 0),
212 	INIT_REGMAP_IRQ(AXP288, GPIO1,                  4, 1),
213 	INIT_REGMAP_IRQ(AXP288, POKO,                   4, 2),
214 	INIT_REGMAP_IRQ(AXP288, POKL,                   4, 3),
215 	INIT_REGMAP_IRQ(AXP288, POKS,                   4, 4),
216 	INIT_REGMAP_IRQ(AXP288, POKN,                   4, 5),
217 	INIT_REGMAP_IRQ(AXP288, POKP,                   4, 6),
218 	INIT_REGMAP_IRQ(AXP288, TIMER,                  4, 7),
219 
220 	INIT_REGMAP_IRQ(AXP288, MV_CHNG,                5, 0),
221 	INIT_REGMAP_IRQ(AXP288, BC_USB_CHNG,            5, 1),
222 };
223 
224 static const struct of_device_id axp20x_of_match[] = {
225 	{ .compatible = "x-powers,axp202", .data = (void *) AXP202_ID },
226 	{ .compatible = "x-powers,axp209", .data = (void *) AXP209_ID },
227 	{ },
228 };
229 MODULE_DEVICE_TABLE(of, axp20x_of_match);
230 
231 /*
232  * This is useless for OF-enabled devices, but it is needed by I2C subsystem
233  */
234 static const struct i2c_device_id axp20x_i2c_id[] = {
235 	{ },
236 };
237 MODULE_DEVICE_TABLE(i2c, axp20x_i2c_id);
238 
239 static const struct acpi_device_id axp20x_acpi_match[] = {
240 	{
241 		.id = "INT33F4",
242 		.driver_data = AXP288_ID,
243 	},
244 	{ },
245 };
246 MODULE_DEVICE_TABLE(acpi, axp20x_acpi_match);
247 
248 static const struct regmap_irq_chip axp20x_regmap_irq_chip = {
249 	.name			= "axp20x_irq_chip",
250 	.status_base		= AXP20X_IRQ1_STATE,
251 	.ack_base		= AXP20X_IRQ1_STATE,
252 	.mask_base		= AXP20X_IRQ1_EN,
253 	.mask_invert		= true,
254 	.init_ack_masked	= true,
255 	.irqs			= axp20x_regmap_irqs,
256 	.num_irqs		= ARRAY_SIZE(axp20x_regmap_irqs),
257 	.num_regs		= 5,
258 
259 };
260 
261 static const struct regmap_irq_chip axp288_regmap_irq_chip = {
262 	.name			= "axp288_irq_chip",
263 	.status_base		= AXP20X_IRQ1_STATE,
264 	.ack_base		= AXP20X_IRQ1_STATE,
265 	.mask_base		= AXP20X_IRQ1_EN,
266 	.mask_invert		= true,
267 	.init_ack_masked	= true,
268 	.irqs			= axp288_regmap_irqs,
269 	.num_irqs		= ARRAY_SIZE(axp288_regmap_irqs),
270 	.num_regs		= 6,
271 
272 };
273 
274 static struct mfd_cell axp20x_cells[] = {
275 	{
276 		.name			= "axp20x-pek",
277 		.num_resources		= ARRAY_SIZE(axp20x_pek_resources),
278 		.resources		= axp20x_pek_resources,
279 	}, {
280 		.name			= "axp20x-regulator",
281 	},
282 };
283 
284 static struct resource axp288_adc_resources[] = {
285 	{
286 		.name  = "GPADC",
287 		.start = AXP288_IRQ_GPADC,
288 		.end   = AXP288_IRQ_GPADC,
289 		.flags = IORESOURCE_IRQ,
290 	},
291 };
292 
293 static struct resource axp288_extcon_resources[] = {
294 	{
295 		.start = AXP288_IRQ_VBUS_FALL,
296 		.end   = AXP288_IRQ_VBUS_FALL,
297 		.flags = IORESOURCE_IRQ,
298 	},
299 	{
300 		.start = AXP288_IRQ_VBUS_RISE,
301 		.end   = AXP288_IRQ_VBUS_RISE,
302 		.flags = IORESOURCE_IRQ,
303 	},
304 	{
305 		.start = AXP288_IRQ_MV_CHNG,
306 		.end   = AXP288_IRQ_MV_CHNG,
307 		.flags = IORESOURCE_IRQ,
308 	},
309 	{
310 		.start = AXP288_IRQ_BC_USB_CHNG,
311 		.end   = AXP288_IRQ_BC_USB_CHNG,
312 		.flags = IORESOURCE_IRQ,
313 	},
314 };
315 
316 static struct resource axp288_charger_resources[] = {
317 	{
318 		.start = AXP288_IRQ_OV,
319 		.end   = AXP288_IRQ_OV,
320 		.flags = IORESOURCE_IRQ,
321 	},
322 	{
323 		.start = AXP288_IRQ_DONE,
324 		.end   = AXP288_IRQ_DONE,
325 		.flags = IORESOURCE_IRQ,
326 	},
327 	{
328 		.start = AXP288_IRQ_CHARGING,
329 		.end   = AXP288_IRQ_CHARGING,
330 		.flags = IORESOURCE_IRQ,
331 	},
332 	{
333 		.start = AXP288_IRQ_SAFE_QUIT,
334 		.end   = AXP288_IRQ_SAFE_QUIT,
335 		.flags = IORESOURCE_IRQ,
336 	},
337 	{
338 		.start = AXP288_IRQ_SAFE_ENTER,
339 		.end   = AXP288_IRQ_SAFE_ENTER,
340 		.flags = IORESOURCE_IRQ,
341 	},
342 	{
343 		.start = AXP288_IRQ_QCBTU,
344 		.end   = AXP288_IRQ_QCBTU,
345 		.flags = IORESOURCE_IRQ,
346 	},
347 	{
348 		.start = AXP288_IRQ_CBTU,
349 		.end   = AXP288_IRQ_CBTU,
350 		.flags = IORESOURCE_IRQ,
351 	},
352 	{
353 		.start = AXP288_IRQ_QCBTO,
354 		.end   = AXP288_IRQ_QCBTO,
355 		.flags = IORESOURCE_IRQ,
356 	},
357 	{
358 		.start = AXP288_IRQ_CBTO,
359 		.end   = AXP288_IRQ_CBTO,
360 		.flags = IORESOURCE_IRQ,
361 	},
362 };
363 
364 static struct mfd_cell axp288_cells[] = {
365 	{
366 		.name = "axp288_adc",
367 		.num_resources = ARRAY_SIZE(axp288_adc_resources),
368 		.resources = axp288_adc_resources,
369 	},
370 	{
371 		.name = "axp288_extcon",
372 		.num_resources = ARRAY_SIZE(axp288_extcon_resources),
373 		.resources = axp288_extcon_resources,
374 	},
375 	{
376 		.name = "axp288_charger",
377 		.num_resources = ARRAY_SIZE(axp288_charger_resources),
378 		.resources = axp288_charger_resources,
379 	},
380 	{
381 		.name = "axp288_fuel_gauge",
382 		.num_resources = ARRAY_SIZE(axp288_fuel_gauge_resources),
383 		.resources = axp288_fuel_gauge_resources,
384 	},
385 	{
386 		.name = "axp288_pmic_acpi",
387 	},
388 };
389 
390 static struct axp20x_dev *axp20x_pm_power_off;
391 static void axp20x_power_off(void)
392 {
393 	if (axp20x_pm_power_off->variant == AXP288_ID)
394 		return;
395 
396 	regmap_write(axp20x_pm_power_off->regmap, AXP20X_OFF_CTRL,
397 		     AXP20X_OFF);
398 }
399 
400 static int axp20x_match_device(struct axp20x_dev *axp20x, struct device *dev)
401 {
402 	const struct acpi_device_id *acpi_id;
403 	const struct of_device_id *of_id;
404 
405 	if (dev->of_node) {
406 		of_id = of_match_device(axp20x_of_match, dev);
407 		if (!of_id) {
408 			dev_err(dev, "Unable to match OF ID\n");
409 			return -ENODEV;
410 		}
411 		axp20x->variant = (long) of_id->data;
412 	} else {
413 		acpi_id = acpi_match_device(dev->driver->acpi_match_table, dev);
414 		if (!acpi_id || !acpi_id->driver_data) {
415 			dev_err(dev, "Unable to match ACPI ID and data\n");
416 			return -ENODEV;
417 		}
418 		axp20x->variant = (long) acpi_id->driver_data;
419 	}
420 
421 	switch (axp20x->variant) {
422 	case AXP202_ID:
423 	case AXP209_ID:
424 		axp20x->nr_cells = ARRAY_SIZE(axp20x_cells);
425 		axp20x->cells = axp20x_cells;
426 		axp20x->regmap_cfg = &axp20x_regmap_config;
427 		axp20x->regmap_irq_chip = &axp20x_regmap_irq_chip;
428 		break;
429 	case AXP288_ID:
430 		axp20x->cells = axp288_cells;
431 		axp20x->nr_cells = ARRAY_SIZE(axp288_cells);
432 		axp20x->regmap_cfg = &axp288_regmap_config;
433 		axp20x->regmap_irq_chip = &axp288_regmap_irq_chip;
434 		break;
435 	default:
436 		dev_err(dev, "unsupported AXP20X ID %lu\n", axp20x->variant);
437 		return -EINVAL;
438 	}
439 	dev_info(dev, "AXP20x variant %s found\n",
440 		axp20x_model_names[axp20x->variant]);
441 
442 	return 0;
443 }
444 
445 static int axp20x_i2c_probe(struct i2c_client *i2c,
446 			 const struct i2c_device_id *id)
447 {
448 	struct axp20x_dev *axp20x;
449 	int ret;
450 
451 	axp20x = devm_kzalloc(&i2c->dev, sizeof(*axp20x), GFP_KERNEL);
452 	if (!axp20x)
453 		return -ENOMEM;
454 
455 	ret = axp20x_match_device(axp20x, &i2c->dev);
456 	if (ret)
457 		return ret;
458 
459 	axp20x->i2c_client = i2c;
460 	axp20x->dev = &i2c->dev;
461 	dev_set_drvdata(axp20x->dev, axp20x);
462 
463 	axp20x->regmap = devm_regmap_init_i2c(i2c, axp20x->regmap_cfg);
464 	if (IS_ERR(axp20x->regmap)) {
465 		ret = PTR_ERR(axp20x->regmap);
466 		dev_err(&i2c->dev, "regmap init failed: %d\n", ret);
467 		return ret;
468 	}
469 
470 	ret = regmap_add_irq_chip(axp20x->regmap, i2c->irq,
471 				  IRQF_ONESHOT | IRQF_SHARED, -1,
472 				  axp20x->regmap_irq_chip,
473 				  &axp20x->regmap_irqc);
474 	if (ret) {
475 		dev_err(&i2c->dev, "failed to add irq chip: %d\n", ret);
476 		return ret;
477 	}
478 
479 	ret = mfd_add_devices(axp20x->dev, -1, axp20x->cells,
480 			axp20x->nr_cells, NULL, 0, NULL);
481 
482 	if (ret) {
483 		dev_err(&i2c->dev, "failed to add MFD devices: %d\n", ret);
484 		regmap_del_irq_chip(i2c->irq, axp20x->regmap_irqc);
485 		return ret;
486 	}
487 
488 	if (!pm_power_off) {
489 		axp20x_pm_power_off = axp20x;
490 		pm_power_off = axp20x_power_off;
491 	}
492 
493 	dev_info(&i2c->dev, "AXP20X driver loaded\n");
494 
495 	return 0;
496 }
497 
498 static int axp20x_i2c_remove(struct i2c_client *i2c)
499 {
500 	struct axp20x_dev *axp20x = i2c_get_clientdata(i2c);
501 
502 	if (axp20x == axp20x_pm_power_off) {
503 		axp20x_pm_power_off = NULL;
504 		pm_power_off = NULL;
505 	}
506 
507 	mfd_remove_devices(axp20x->dev);
508 	regmap_del_irq_chip(axp20x->i2c_client->irq, axp20x->regmap_irqc);
509 
510 	return 0;
511 }
512 
513 static struct i2c_driver axp20x_i2c_driver = {
514 	.driver = {
515 		.name	= "axp20x",
516 		.owner	= THIS_MODULE,
517 		.of_match_table	= of_match_ptr(axp20x_of_match),
518 		.acpi_match_table = ACPI_PTR(axp20x_acpi_match),
519 	},
520 	.probe		= axp20x_i2c_probe,
521 	.remove		= axp20x_i2c_remove,
522 	.id_table	= axp20x_i2c_id,
523 };
524 
525 module_i2c_driver(axp20x_i2c_driver);
526 
527 MODULE_DESCRIPTION("PMIC MFD core driver for AXP20X");
528 MODULE_AUTHOR("Carlo Caione <carlo@caione.org>");
529 MODULE_LICENSE("GPL");
530