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 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");