blob: b1b580a88654f9fd1c70c1e89a85b3ba2d5b6786 [file] [log] [blame]
Carlo Caionecfb61a42014-05-01 14:29:27 +02001/*
Jacob Panaf7e9062014-10-06 21:17:14 -07002 * axp20x.c - MFD core driver for the X-Powers' Power Management ICs
Carlo Caionecfb61a42014-05-01 14:29:27 +02003 *
Jacob Panaf7e9062014-10-06 21:17:14 -07004 * 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.
Carlo Caionecfb61a42014-05-01 14:29:27 +02007 *
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>
Jacob Panaf7e9062014-10-06 21:17:14 -070028#include <linux/acpi.h>
Carlo Caionecfb61a42014-05-01 14:29:27 +020029
30#define AXP20X_OFF 0x80
31
Jacob Panaf7e9062014-10-06 21:17:14 -070032static const char const *axp20x_model_names[] = {
33 "AXP202",
34 "AXP209",
35 "AXP288",
36};
37
Carlo Caionecfb61a42014-05-01 14:29:27 +020038static 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
43static const struct regmap_range axp20x_volatile_ranges[] = {
44 regmap_reg_range(AXP20X_IRQ1_EN, AXP20X_IRQ5_STATE),
45};
46
47static 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
52static 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
Jacob Panaf7e9062014-10-06 21:17:14 -070057static 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
62static const struct regmap_range axp288_volatile_ranges[] = {
63 regmap_reg_range(AXP20X_IRQ1_EN, AXP20X_IPSOUT_V_HIGH_L),
64};
65
66static 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
71static 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
Carlo Caionecfb61a42014-05-01 14:29:27 +020076static 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
Jacob Panaf7e9062014-10-06 21:17:14 -070090static struct resource axp288_battery_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
Carlo Caionecfb61a42014-05-01 14:29:27 +0200123static 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
Jacob Panaf7e9062014-10-06 21:17:14 -0700132static 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) }
Carlo Caionecfb61a42014-05-01 14:29:27 +0200143
144static const struct regmap_irq axp20x_regmap_irqs[] = {
Jacob Panaf7e9062014-10-06 21:17:14 -0700145 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 */
185static const struct regmap_irq axp288_regmap_irqs[] = {
Jacob Panff3bbc52014-11-11 11:30:09 -0800186 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),
Jacob Panaf7e9062014-10-06 21:17:14 -0700189
Jacob Panff3bbc52014-11-11 11:30:09 -0800190 INIT_REGMAP_IRQ(AXP288, DONE, 1, 2),
191 INIT_REGMAP_IRQ(AXP288, CHARGING, 1, 3),
Jacob Panaf7e9062014-10-06 21:17:14 -0700192 INIT_REGMAP_IRQ(AXP288, SAFE_QUIT, 1, 4),
193 INIT_REGMAP_IRQ(AXP288, SAFE_ENTER, 1, 5),
Jacob Panff3bbc52014-11-11 11:30:09 -0800194 INIT_REGMAP_IRQ(AXP288, ABSENT, 1, 6),
195 INIT_REGMAP_IRQ(AXP288, APPEND, 1, 7),
Jacob Panaf7e9062014-10-06 21:17:14 -0700196
197 INIT_REGMAP_IRQ(AXP288, QWBTU, 2, 0),
198 INIT_REGMAP_IRQ(AXP288, WBTU, 2, 1),
199 INIT_REGMAP_IRQ(AXP288, QWBTO, 2, 2),
Jacob Panff3bbc52014-11-11 11:30:09 -0800200 INIT_REGMAP_IRQ(AXP288, WBTO, 2, 3),
Jacob Panaf7e9062014-10-06 21:17:14 -0700201 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),
Jacob Panff3bbc52014-11-11 11:30:09 -0800218 INIT_REGMAP_IRQ(AXP288, TIMER, 4, 7),
Jacob Panaf7e9062014-10-06 21:17:14 -0700219
220 INIT_REGMAP_IRQ(AXP288, MV_CHNG, 5, 0),
221 INIT_REGMAP_IRQ(AXP288, BC_USB_CHNG, 5, 1),
Carlo Caionecfb61a42014-05-01 14:29:27 +0200222};
223
224static 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};
229MODULE_DEVICE_TABLE(of, axp20x_of_match);
230
231/*
232 * This is useless for OF-enabled devices, but it is needed by I2C subsystem
233 */
234static const struct i2c_device_id axp20x_i2c_id[] = {
235 { },
236};
237MODULE_DEVICE_TABLE(i2c, axp20x_i2c_id);
238
Lee Jones0e50e922014-11-11 12:36:46 +0000239static const struct acpi_device_id axp20x_acpi_match[] = {
Jacob Panaf7e9062014-10-06 21:17:14 -0700240 {
241 .id = "INT33F4",
242 .driver_data = AXP288_ID,
243 },
244 { },
245};
246MODULE_DEVICE_TABLE(acpi, axp20x_acpi_match);
247
Carlo Caionecfb61a42014-05-01 14:29:27 +0200248static 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,
Carlo Caionecfb61a42014-05-01 14:29:27 +0200253 .mask_invert = true,
254 .init_ack_masked = true,
Jacob Panaf7e9062014-10-06 21:17:14 -0700255 .irqs = axp20x_regmap_irqs,
256 .num_irqs = ARRAY_SIZE(axp20x_regmap_irqs),
257 .num_regs = 5,
258
259};
260
261static 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
Carlo Caionecfb61a42014-05-01 14:29:27 +0200272};
273
Carlo Caionecfb61a42014-05-01 14:29:27 +0200274static 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",
Carlo Caionecfb61a42014-05-01 14:29:27 +0200281 },
282};
283
Jacob Panaf7e9062014-10-06 21:17:14 -0700284static 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
293static struct resource axp288_charger_resources[] = {
294 {
295 .start = AXP288_IRQ_OV,
296 .end = AXP288_IRQ_OV,
297 .flags = IORESOURCE_IRQ,
298 },
299 {
300 .start = AXP288_IRQ_DONE,
301 .end = AXP288_IRQ_DONE,
302 .flags = IORESOURCE_IRQ,
303 },
304 {
305 .start = AXP288_IRQ_CHARGING,
306 .end = AXP288_IRQ_CHARGING,
307 .flags = IORESOURCE_IRQ,
308 },
309 {
310 .start = AXP288_IRQ_SAFE_QUIT,
311 .end = AXP288_IRQ_SAFE_QUIT,
312 .flags = IORESOURCE_IRQ,
313 },
314 {
315 .start = AXP288_IRQ_SAFE_ENTER,
316 .end = AXP288_IRQ_SAFE_ENTER,
317 .flags = IORESOURCE_IRQ,
318 },
319 {
320 .start = AXP288_IRQ_QCBTU,
321 .end = AXP288_IRQ_QCBTU,
322 .flags = IORESOURCE_IRQ,
323 },
324 {
325 .start = AXP288_IRQ_CBTU,
326 .end = AXP288_IRQ_CBTU,
327 .flags = IORESOURCE_IRQ,
328 },
329 {
330 .start = AXP288_IRQ_QCBTO,
331 .end = AXP288_IRQ_QCBTO,
332 .flags = IORESOURCE_IRQ,
333 },
334 {
335 .start = AXP288_IRQ_CBTO,
336 .end = AXP288_IRQ_CBTO,
337 .flags = IORESOURCE_IRQ,
338 },
339};
340
341static struct mfd_cell axp288_cells[] = {
342 {
343 .name = "axp288_adc",
344 .num_resources = ARRAY_SIZE(axp288_adc_resources),
345 .resources = axp288_adc_resources,
346 },
347 {
348 .name = "axp288_charger",
349 .num_resources = ARRAY_SIZE(axp288_charger_resources),
350 .resources = axp288_charger_resources,
351 },
352 {
353 .name = "axp288_battery",
354 .num_resources = ARRAY_SIZE(axp288_battery_resources),
355 .resources = axp288_battery_resources,
356 },
Aaron Lud8139f62014-11-24 17:24:47 +0800357 {
358 .name = "axp288_pmic_acpi",
359 },
Jacob Panaf7e9062014-10-06 21:17:14 -0700360};
361
Carlo Caionecfb61a42014-05-01 14:29:27 +0200362static struct axp20x_dev *axp20x_pm_power_off;
363static void axp20x_power_off(void)
364{
Jacob Panaf7e9062014-10-06 21:17:14 -0700365 if (axp20x_pm_power_off->variant == AXP288_ID)
366 return;
367
Carlo Caionecfb61a42014-05-01 14:29:27 +0200368 regmap_write(axp20x_pm_power_off->regmap, AXP20X_OFF_CTRL,
369 AXP20X_OFF);
370}
371
Jacob Panaf7e9062014-10-06 21:17:14 -0700372static int axp20x_match_device(struct axp20x_dev *axp20x, struct device *dev)
373{
374 const struct acpi_device_id *acpi_id;
375 const struct of_device_id *of_id;
376
377 if (dev->of_node) {
378 of_id = of_match_device(axp20x_of_match, dev);
379 if (!of_id) {
380 dev_err(dev, "Unable to match OF ID\n");
381 return -ENODEV;
382 }
383 axp20x->variant = (long) of_id->data;
384 } else {
385 acpi_id = acpi_match_device(dev->driver->acpi_match_table, dev);
386 if (!acpi_id || !acpi_id->driver_data) {
387 dev_err(dev, "Unable to match ACPI ID and data\n");
388 return -ENODEV;
389 }
390 axp20x->variant = (long) acpi_id->driver_data;
391 }
392
393 switch (axp20x->variant) {
394 case AXP202_ID:
395 case AXP209_ID:
396 axp20x->nr_cells = ARRAY_SIZE(axp20x_cells);
397 axp20x->cells = axp20x_cells;
398 axp20x->regmap_cfg = &axp20x_regmap_config;
399 axp20x->regmap_irq_chip = &axp20x_regmap_irq_chip;
400 break;
401 case AXP288_ID:
402 axp20x->cells = axp288_cells;
403 axp20x->nr_cells = ARRAY_SIZE(axp288_cells);
404 axp20x->regmap_cfg = &axp288_regmap_config;
405 axp20x->regmap_irq_chip = &axp288_regmap_irq_chip;
406 break;
407 default:
408 dev_err(dev, "unsupported AXP20X ID %lu\n", axp20x->variant);
409 return -EINVAL;
410 }
411 dev_info(dev, "AXP20x variant %s found\n",
412 axp20x_model_names[axp20x->variant]);
413
414 return 0;
415}
416
Carlo Caionecfb61a42014-05-01 14:29:27 +0200417static int axp20x_i2c_probe(struct i2c_client *i2c,
418 const struct i2c_device_id *id)
419{
420 struct axp20x_dev *axp20x;
Carlo Caionecfb61a42014-05-01 14:29:27 +0200421 int ret;
422
423 axp20x = devm_kzalloc(&i2c->dev, sizeof(*axp20x), GFP_KERNEL);
424 if (!axp20x)
425 return -ENOMEM;
426
Jacob Panaf7e9062014-10-06 21:17:14 -0700427 ret = axp20x_match_device(axp20x, &i2c->dev);
428 if (ret)
429 return ret;
Carlo Caionecfb61a42014-05-01 14:29:27 +0200430
431 axp20x->i2c_client = i2c;
432 axp20x->dev = &i2c->dev;
433 dev_set_drvdata(axp20x->dev, axp20x);
434
Jacob Panaf7e9062014-10-06 21:17:14 -0700435 axp20x->regmap = devm_regmap_init_i2c(i2c, axp20x->regmap_cfg);
Carlo Caionecfb61a42014-05-01 14:29:27 +0200436 if (IS_ERR(axp20x->regmap)) {
437 ret = PTR_ERR(axp20x->regmap);
438 dev_err(&i2c->dev, "regmap init failed: %d\n", ret);
439 return ret;
440 }
441
442 ret = regmap_add_irq_chip(axp20x->regmap, i2c->irq,
443 IRQF_ONESHOT | IRQF_SHARED, -1,
Jacob Panaf7e9062014-10-06 21:17:14 -0700444 axp20x->regmap_irq_chip,
Carlo Caionecfb61a42014-05-01 14:29:27 +0200445 &axp20x->regmap_irqc);
446 if (ret) {
447 dev_err(&i2c->dev, "failed to add irq chip: %d\n", ret);
448 return ret;
449 }
450
Jacob Panaf7e9062014-10-06 21:17:14 -0700451 ret = mfd_add_devices(axp20x->dev, -1, axp20x->cells,
452 axp20x->nr_cells, NULL, 0, NULL);
Carlo Caionecfb61a42014-05-01 14:29:27 +0200453
454 if (ret) {
455 dev_err(&i2c->dev, "failed to add MFD devices: %d\n", ret);
456 regmap_del_irq_chip(i2c->irq, axp20x->regmap_irqc);
457 return ret;
458 }
459
460 if (!pm_power_off) {
461 axp20x_pm_power_off = axp20x;
462 pm_power_off = axp20x_power_off;
463 }
464
465 dev_info(&i2c->dev, "AXP20X driver loaded\n");
466
467 return 0;
468}
469
470static int axp20x_i2c_remove(struct i2c_client *i2c)
471{
472 struct axp20x_dev *axp20x = i2c_get_clientdata(i2c);
473
474 if (axp20x == axp20x_pm_power_off) {
475 axp20x_pm_power_off = NULL;
476 pm_power_off = NULL;
477 }
478
479 mfd_remove_devices(axp20x->dev);
480 regmap_del_irq_chip(axp20x->i2c_client->irq, axp20x->regmap_irqc);
481
482 return 0;
483}
484
485static struct i2c_driver axp20x_i2c_driver = {
486 .driver = {
487 .name = "axp20x",
488 .owner = THIS_MODULE,
489 .of_match_table = of_match_ptr(axp20x_of_match),
Jacob Panaf7e9062014-10-06 21:17:14 -0700490 .acpi_match_table = ACPI_PTR(axp20x_acpi_match),
Carlo Caionecfb61a42014-05-01 14:29:27 +0200491 },
492 .probe = axp20x_i2c_probe,
493 .remove = axp20x_i2c_remove,
494 .id_table = axp20x_i2c_id,
495};
496
497module_i2c_driver(axp20x_i2c_driver);
498
499MODULE_DESCRIPTION("PMIC MFD core driver for AXP20X");
500MODULE_AUTHOR("Carlo Caione <carlo@caione.org>");
501MODULE_LICENSE("GPL");