power/supply/axp20x_usb_power.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * AXP20x PMIC USB power supply status driver
0004  *
0005  * Copyright (C) 2015 Hans de Goede <hdegoede@redhat.com>
0006  * Copyright (C) 2014 Bruno Prémont <bonbons@linux-vserver.org>
0007  */
0008
0009 #include <linux/bitops.h>
0010 #include <linux/device.h>
0011 #include <linux/devm-helpers.h>
0012 #include <linux/init.h>
0013 #include <linux/interrupt.h>
0014 #include <linux/kernel.h>
0015 #include <linux/mfd/axp20x.h>
0016 #include <linux/module.h>
0017 #include <linux/of.h>
0018 #include <linux/of_device.h>
0019 #include <linux/platform_device.h>
0020 #include <linux/pm.h>
0021 #include <linux/power_supply.h>
0022 #include <linux/regmap.h>
0023 #include <linux/slab.h>
0024 #include <linux/iio/consumer.h>
0025 #include <linux/workqueue.h>
0026
0027 #define DRVNAME "axp20x-usb-power-supply"
0028
0029 #define AXP20X_PWR_STATUS_VBUS_PRESENT  BIT(5)
0030 #define AXP20X_PWR_STATUS_VBUS_USED BIT(4)
0031
0032 #define AXP20X_USB_STATUS_VBUS_VALID    BIT(2)
0033
0034 #define AXP20X_VBUS_PATH_SEL        BIT(7)
0035 #define AXP20X_VBUS_PATH_SEL_OFFSET 7
0036
0037 #define AXP20X_VBUS_VHOLD_uV(b)     (4000000 + (((b) >> 3) & 7) * 100000)
0038 #define AXP20X_VBUS_VHOLD_MASK      GENMASK(5, 3)
0039 #define AXP20X_VBUS_VHOLD_OFFSET    3
0040 #define AXP20X_VBUS_CLIMIT_MASK     3
0041 #define AXP20X_VBUS_CLIMIT_900mA    0
0042 #define AXP20X_VBUS_CLIMIT_500mA    1
0043 #define AXP20X_VBUS_CLIMIT_100mA    2
0044 #define AXP20X_VBUS_CLIMIT_NONE     3
0045
0046 #define AXP813_VBUS_CLIMIT_900mA    0
0047 #define AXP813_VBUS_CLIMIT_1500mA   1
0048 #define AXP813_VBUS_CLIMIT_2000mA   2
0049 #define AXP813_VBUS_CLIMIT_2500mA   3
0050
0051 #define AXP20X_ADC_EN1_VBUS_CURR    BIT(2)
0052 #define AXP20X_ADC_EN1_VBUS_VOLT    BIT(3)
0053
0054 #define AXP20X_VBUS_MON_VBUS_VALID  BIT(3)
0055
0056 #define AXP813_BC_EN        BIT(0)
0057
0058 /*
0059  * Note do not raise the debounce time, we must report Vusb high within
0060  * 100ms otherwise we get Vbus errors in musb.
0061  */
0062 #define DEBOUNCE_TIME           msecs_to_jiffies(50)
0063
0064 struct axp20x_usb_power {
0065     struct regmap *regmap;
0066     struct power_supply *supply;
0067     enum axp20x_variants axp20x_id;
0068     struct iio_channel *vbus_v;
0069     struct iio_channel *vbus_i;
0070     struct delayed_work vbus_detect;
0071     unsigned int old_status;
0072     unsigned int online;
0073     unsigned int num_irqs;
0074     unsigned int irqs[];
0075 };
0076
0077 static bool axp20x_usb_vbus_needs_polling(struct axp20x_usb_power *power)
0078 {
0079     /*
0080      * Polling is only necessary while VBUS is offline. While online, a
0081      * present->absent transition implies an online->offline transition
0082      * and will trigger the VBUS_REMOVAL IRQ.
0083      */
0084     if (power->axp20x_id >= AXP221_ID && !power->online)
0085         return true;
0086
0087     return false;
0088 }
0089
0090 static irqreturn_t axp20x_usb_power_irq(int irq, void *devid)
0091 {
0092     struct axp20x_usb_power *power = devid;
0093
0094     power_supply_changed(power->supply);
0095
0096     mod_delayed_work(system_power_efficient_wq, &power->vbus_detect, DEBOUNCE_TIME);
0097
0098     return IRQ_HANDLED;
0099 }
0100
0101 static void axp20x_usb_power_poll_vbus(struct work_struct *work)
0102 {
0103     struct axp20x_usb_power *power =
0104         container_of(work, struct axp20x_usb_power, vbus_detect.work);
0105     unsigned int val;
0106     int ret;
0107
0108     ret = regmap_read(power->regmap, AXP20X_PWR_INPUT_STATUS, &val);
0109     if (ret)
0110         goto out;
0111
0112     val &= (AXP20X_PWR_STATUS_VBUS_PRESENT | AXP20X_PWR_STATUS_VBUS_USED);
0113     if (val != power->old_status)
0114         power_supply_changed(power->supply);
0115
0116     power->old_status = val;
0117     power->online = val & AXP20X_PWR_STATUS_VBUS_USED;
0118
0119 out:
0120     if (axp20x_usb_vbus_needs_polling(power))
0121         mod_delayed_work(system_power_efficient_wq, &power->vbus_detect, DEBOUNCE_TIME);
0122 }
0123
0124 static int axp20x_get_current_max(struct axp20x_usb_power *power, int *val)
0125 {
0126     unsigned int v;
0127     int ret = regmap_read(power->regmap, AXP20X_VBUS_IPSOUT_MGMT, &v);
0128
0129     if (ret)
0130         return ret;
0131
0132     switch (v & AXP20X_VBUS_CLIMIT_MASK) {
0133     case AXP20X_VBUS_CLIMIT_100mA:
0134         if (power->axp20x_id == AXP221_ID)
0135             *val = -1; /* No 100mA limit */
0136         else
0137             *val = 100000;
0138         break;
0139     case AXP20X_VBUS_CLIMIT_500mA:
0140         *val = 500000;
0141         break;
0142     case AXP20X_VBUS_CLIMIT_900mA:
0143         *val = 900000;
0144         break;
0145     case AXP20X_VBUS_CLIMIT_NONE:
0146         *val = -1;
0147         break;
0148     }
0149
0150     return 0;
0151 }
0152
0153 static int axp813_get_current_max(struct axp20x_usb_power *power, int *val)
0154 {
0155     unsigned int v;
0156     int ret = regmap_read(power->regmap, AXP20X_VBUS_IPSOUT_MGMT, &v);
0157
0158     if (ret)
0159         return ret;
0160
0161     switch (v & AXP20X_VBUS_CLIMIT_MASK) {
0162     case AXP813_VBUS_CLIMIT_900mA:
0163         *val = 900000;
0164         break;
0165     case AXP813_VBUS_CLIMIT_1500mA:
0166         *val = 1500000;
0167         break;
0168     case AXP813_VBUS_CLIMIT_2000mA:
0169         *val = 2000000;
0170         break;
0171     case AXP813_VBUS_CLIMIT_2500mA:
0172         *val = 2500000;
0173         break;
0174     }
0175     return 0;
0176 }
0177
0178 static int axp20x_usb_power_get_property(struct power_supply *psy,
0179     enum power_supply_property psp, union power_supply_propval *val)
0180 {
0181     struct axp20x_usb_power *power = power_supply_get_drvdata(psy);
0182     unsigned int input, v;
0183     int ret;
0184
0185     switch (psp) {
0186     case POWER_SUPPLY_PROP_VOLTAGE_MIN:
0187         ret = regmap_read(power->regmap, AXP20X_VBUS_IPSOUT_MGMT, &v);
0188         if (ret)
0189             return ret;
0190
0191         val->intval = AXP20X_VBUS_VHOLD_uV(v);
0192         return 0;
0193     case POWER_SUPPLY_PROP_VOLTAGE_NOW:
0194         if (IS_ENABLED(CONFIG_AXP20X_ADC)) {
0195             ret = iio_read_channel_processed(power->vbus_v,
0196                              &val->intval);
0197             if (ret)
0198                 return ret;
0199
0200             /*
0201              * IIO framework gives mV but Power Supply framework
0202              * gives uV.
0203              */
0204             val->intval *= 1000;
0205             return 0;
0206         }
0207
0208         ret = axp20x_read_variable_width(power->regmap,
0209                          AXP20X_VBUS_V_ADC_H, 12);
0210         if (ret < 0)
0211             return ret;
0212
0213         val->intval = ret * 1700; /* 1 step = 1.7 mV */
0214         return 0;
0215     case POWER_SUPPLY_PROP_CURRENT_MAX:
0216         if (power->axp20x_id == AXP813_ID)
0217             return axp813_get_current_max(power, &val->intval);
0218         return axp20x_get_current_max(power, &val->intval);
0219     case POWER_SUPPLY_PROP_CURRENT_NOW:
0220         if (IS_ENABLED(CONFIG_AXP20X_ADC)) {
0221             ret = iio_read_channel_processed(power->vbus_i,
0222                              &val->intval);
0223             if (ret)
0224                 return ret;
0225
0226             /*
0227              * IIO framework gives mA but Power Supply framework
0228              * gives uA.
0229              */
0230             val->intval *= 1000;
0231             return 0;
0232         }
0233
0234         ret = axp20x_read_variable_width(power->regmap,
0235                          AXP20X_VBUS_I_ADC_H, 12);
0236         if (ret < 0)
0237             return ret;
0238
0239         val->intval = ret * 375; /* 1 step = 0.375 mA */
0240         return 0;
0241     default:
0242         break;
0243     }
0244
0245     /* All the properties below need the input-status reg value */
0246     ret = regmap_read(power->regmap, AXP20X_PWR_INPUT_STATUS, &input);
0247     if (ret)
0248         return ret;
0249
0250     switch (psp) {
0251     case POWER_SUPPLY_PROP_HEALTH:
0252         if (!(input & AXP20X_PWR_STATUS_VBUS_PRESENT)) {
0253             val->intval = POWER_SUPPLY_HEALTH_UNKNOWN;
0254             break;
0255         }
0256
0257         val->intval = POWER_SUPPLY_HEALTH_GOOD;
0258
0259         if (power->axp20x_id == AXP202_ID) {
0260             ret = regmap_read(power->regmap,
0261                       AXP20X_USB_OTG_STATUS, &v);
0262             if (ret)
0263                 return ret;
0264
0265             if (!(v & AXP20X_USB_STATUS_VBUS_VALID))
0266                 val->intval =
0267                     POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
0268         }
0269         break;
0270     case POWER_SUPPLY_PROP_PRESENT:
0271         val->intval = !!(input & AXP20X_PWR_STATUS_VBUS_PRESENT);
0272         break;
0273     case POWER_SUPPLY_PROP_ONLINE:
0274         val->intval = !!(input & AXP20X_PWR_STATUS_VBUS_USED);
0275         break;
0276     default:
0277         return -EINVAL;
0278     }
0279
0280     return 0;
0281 }
0282
0283 static int axp813_usb_power_set_online(struct axp20x_usb_power *power,
0284                        int intval)
0285 {
0286     int val = !intval << AXP20X_VBUS_PATH_SEL_OFFSET;
0287
0288     return regmap_update_bits(power->regmap,
0289                   AXP20X_VBUS_IPSOUT_MGMT,
0290                   AXP20X_VBUS_PATH_SEL, val);
0291 }
0292
0293 static int axp20x_usb_power_set_voltage_min(struct axp20x_usb_power *power,
0294                         int intval)
0295 {
0296     int val;
0297
0298     switch (intval) {
0299     case 4000000:
0300     case 4100000:
0301     case 4200000:
0302     case 4300000:
0303     case 4400000:
0304     case 4500000:
0305     case 4600000:
0306     case 4700000:
0307         val = (intval - 4000000) / 100000;
0308         return regmap_update_bits(power->regmap,
0309                       AXP20X_VBUS_IPSOUT_MGMT,
0310                       AXP20X_VBUS_VHOLD_MASK,
0311                       val << AXP20X_VBUS_VHOLD_OFFSET);
0312     default:
0313         return -EINVAL;
0314     }
0315
0316     return -EINVAL;
0317 }
0318
0319 static int axp813_usb_power_set_current_max(struct axp20x_usb_power *power,
0320                         int intval)
0321 {
0322     int val;
0323
0324     switch (intval) {
0325     case 900000:
0326         return regmap_update_bits(power->regmap,
0327                       AXP20X_VBUS_IPSOUT_MGMT,
0328                       AXP20X_VBUS_CLIMIT_MASK,
0329                       AXP813_VBUS_CLIMIT_900mA);
0330     case 1500000:
0331     case 2000000:
0332     case 2500000:
0333         val = (intval - 1000000) / 500000;
0334         return regmap_update_bits(power->regmap,
0335                       AXP20X_VBUS_IPSOUT_MGMT,
0336                       AXP20X_VBUS_CLIMIT_MASK, val);
0337     default:
0338         return -EINVAL;
0339     }
0340
0341     return -EINVAL;
0342 }
0343
0344 static int axp20x_usb_power_set_current_max(struct axp20x_usb_power *power,
0345                         int intval)
0346 {
0347     int val;
0348
0349     switch (intval) {
0350     case 100000:
0351         if (power->axp20x_id == AXP221_ID)
0352             return -EINVAL;
0353         fallthrough;
0354     case 500000:
0355     case 900000:
0356         val = (900000 - intval) / 400000;
0357         return regmap_update_bits(power->regmap,
0358                       AXP20X_VBUS_IPSOUT_MGMT,
0359                       AXP20X_VBUS_CLIMIT_MASK, val);
0360     default:
0361         return -EINVAL;
0362     }
0363
0364     return -EINVAL;
0365 }
0366
0367 static int axp20x_usb_power_set_property(struct power_supply *psy,
0368                      enum power_supply_property psp,
0369                      const union power_supply_propval *val)
0370 {
0371     struct axp20x_usb_power *power = power_supply_get_drvdata(psy);
0372
0373     switch (psp) {
0374     case POWER_SUPPLY_PROP_ONLINE:
0375         if (power->axp20x_id != AXP813_ID)
0376             return -EINVAL;
0377         return axp813_usb_power_set_online(power, val->intval);
0378
0379     case POWER_SUPPLY_PROP_VOLTAGE_MIN:
0380         return axp20x_usb_power_set_voltage_min(power, val->intval);
0381
0382     case POWER_SUPPLY_PROP_CURRENT_MAX:
0383         if (power->axp20x_id == AXP813_ID)
0384             return axp813_usb_power_set_current_max(power,
0385                                 val->intval);
0386         return axp20x_usb_power_set_current_max(power, val->intval);
0387
0388     default:
0389         return -EINVAL;
0390     }
0391
0392     return -EINVAL;
0393 }
0394
0395 static int axp20x_usb_power_prop_writeable(struct power_supply *psy,
0396                        enum power_supply_property psp)
0397 {
0398     struct axp20x_usb_power *power = power_supply_get_drvdata(psy);
0399
0400     /*
0401      * The VBUS path select flag works differently on AXP288 and newer:
0402      *  - On AXP20x and AXP22x, the flag enables VBUS (ignoring N_VBUSEN).
0403      *  - On AXP288 and AXP8xx, the flag disables VBUS (ignoring N_VBUSEN).
0404      * We only expose the control on variants where it can be used to force
0405      * the VBUS input offline.
0406      */
0407     if (psp == POWER_SUPPLY_PROP_ONLINE)
0408         return power->axp20x_id == AXP813_ID;
0409
0410     return psp == POWER_SUPPLY_PROP_VOLTAGE_MIN ||
0411            psp == POWER_SUPPLY_PROP_CURRENT_MAX;
0412 }
0413
0414 static enum power_supply_property axp20x_usb_power_properties[] = {
0415     POWER_SUPPLY_PROP_HEALTH,
0416     POWER_SUPPLY_PROP_PRESENT,
0417     POWER_SUPPLY_PROP_ONLINE,
0418     POWER_SUPPLY_PROP_VOLTAGE_MIN,
0419     POWER_SUPPLY_PROP_VOLTAGE_NOW,
0420     POWER_SUPPLY_PROP_CURRENT_MAX,
0421     POWER_SUPPLY_PROP_CURRENT_NOW,
0422 };
0423
0424 static enum power_supply_property axp22x_usb_power_properties[] = {
0425     POWER_SUPPLY_PROP_HEALTH,
0426     POWER_SUPPLY_PROP_PRESENT,
0427     POWER_SUPPLY_PROP_ONLINE,
0428     POWER_SUPPLY_PROP_VOLTAGE_MIN,
0429     POWER_SUPPLY_PROP_CURRENT_MAX,
0430 };
0431
0432 static const struct power_supply_desc axp20x_usb_power_desc = {
0433     .name = "axp20x-usb",
0434     .type = POWER_SUPPLY_TYPE_USB,
0435     .properties = axp20x_usb_power_properties,
0436     .num_properties = ARRAY_SIZE(axp20x_usb_power_properties),
0437     .property_is_writeable = axp20x_usb_power_prop_writeable,
0438     .get_property = axp20x_usb_power_get_property,
0439     .set_property = axp20x_usb_power_set_property,
0440 };
0441
0442 static const struct power_supply_desc axp22x_usb_power_desc = {
0443     .name = "axp20x-usb",
0444     .type = POWER_SUPPLY_TYPE_USB,
0445     .properties = axp22x_usb_power_properties,
0446     .num_properties = ARRAY_SIZE(axp22x_usb_power_properties),
0447     .property_is_writeable = axp20x_usb_power_prop_writeable,
0448     .get_property = axp20x_usb_power_get_property,
0449     .set_property = axp20x_usb_power_set_property,
0450 };
0451
0452 static const char * const axp20x_irq_names[] = {
0453     "VBUS_PLUGIN",
0454     "VBUS_REMOVAL",
0455     "VBUS_VALID",
0456     "VBUS_NOT_VALID",
0457 };
0458
0459 static const char * const axp22x_irq_names[] = {
0460     "VBUS_PLUGIN",
0461     "VBUS_REMOVAL",
0462 };
0463
0464 struct axp_data {
0465     const struct power_supply_desc  *power_desc;
0466     const char * const      *irq_names;
0467     unsigned int            num_irq_names;
0468     enum axp20x_variants        axp20x_id;
0469 };
0470
0471 static const struct axp_data axp202_data = {
0472     .power_desc = &axp20x_usb_power_desc,
0473     .irq_names  = axp20x_irq_names,
0474     .num_irq_names  = ARRAY_SIZE(axp20x_irq_names),
0475     .axp20x_id  = AXP202_ID,
0476 };
0477
0478 static const struct axp_data axp221_data = {
0479     .power_desc = &axp22x_usb_power_desc,
0480     .irq_names  = axp22x_irq_names,
0481     .num_irq_names  = ARRAY_SIZE(axp22x_irq_names),
0482     .axp20x_id  = AXP221_ID,
0483 };
0484
0485 static const struct axp_data axp223_data = {
0486     .power_desc = &axp22x_usb_power_desc,
0487     .irq_names  = axp22x_irq_names,
0488     .num_irq_names  = ARRAY_SIZE(axp22x_irq_names),
0489     .axp20x_id  = AXP223_ID,
0490 };
0491
0492 static const struct axp_data axp813_data = {
0493     .power_desc = &axp22x_usb_power_desc,
0494     .irq_names  = axp22x_irq_names,
0495     .num_irq_names  = ARRAY_SIZE(axp22x_irq_names),
0496     .axp20x_id  = AXP813_ID,
0497 };
0498
0499 #ifdef CONFIG_PM_SLEEP
0500 static int axp20x_usb_power_suspend(struct device *dev)
0501 {
0502     struct axp20x_usb_power *power = dev_get_drvdata(dev);
0503     int i = 0;
0504
0505     /*
0506      * Allow wake via VBUS_PLUGIN only.
0507      *
0508      * As nested threaded IRQs are not automatically disabled during
0509      * suspend, we must explicitly disable the remainder of the IRQs.
0510      */
0511     if (device_may_wakeup(&power->supply->dev))
0512         enable_irq_wake(power->irqs[i++]);
0513     while (i < power->num_irqs)
0514         disable_irq(power->irqs[i++]);
0515
0516     return 0;
0517 }
0518
0519 static int axp20x_usb_power_resume(struct device *dev)
0520 {
0521     struct axp20x_usb_power *power = dev_get_drvdata(dev);
0522     int i = 0;
0523
0524     if (device_may_wakeup(&power->supply->dev))
0525         disable_irq_wake(power->irqs[i++]);
0526     while (i < power->num_irqs)
0527         enable_irq(power->irqs[i++]);
0528
0529     mod_delayed_work(system_power_efficient_wq, &power->vbus_detect, DEBOUNCE_TIME);
0530
0531     return 0;
0532 }
0533 #endif
0534
0535 static SIMPLE_DEV_PM_OPS(axp20x_usb_power_pm_ops, axp20x_usb_power_suspend,
0536                           axp20x_usb_power_resume);
0537
0538 static int configure_iio_channels(struct platform_device *pdev,
0539                   struct axp20x_usb_power *power)
0540 {
0541     power->vbus_v = devm_iio_channel_get(&pdev->dev, "vbus_v");
0542     if (IS_ERR(power->vbus_v)) {
0543         if (PTR_ERR(power->vbus_v) == -ENODEV)
0544             return -EPROBE_DEFER;
0545         return PTR_ERR(power->vbus_v);
0546     }
0547
0548     power->vbus_i = devm_iio_channel_get(&pdev->dev, "vbus_i");
0549     if (IS_ERR(power->vbus_i)) {
0550         if (PTR_ERR(power->vbus_i) == -ENODEV)
0551             return -EPROBE_DEFER;
0552         return PTR_ERR(power->vbus_i);
0553     }
0554
0555     return 0;
0556 }
0557
0558 static int configure_adc_registers(struct axp20x_usb_power *power)
0559 {
0560     /* Enable vbus voltage and current measurement */
0561     return regmap_update_bits(power->regmap, AXP20X_ADC_EN1,
0562                   AXP20X_ADC_EN1_VBUS_CURR |
0563                   AXP20X_ADC_EN1_VBUS_VOLT,
0564                   AXP20X_ADC_EN1_VBUS_CURR |
0565                   AXP20X_ADC_EN1_VBUS_VOLT);
0566 }
0567
0568 static int axp20x_usb_power_probe(struct platform_device *pdev)
0569 {
0570     struct axp20x_dev *axp20x = dev_get_drvdata(pdev->dev.parent);
0571     struct power_supply_config psy_cfg = {};
0572     struct axp20x_usb_power *power;
0573     const struct axp_data *axp_data;
0574     int i, irq, ret;
0575
0576     if (!of_device_is_available(pdev->dev.of_node))
0577         return -ENODEV;
0578
0579     if (!axp20x) {
0580         dev_err(&pdev->dev, "Parent drvdata not set\n");
0581         return -EINVAL;
0582     }
0583
0584     axp_data = of_device_get_match_data(&pdev->dev);
0585
0586     power = devm_kzalloc(&pdev->dev,
0587                  struct_size(power, irqs, axp_data->num_irq_names),
0588                  GFP_KERNEL);
0589     if (!power)
0590         return -ENOMEM;
0591
0592     platform_set_drvdata(pdev, power);
0593
0594     power->axp20x_id = axp_data->axp20x_id;
0595     power->regmap = axp20x->regmap;
0596     power->num_irqs = axp_data->num_irq_names;
0597
0598     ret = devm_delayed_work_autocancel(&pdev->dev, &power->vbus_detect,
0599                        axp20x_usb_power_poll_vbus);
0600     if (ret)
0601         return ret;
0602
0603     if (power->axp20x_id == AXP202_ID) {
0604         /* Enable vbus valid checking */
0605         ret = regmap_update_bits(power->regmap, AXP20X_VBUS_MON,
0606                      AXP20X_VBUS_MON_VBUS_VALID,
0607                      AXP20X_VBUS_MON_VBUS_VALID);
0608         if (ret)
0609             return ret;
0610
0611         if (IS_ENABLED(CONFIG_AXP20X_ADC))
0612             ret = configure_iio_channels(pdev, power);
0613         else
0614             ret = configure_adc_registers(power);
0615
0616         if (ret)
0617             return ret;
0618     }
0619
0620     if (power->axp20x_id == AXP813_ID) {
0621         /* Enable USB Battery Charging specification detection */
0622         ret = regmap_update_bits(axp20x->regmap, AXP288_BC_GLOBAL,
0623                    AXP813_BC_EN, AXP813_BC_EN);
0624         if (ret)
0625             return ret;
0626     }
0627
0628     psy_cfg.of_node = pdev->dev.of_node;
0629     psy_cfg.drv_data = power;
0630
0631     power->supply = devm_power_supply_register(&pdev->dev,
0632                            axp_data->power_desc,
0633                            &psy_cfg);
0634     if (IS_ERR(power->supply))
0635         return PTR_ERR(power->supply);
0636
0637     /* Request irqs after registering, as irqs may trigger immediately */
0638     for (i = 0; i < axp_data->num_irq_names; i++) {
0639         irq = platform_get_irq_byname(pdev, axp_data->irq_names[i]);
0640         if (irq < 0)
0641             return irq;
0642
0643         power->irqs[i] = regmap_irq_get_virq(axp20x->regmap_irqc, irq);
0644         ret = devm_request_any_context_irq(&pdev->dev, power->irqs[i],
0645                            axp20x_usb_power_irq, 0,
0646                            DRVNAME, power);
0647         if (ret < 0) {
0648             dev_err(&pdev->dev, "Error requesting %s IRQ: %d\n",
0649                 axp_data->irq_names[i], ret);
0650             return ret;
0651         }
0652     }
0653
0654     if (axp20x_usb_vbus_needs_polling(power))
0655         queue_delayed_work(system_power_efficient_wq, &power->vbus_detect, 0);
0656
0657     return 0;
0658 }
0659
0660 static const struct of_device_id axp20x_usb_power_match[] = {
0661     {
0662         .compatible = "x-powers,axp202-usb-power-supply",
0663         .data = &axp202_data,
0664     }, {
0665         .compatible = "x-powers,axp221-usb-power-supply",
0666         .data = &axp221_data,
0667     }, {
0668         .compatible = "x-powers,axp223-usb-power-supply",
0669         .data = &axp223_data,
0670     }, {
0671         .compatible = "x-powers,axp813-usb-power-supply",
0672         .data = &axp813_data,
0673     }, { /* sentinel */ }
0674 };
0675 MODULE_DEVICE_TABLE(of, axp20x_usb_power_match);
0676
0677 static struct platform_driver axp20x_usb_power_driver = {
0678     .probe = axp20x_usb_power_probe,
0679     .driver = {
0680         .name       = DRVNAME,
0681         .of_match_table = axp20x_usb_power_match,
0682         .pm     = &axp20x_usb_power_pm_ops,
0683     },
0684 };
0685
0686 module_platform_driver(axp20x_usb_power_driver);
0687
0688 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
0689 MODULE_DESCRIPTION("AXP20x PMIC USB power supply status driver");
0690 MODULE_LICENSE("GPL");