drivers/mfd/axp20x.c

   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 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 const char * const axp20x_supplies[] = {
 275         "acin",
 276         "vin2",
 277         "vin3",
 278         "ldo24in",
 279         "ldo3in",
 280         "ldo5in",
 281 };
 282
 283 static struct mfd_cell axp20x_cells[] = {
 284         {
 285                 .name                   = "axp20x-pek",
 286                 .num_resources          = ARRAY_SIZE(axp20x_pek_resources),
 287                 .resources              = axp20x_pek_resources,
 288         }, {
 289                 .name                   = "axp20x-regulator",
 290                 .parent_supplies        = axp20x_supplies,
 291                 .num_parent_supplies    = ARRAY_SIZE(axp20x_supplies),
 292         },
 293 };
 294
 295 static struct resource axp288_adc_resources[] = {
 296         {
 297                 .name  = "GPADC",
 298                 .start = AXP288_IRQ_GPADC,
 299                 .end   = AXP288_IRQ_GPADC,
 300                 .flags = IORESOURCE_IRQ,
 301         },
 302 };
 303
 304 static struct resource axp288_charger_resources[] = {
 305         {
 306                 .start = AXP288_IRQ_OV,
 307                 .end   = AXP288_IRQ_OV,
 308                 .flags = IORESOURCE_IRQ,
 309         },
 310         {
 311                 .start = AXP288_IRQ_DONE,
 312                 .end   = AXP288_IRQ_DONE,
 313                 .flags = IORESOURCE_IRQ,
 314         },
 315         {
 316                 .start = AXP288_IRQ_CHARGING,
 317                 .end   = AXP288_IRQ_CHARGING,
 318                 .flags = IORESOURCE_IRQ,
 319         },
 320         {
 321                 .start = AXP288_IRQ_SAFE_QUIT,
 322                 .end   = AXP288_IRQ_SAFE_QUIT,
 323                 .flags = IORESOURCE_IRQ,
 324         },
 325         {
 326                 .start = AXP288_IRQ_SAFE_ENTER,
 327                 .end   = AXP288_IRQ_SAFE_ENTER,
 328                 .flags = IORESOURCE_IRQ,
 329         },
 330         {
 331                 .start = AXP288_IRQ_QCBTU,
 332                 .end   = AXP288_IRQ_QCBTU,
 333                 .flags = IORESOURCE_IRQ,
 334         },
 335         {
 336                 .start = AXP288_IRQ_CBTU,
 337                 .end   = AXP288_IRQ_CBTU,
 338                 .flags = IORESOURCE_IRQ,
 339         },
 340         {
 341                 .start = AXP288_IRQ_QCBTO,
 342                 .end   = AXP288_IRQ_QCBTO,
 343                 .flags = IORESOURCE_IRQ,
 344         },
 345         {
 346                 .start = AXP288_IRQ_CBTO,
 347                 .end   = AXP288_IRQ_CBTO,
 348                 .flags = IORESOURCE_IRQ,
 349         },
 350 };
 351
 352 static struct mfd_cell axp288_cells[] = {
 353         {
 354                 .name = "axp288_adc",
 355                 .num_resources = ARRAY_SIZE(axp288_adc_resources),
 356                 .resources = axp288_adc_resources,
 357         },
 358         {
 359                 .name = "axp288_charger",
 360                 .num_resources = ARRAY_SIZE(axp288_charger_resources),
 361                 .resources = axp288_charger_resources,
 362         },
 363         {
 364                 .name = "axp288_battery",
 365                 .num_resources = ARRAY_SIZE(axp288_battery_resources),
 366                 .resources = axp288_battery_resources,
 367         },
 368 };
 369
 370 static struct axp20x_dev *axp20x_pm_power_off;
 371 static void axp20x_power_off(void)
 372 {
 373         if (axp20x_pm_power_off->variant == AXP288_ID)
 374                 return;
 375
 376         regmap_write(axp20x_pm_power_off->regmap, AXP20X_OFF_CTRL,
 377                      AXP20X_OFF);
 378 }
 379
 380 static int axp20x_match_device(struct axp20x_dev *axp20x, struct device *dev)
 381 {
 382         const struct acpi_device_id *acpi_id;
 383         const struct of_device_id *of_id;
 384
 385         if (dev->of_node) {
 386                 of_id = of_match_device(axp20x_of_match, dev);
 387                 if (!of_id) {
 388                         dev_err(dev, "Unable to match OF ID\n");
 389                         return -ENODEV;
 390                 }
 391                 axp20x->variant = (long) of_id->data;
 392         } else {
 393                 acpi_id = acpi_match_device(dev->driver->acpi_match_table, dev);
 394                 if (!acpi_id || !acpi_id->driver_data) {
 395                         dev_err(dev, "Unable to match ACPI ID and data\n");
 396                         return -ENODEV;
 397                 }
 398                 axp20x->variant = (long) acpi_id->driver_data;
 399         }
 400
 401         switch (axp20x->variant) {
 402         case AXP202_ID:
 403         case AXP209_ID:
 404                 axp20x->nr_cells = ARRAY_SIZE(axp20x_cells);
 405                 axp20x->cells = axp20x_cells;
 406                 axp20x->regmap_cfg = &axp20x_regmap_config;
 407                 axp20x->regmap_irq_chip = &axp20x_regmap_irq_chip;
 408                 break;
 409         case AXP288_ID:
 410                 axp20x->cells = axp288_cells;
 411                 axp20x->nr_cells = ARRAY_SIZE(axp288_cells);
 412                 axp20x->regmap_cfg = &axp288_regmap_config;
 413                 axp20x->regmap_irq_chip = &axp288_regmap_irq_chip;
 414                 break;
 415         default:
 416                 dev_err(dev, "unsupported AXP20X ID %lu\n", axp20x->variant);
 417                 return -EINVAL;
 418         }
 419         dev_info(dev, "AXP20x variant %s found\n",
 420                 axp20x_model_names[axp20x->variant]);
 421
 422         return 0;
 423 }
 424
 425 static int axp20x_i2c_probe(struct i2c_client *i2c,
 426                          const struct i2c_device_id *id)
 427 {
 428         struct axp20x_dev *axp20x;
 429         int ret;
 430
 431         axp20x = devm_kzalloc(&i2c->dev, sizeof(*axp20x), GFP_KERNEL);
 432         if (!axp20x)
 433                 return -ENOMEM;
 434
 435         ret = axp20x_match_device(axp20x, &i2c->dev);
 436         if (ret)
 437                 return ret;
 438
 439         axp20x->i2c_client = i2c;
 440         axp20x->dev = &i2c->dev;
 441         dev_set_drvdata(axp20x->dev, axp20x);
 442
 443         axp20x->regmap = devm_regmap_init_i2c(i2c, axp20x->regmap_cfg);
 444         if (IS_ERR(axp20x->regmap)) {
 445                 ret = PTR_ERR(axp20x->regmap);
 446                 dev_err(&i2c->dev, "regmap init failed: %d\n", ret);
 447                 return ret;
 448         }
 449
 450         ret = regmap_add_irq_chip(axp20x->regmap, i2c->irq,
 451                                   IRQF_ONESHOT | IRQF_SHARED, -1,
 452                                   axp20x->regmap_irq_chip,
 453                                   &axp20x->regmap_irqc);
 454         if (ret) {
 455                 dev_err(&i2c->dev, "failed to add irq chip: %d\n", ret);
 456                 return ret;
 457         }
 458
 459         ret = mfd_add_devices(axp20x->dev, -1, axp20x->cells,
 460                         axp20x->nr_cells, NULL, 0, NULL);
 461
 462         if (ret) {
 463                 dev_err(&i2c->dev, "failed to add MFD devices: %d\n", ret);
 464                 regmap_del_irq_chip(i2c->irq, axp20x->regmap_irqc);
 465                 return ret;
 466         }
 467
 468         if (!pm_power_off) {
 469                 axp20x_pm_power_off = axp20x;
 470                 pm_power_off = axp20x_power_off;
 471         }
 472
 473         dev_info(&i2c->dev, "AXP20X driver loaded\n");
 474
 475         return 0;
 476 }
 477
 478 static int axp20x_i2c_remove(struct i2c_client *i2c)
 479 {
 480         struct axp20x_dev *axp20x = i2c_get_clientdata(i2c);
 481
 482         if (axp20x == axp20x_pm_power_off) {
 483                 axp20x_pm_power_off = NULL;
 484                 pm_power_off = NULL;
 485         }
 486
 487         mfd_remove_devices(axp20x->dev);
 488         regmap_del_irq_chip(axp20x->i2c_client->irq, axp20x->regmap_irqc);
 489
 490         return 0;
 491 }
 492
 493 static struct i2c_driver axp20x_i2c_driver = {
 494         .driver = {
 495                 .name   = "axp20x",
 496                 .owner  = THIS_MODULE,
 497                 .of_match_table = of_match_ptr(axp20x_of_match),
 498                 .acpi_match_table = ACPI_PTR(axp20x_acpi_match),
 499         },
 500         .probe          = axp20x_i2c_probe,
 501         .remove         = axp20x_i2c_remove,
 502         .id_table       = axp20x_i2c_id,
 503 };
 504
 505 module_i2c_driver(axp20x_i2c_driver);
 506
 507 MODULE_DESCRIPTION("PMIC MFD core driver for AXP20X");
 508 MODULE_AUTHOR("Carlo Caione <carlo@caione.org>");
 509 MODULE_LICENSE("GPL");