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