drivers/power/supply/axp20x_usb_power.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * AXP20x PMIC USB power supply status driver
   4  *
   5  * Copyright (C) 2015 Hans de Goede <hdegoede@redhat.com>
   6  * Copyright (C) 2014 Bruno Prémont <bonbons@linux-vserver.org>
   7  */
   8
   9 #include <linux/bitops.h>
  10 #include <linux/device.h>
  11 #include <linux/init.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/kernel.h>
  14 #include <linux/mfd/axp20x.h>
  15 #include <linux/module.h>
  16 #include <linux/of.h>
  17 #include <linux/of_device.h>
  18 #include <linux/platform_device.h>
  19 #include <linux/power_supply.h>
  20 #include <linux/regmap.h>
  21 #include <linux/slab.h>
  22 #include <linux/iio/consumer.h>
  23 #include <linux/workqueue.h>
  24
  25 #define DRVNAME "axp20x-usb-power-supply"
  26
  27 #define AXP20X_PWR_STATUS_VBUS_PRESENT  BIT(5)
  28 #define AXP20X_PWR_STATUS_VBUS_USED     BIT(4)
  29
  30 #define AXP20X_USB_STATUS_VBUS_VALID    BIT(2)
  31
  32 #define AXP20X_VBUS_VHOLD_uV(b)         (4000000 + (((b) >> 3) & 7) * 100000)
  33 #define AXP20X_VBUS_VHOLD_MASK          GENMASK(5, 3)
  34 #define AXP20X_VBUS_VHOLD_OFFSET        3
  35 #define AXP20X_VBUS_CLIMIT_MASK         3
  36 #define AXP20X_VBUS_CLIMIT_900mA        0
  37 #define AXP20X_VBUS_CLIMIT_500mA        1
  38 #define AXP20X_VBUS_CLIMIT_100mA        2
  39 #define AXP20X_VBUS_CLIMIT_NONE         3
  40
  41 #define AXP813_VBUS_CLIMIT_900mA        0
  42 #define AXP813_VBUS_CLIMIT_1500mA       1
  43 #define AXP813_VBUS_CLIMIT_2000mA       2
  44 #define AXP813_VBUS_CLIMIT_2500mA       3
  45
  46 #define AXP20X_ADC_EN1_VBUS_CURR        BIT(2)
  47 #define AXP20X_ADC_EN1_VBUS_VOLT        BIT(3)
  48
  49 #define AXP20X_VBUS_MON_VBUS_VALID      BIT(3)
  50
  51 #define AXP813_BC_EN            BIT(0)
  52
  53 /*
  54  * Note do not raise the debounce time, we must report Vusb high within
  55  * 100ms otherwise we get Vbus errors in musb.
  56  */
  57 #define DEBOUNCE_TIME                   msecs_to_jiffies(50)
  58
  59 struct axp20x_usb_power {
  60         struct device_node *np;
  61         struct regmap *regmap;
  62         struct power_supply *supply;
  63         enum axp20x_variants axp20x_id;
  64         struct iio_channel *vbus_v;
  65         struct iio_channel *vbus_i;
  66         struct delayed_work vbus_detect;
  67         unsigned int old_status;
  68 };
  69
  70 static irqreturn_t axp20x_usb_power_irq(int irq, void *devid)
  71 {
  72         struct axp20x_usb_power *power = devid;
  73
  74         power_supply_changed(power->supply);
  75
  76         return IRQ_HANDLED;
  77 }
  78
  79 static void axp20x_usb_power_poll_vbus(struct work_struct *work)
  80 {
  81         struct axp20x_usb_power *power =
  82                 container_of(work, struct axp20x_usb_power, vbus_detect.work);
  83         unsigned int val;
  84         int ret;
  85
  86         ret = regmap_read(power->regmap, AXP20X_PWR_INPUT_STATUS, &val);
  87         if (ret)
  88                 goto out;
  89
  90         val &= (AXP20X_PWR_STATUS_VBUS_PRESENT | AXP20X_PWR_STATUS_VBUS_USED);
  91         if (val != power->old_status)
  92                 power_supply_changed(power->supply);
  93
  94         power->old_status = val;
  95
  96 out:
  97         mod_delayed_work(system_wq, &power->vbus_detect, DEBOUNCE_TIME);
  98 }
  99
 100 static bool axp20x_usb_vbus_needs_polling(struct axp20x_usb_power *power)
 101 {
 102         if (power->axp20x_id >= AXP221_ID)
 103                 return true;
 104
 105         return false;
 106 }
 107
 108 static int axp20x_get_current_max(struct axp20x_usb_power *power, int *val)
 109 {
 110         unsigned int v;
 111         int ret = regmap_read(power->regmap, AXP20X_VBUS_IPSOUT_MGMT, &v);
 112
 113         if (ret)
 114                 return ret;
 115
 116         switch (v & AXP20X_VBUS_CLIMIT_MASK) {
 117         case AXP20X_VBUS_CLIMIT_100mA:
 118                 if (power->axp20x_id == AXP221_ID)
 119                         *val = -1; /* No 100mA limit */
 120                 else
 121                         *val = 100000;
 122                 break;
 123         case AXP20X_VBUS_CLIMIT_500mA:
 124                 *val = 500000;
 125                 break;
 126         case AXP20X_VBUS_CLIMIT_900mA:
 127                 *val = 900000;
 128                 break;
 129         case AXP20X_VBUS_CLIMIT_NONE:
 130                 *val = -1;
 131                 break;
 132         }
 133
 134         return 0;
 135 }
 136
 137 static int axp813_get_current_max(struct axp20x_usb_power *power, int *val)
 138 {
 139         unsigned int v;
 140         int ret = regmap_read(power->regmap, AXP20X_VBUS_IPSOUT_MGMT, &v);
 141
 142         if (ret)
 143                 return ret;
 144
 145         switch (v & AXP20X_VBUS_CLIMIT_MASK) {
 146         case AXP813_VBUS_CLIMIT_900mA:
 147                 *val = 900000;
 148                 break;
 149         case AXP813_VBUS_CLIMIT_1500mA:
 150                 *val = 1500000;
 151                 break;
 152         case AXP813_VBUS_CLIMIT_2000mA:
 153                 *val = 2000000;
 154                 break;
 155         case AXP813_VBUS_CLIMIT_2500mA:
 156                 *val = 2500000;
 157                 break;
 158         }
 159         return 0;
 160 }
 161
 162 static int axp20x_usb_power_get_property(struct power_supply *psy,
 163         enum power_supply_property psp, union power_supply_propval *val)
 164 {
 165         struct axp20x_usb_power *power = power_supply_get_drvdata(psy);
 166         unsigned int input, v;
 167         int ret;
 168
 169         switch (psp) {
 170         case POWER_SUPPLY_PROP_VOLTAGE_MIN:
 171                 ret = regmap_read(power->regmap, AXP20X_VBUS_IPSOUT_MGMT, &v);
 172                 if (ret)
 173                         return ret;
 174
 175                 val->intval = AXP20X_VBUS_VHOLD_uV(v);
 176                 return 0;
 177         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 178                 if (IS_ENABLED(CONFIG_AXP20X_ADC)) {
 179                         ret = iio_read_channel_processed(power->vbus_v,
 180                                                          &val->intval);
 181                         if (ret)
 182                                 return ret;
 183
 184                         /*
 185                          * IIO framework gives mV but Power Supply framework
 186                          * gives uV.
 187                          */
 188                         val->intval *= 1000;
 189                         return 0;
 190                 }
 191
 192                 ret = axp20x_read_variable_width(power->regmap,
 193                                                  AXP20X_VBUS_V_ADC_H, 12);
 194                 if (ret < 0)
 195                         return ret;
 196
 197                 val->intval = ret * 1700; /* 1 step = 1.7 mV */
 198                 return 0;
 199         case POWER_SUPPLY_PROP_CURRENT_MAX:
 200                 if (power->axp20x_id == AXP813_ID)
 201                         return axp813_get_current_max(power, &val->intval);
 202                 return axp20x_get_current_max(power, &val->intval);
 203         case POWER_SUPPLY_PROP_CURRENT_NOW:
 204                 if (IS_ENABLED(CONFIG_AXP20X_ADC)) {
 205                         ret = iio_read_channel_processed(power->vbus_i,
 206                                                          &val->intval);
 207                         if (ret)
 208                                 return ret;
 209
 210                         /*
 211                          * IIO framework gives mA but Power Supply framework
 212                          * gives uA.
 213                          */
 214                         val->intval *= 1000;
 215                         return 0;
 216                 }
 217
 218                 ret = axp20x_read_variable_width(power->regmap,
 219                                                  AXP20X_VBUS_I_ADC_H, 12);
 220                 if (ret < 0)
 221                         return ret;
 222
 223                 val->intval = ret * 375; /* 1 step = 0.375 mA */
 224                 return 0;
 225         default:
 226                 break;
 227         }
 228
 229         /* All the properties below need the input-status reg value */
 230         ret = regmap_read(power->regmap, AXP20X_PWR_INPUT_STATUS, &input);
 231         if (ret)
 232                 return ret;
 233
 234         switch (psp) {
 235         case POWER_SUPPLY_PROP_HEALTH:
 236                 if (!(input & AXP20X_PWR_STATUS_VBUS_PRESENT)) {
 237                         val->intval = POWER_SUPPLY_HEALTH_UNKNOWN;
 238                         break;
 239                 }
 240
 241                 val->intval = POWER_SUPPLY_HEALTH_GOOD;
 242
 243                 if (power->axp20x_id == AXP202_ID) {
 244                         ret = regmap_read(power->regmap,
 245                                           AXP20X_USB_OTG_STATUS, &v);
 246                         if (ret)
 247                                 return ret;
 248
 249                         if (!(v & AXP20X_USB_STATUS_VBUS_VALID))
 250                                 val->intval =
 251                                         POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
 252                 }
 253                 break;
 254         case POWER_SUPPLY_PROP_PRESENT:
 255                 val->intval = !!(input & AXP20X_PWR_STATUS_VBUS_PRESENT);
 256                 break;
 257         case POWER_SUPPLY_PROP_ONLINE:
 258                 val->intval = !!(input & AXP20X_PWR_STATUS_VBUS_USED);
 259                 break;
 260         default:
 261                 return -EINVAL;
 262         }
 263
 264         return 0;
 265 }
 266
 267 static int axp20x_usb_power_set_voltage_min(struct axp20x_usb_power *power,
 268                                             int intval)
 269 {
 270         int val;
 271
 272         switch (intval) {
 273         case 4000000:
 274         case 4100000:
 275         case 4200000:
 276         case 4300000:
 277         case 4400000:
 278         case 4500000:
 279         case 4600000:
 280         case 4700000:
 281                 val = (intval - 4000000) / 100000;
 282                 return regmap_update_bits(power->regmap,
 283                                           AXP20X_VBUS_IPSOUT_MGMT,
 284                                           AXP20X_VBUS_VHOLD_MASK,
 285                                           val << AXP20X_VBUS_VHOLD_OFFSET);
 286         default:
 287                 return -EINVAL;
 288         }
 289
 290         return -EINVAL;
 291 }
 292
 293 static int axp813_usb_power_set_current_max(struct axp20x_usb_power *power,
 294                                             int intval)
 295 {
 296         int val;
 297
 298         switch (intval) {
 299         case 900000:
 300                 return regmap_update_bits(power->regmap,
 301                                           AXP20X_VBUS_IPSOUT_MGMT,
 302                                           AXP20X_VBUS_CLIMIT_MASK,
 303                                           AXP813_VBUS_CLIMIT_900mA);
 304         case 1500000:
 305         case 2000000:
 306         case 2500000:
 307                 val = (intval - 1000000) / 500000;
 308                 return regmap_update_bits(power->regmap,
 309                                           AXP20X_VBUS_IPSOUT_MGMT,
 310                                           AXP20X_VBUS_CLIMIT_MASK, val);
 311         default:
 312                 return -EINVAL;
 313         }
 314
 315         return -EINVAL;
 316 }
 317
 318 static int axp20x_usb_power_set_current_max(struct axp20x_usb_power *power,
 319                                             int intval)
 320 {
 321         int val;
 322
 323         switch (intval) {
 324         case 100000:
 325                 if (power->axp20x_id == AXP221_ID)
 326                         return -EINVAL;
 327                 /* fall through */
 328         case 500000:
 329         case 900000:
 330                 val = (900000 - intval) / 400000;
 331                 return regmap_update_bits(power->regmap,
 332                                           AXP20X_VBUS_IPSOUT_MGMT,
 333                                           AXP20X_VBUS_CLIMIT_MASK, val);
 334         default:
 335                 return -EINVAL;
 336         }
 337
 338         return -EINVAL;
 339 }
 340
 341 static int axp20x_usb_power_set_property(struct power_supply *psy,
 342                                          enum power_supply_property psp,
 343                                          const union power_supply_propval *val)
 344 {
 345         struct axp20x_usb_power *power = power_supply_get_drvdata(psy);
 346
 347         switch (psp) {
 348         case POWER_SUPPLY_PROP_VOLTAGE_MIN:
 349                 return axp20x_usb_power_set_voltage_min(power, val->intval);
 350
 351         case POWER_SUPPLY_PROP_CURRENT_MAX:
 352                 if (power->axp20x_id == AXP813_ID)
 353                         return axp813_usb_power_set_current_max(power,
 354                                                                 val->intval);
 355                 return axp20x_usb_power_set_current_max(power, val->intval);
 356
 357         default:
 358                 return -EINVAL;
 359         }
 360
 361         return -EINVAL;
 362 }
 363
 364 static int axp20x_usb_power_prop_writeable(struct power_supply *psy,
 365                                            enum power_supply_property psp)
 366 {
 367         return psp == POWER_SUPPLY_PROP_VOLTAGE_MIN ||
 368                psp == POWER_SUPPLY_PROP_CURRENT_MAX;
 369 }
 370
 371 static enum power_supply_property axp20x_usb_power_properties[] = {
 372         POWER_SUPPLY_PROP_HEALTH,
 373         POWER_SUPPLY_PROP_PRESENT,
 374         POWER_SUPPLY_PROP_ONLINE,
 375         POWER_SUPPLY_PROP_VOLTAGE_MIN,
 376         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 377         POWER_SUPPLY_PROP_CURRENT_MAX,
 378         POWER_SUPPLY_PROP_CURRENT_NOW,
 379 };
 380
 381 static enum power_supply_property axp22x_usb_power_properties[] = {
 382         POWER_SUPPLY_PROP_HEALTH,
 383         POWER_SUPPLY_PROP_PRESENT,
 384         POWER_SUPPLY_PROP_ONLINE,
 385         POWER_SUPPLY_PROP_VOLTAGE_MIN,
 386         POWER_SUPPLY_PROP_CURRENT_MAX,
 387 };
 388
 389 static const struct power_supply_desc axp20x_usb_power_desc = {
 390         .name = "axp20x-usb",
 391         .type = POWER_SUPPLY_TYPE_USB,
 392         .properties = axp20x_usb_power_properties,
 393         .num_properties = ARRAY_SIZE(axp20x_usb_power_properties),
 394         .property_is_writeable = axp20x_usb_power_prop_writeable,
 395         .get_property = axp20x_usb_power_get_property,
 396         .set_property = axp20x_usb_power_set_property,
 397 };
 398
 399 static const struct power_supply_desc axp22x_usb_power_desc = {
 400         .name = "axp20x-usb",
 401         .type = POWER_SUPPLY_TYPE_USB,
 402         .properties = axp22x_usb_power_properties,
 403         .num_properties = ARRAY_SIZE(axp22x_usb_power_properties),
 404         .property_is_writeable = axp20x_usb_power_prop_writeable,
 405         .get_property = axp20x_usb_power_get_property,
 406         .set_property = axp20x_usb_power_set_property,
 407 };
 408
 409 static int configure_iio_channels(struct platform_device *pdev,
 410                                   struct axp20x_usb_power *power)
 411 {
 412         power->vbus_v = devm_iio_channel_get(&pdev->dev, "vbus_v");
 413         if (IS_ERR(power->vbus_v)) {
 414                 if (PTR_ERR(power->vbus_v) == -ENODEV)
 415                         return -EPROBE_DEFER;
 416                 return PTR_ERR(power->vbus_v);
 417         }
 418
 419         power->vbus_i = devm_iio_channel_get(&pdev->dev, "vbus_i");
 420         if (IS_ERR(power->vbus_i)) {
 421                 if (PTR_ERR(power->vbus_i) == -ENODEV)
 422                         return -EPROBE_DEFER;
 423                 return PTR_ERR(power->vbus_i);
 424         }
 425
 426         return 0;
 427 }
 428
 429 static int configure_adc_registers(struct axp20x_usb_power *power)
 430 {
 431         /* Enable vbus voltage and current measurement */
 432         return regmap_update_bits(power->regmap, AXP20X_ADC_EN1,
 433                                   AXP20X_ADC_EN1_VBUS_CURR |
 434                                   AXP20X_ADC_EN1_VBUS_VOLT,
 435                                   AXP20X_ADC_EN1_VBUS_CURR |
 436                                   AXP20X_ADC_EN1_VBUS_VOLT);
 437 }
 438
 439 static int axp20x_usb_power_probe(struct platform_device *pdev)
 440 {
 441         struct axp20x_dev *axp20x = dev_get_drvdata(pdev->dev.parent);
 442         struct power_supply_config psy_cfg = {};
 443         struct axp20x_usb_power *power;
 444         static const char * const axp20x_irq_names[] = { "VBUS_PLUGIN",
 445                 "VBUS_REMOVAL", "VBUS_VALID", "VBUS_NOT_VALID", NULL };
 446         static const char * const axp22x_irq_names[] = {
 447                 "VBUS_PLUGIN", "VBUS_REMOVAL", NULL };
 448         const char * const *irq_names;
 449         const struct power_supply_desc *usb_power_desc;
 450         int i, irq, ret;
 451
 452         if (!of_device_is_available(pdev->dev.of_node))
 453                 return -ENODEV;
 454
 455         if (!axp20x) {
 456                 dev_err(&pdev->dev, "Parent drvdata not set\n");
 457                 return -EINVAL;
 458         }
 459
 460         power = devm_kzalloc(&pdev->dev, sizeof(*power), GFP_KERNEL);
 461         if (!power)
 462                 return -ENOMEM;
 463
 464         platform_set_drvdata(pdev, power);
 465         power->axp20x_id = (enum axp20x_variants)of_device_get_match_data(
 466                                                                 &pdev->dev);
 467
 468         power->np = pdev->dev.of_node;
 469         power->regmap = axp20x->regmap;
 470
 471         if (power->axp20x_id == AXP202_ID) {
 472                 /* Enable vbus valid checking */
 473                 ret = regmap_update_bits(power->regmap, AXP20X_VBUS_MON,
 474                                          AXP20X_VBUS_MON_VBUS_VALID,
 475                                          AXP20X_VBUS_MON_VBUS_VALID);
 476                 if (ret)
 477                         return ret;
 478
 479                 if (IS_ENABLED(CONFIG_AXP20X_ADC))
 480                         ret = configure_iio_channels(pdev, power);
 481                 else
 482                         ret = configure_adc_registers(power);
 483
 484                 if (ret)
 485                         return ret;
 486
 487                 usb_power_desc = &axp20x_usb_power_desc;
 488                 irq_names = axp20x_irq_names;
 489         } else if (power->axp20x_id == AXP221_ID ||
 490                    power->axp20x_id == AXP223_ID ||
 491                    power->axp20x_id == AXP813_ID) {
 492                 usb_power_desc = &axp22x_usb_power_desc;
 493                 irq_names = axp22x_irq_names;
 494         } else {
 495                 dev_err(&pdev->dev, "Unsupported AXP variant: %ld\n",
 496                         axp20x->variant);
 497                 return -EINVAL;
 498         }
 499
 500         if (power->axp20x_id == AXP813_ID) {
 501                 /* Enable USB Battery Charging specification detection */
 502                 regmap_update_bits(axp20x->regmap, AXP288_BC_GLOBAL,
 503                                    AXP813_BC_EN, AXP813_BC_EN);
 504         }
 505
 506         psy_cfg.of_node = pdev->dev.of_node;
 507         psy_cfg.drv_data = power;
 508
 509         power->supply = devm_power_supply_register(&pdev->dev, usb_power_desc,
 510                                                    &psy_cfg);
 511         if (IS_ERR(power->supply))
 512                 return PTR_ERR(power->supply);
 513
 514         /* Request irqs after registering, as irqs may trigger immediately */
 515         for (i = 0; irq_names[i]; i++) {
 516                 irq = platform_get_irq_byname(pdev, irq_names[i]);
 517                 if (irq < 0) {
 518                         dev_warn(&pdev->dev, "No IRQ for %s: %d\n",
 519                                  irq_names[i], irq);
 520                         continue;
 521                 }
 522                 irq = regmap_irq_get_virq(axp20x->regmap_irqc, irq);
 523                 ret = devm_request_any_context_irq(&pdev->dev, irq,
 524                                 axp20x_usb_power_irq, 0, DRVNAME, power);
 525                 if (ret < 0)
 526                         dev_warn(&pdev->dev, "Error requesting %s IRQ: %d\n",
 527                                  irq_names[i], ret);
 528         }
 529
 530         INIT_DELAYED_WORK(&power->vbus_detect, axp20x_usb_power_poll_vbus);
 531         if (axp20x_usb_vbus_needs_polling(power))
 532                 queue_delayed_work(system_wq, &power->vbus_detect, 0);
 533
 534         return 0;
 535 }
 536
 537 static int axp20x_usb_power_remove(struct platform_device *pdev)
 538 {
 539         struct axp20x_usb_power *power = platform_get_drvdata(pdev);
 540
 541         cancel_delayed_work_sync(&power->vbus_detect);
 542
 543         return 0;
 544 }
 545
 546 static const struct of_device_id axp20x_usb_power_match[] = {
 547         {
 548                 .compatible = "x-powers,axp202-usb-power-supply",
 549                 .data = (void *)AXP202_ID,
 550         }, {
 551                 .compatible = "x-powers,axp221-usb-power-supply",
 552                 .data = (void *)AXP221_ID,
 553         }, {
 554                 .compatible = "x-powers,axp223-usb-power-supply",
 555                 .data = (void *)AXP223_ID,
 556         }, {
 557                 .compatible = "x-powers,axp813-usb-power-supply",
 558                 .data = (void *)AXP813_ID,
 559         }, { /* sentinel */ }
 560 };
 561 MODULE_DEVICE_TABLE(of, axp20x_usb_power_match);
 562
 563 static struct platform_driver axp20x_usb_power_driver = {
 564         .probe = axp20x_usb_power_probe,
 565         .remove = axp20x_usb_power_remove,
 566         .driver = {
 567                 .name = DRVNAME,
 568                 .of_match_table = axp20x_usb_power_match,
 569         },
 570 };
 571
 572 module_platform_driver(axp20x_usb_power_driver);
 573
 574 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
 575 MODULE_DESCRIPTION("AXP20x PMIC USB power supply status driver");
 576 MODULE_LICENSE("GPL");