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_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 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_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 341 static 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 }, 357 { 358 .name = "axp288_pmic_acpi", 359 }, 360 }; 361 362 static struct axp20x_dev *axp20x_pm_power_off; 363 static void axp20x_power_off(void) 364 { 365 if (axp20x_pm_power_off->variant == AXP288_ID) 366 return; 367 368 regmap_write(axp20x_pm_power_off->regmap, AXP20X_OFF_CTRL, 369 AXP20X_OFF); 370 } 371 372 static 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 417 static int axp20x_i2c_probe(struct i2c_client *i2c, 418 const struct i2c_device_id *id) 419 { 420 struct axp20x_dev *axp20x; 421 int ret; 422 423 axp20x = devm_kzalloc(&i2c->dev, sizeof(*axp20x), GFP_KERNEL); 424 if (!axp20x) 425 return -ENOMEM; 426 427 ret = axp20x_match_device(axp20x, &i2c->dev); 428 if (ret) 429 return ret; 430 431 axp20x->i2c_client = i2c; 432 axp20x->dev = &i2c->dev; 433 dev_set_drvdata(axp20x->dev, axp20x); 434 435 axp20x->regmap = devm_regmap_init_i2c(i2c, axp20x->regmap_cfg); 436 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, 444 axp20x->regmap_irq_chip, 445 &axp20x->regmap_irqc); 446 if (ret) { 447 dev_err(&i2c->dev, "failed to add irq chip: %d\n", ret); 448 return ret; 449 } 450 451 ret = mfd_add_devices(axp20x->dev, -1, axp20x->cells, 452 axp20x->nr_cells, NULL, 0, NULL); 453 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 470 static 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 485 static 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), 490 .acpi_match_table = ACPI_PTR(axp20x_acpi_match), 491 }, 492 .probe = axp20x_i2c_probe, 493 .remove = axp20x_i2c_remove, 494 .id_table = axp20x_i2c_id, 495 }; 496 497 module_i2c_driver(axp20x_i2c_driver); 498 499 MODULE_DESCRIPTION("PMIC MFD core driver for AXP20X"); 500 MODULE_AUTHOR("Carlo Caione <carlo@caione.org>"); 501 MODULE_LICENSE("GPL"); 502