power/supply/cpcap-charger.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Motorola CPCAP PMIC battery charger driver
0004  *
0005  * Copyright (C) 2017 Tony Lindgren <tony@atomide.com>
0006  *
0007  * Rewritten for Linux power framework with some parts based on
0008  * on earlier driver found in the Motorola Linux kernel:
0009  *
0010  * Copyright (C) 2009-2010 Motorola, Inc.
0011  */
0012
0013 #include <linux/atomic.h>
0014 #include <linux/init.h>
0015 #include <linux/module.h>
0016 #include <linux/slab.h>
0017 #include <linux/err.h>
0018 #include <linux/interrupt.h>
0019 #include <linux/notifier.h>
0020 #include <linux/of.h>
0021 #include <linux/of_platform.h>
0022 #include <linux/platform_device.h>
0023 #include <linux/power_supply.h>
0024 #include <linux/regmap.h>
0025
0026 #include <linux/gpio/consumer.h>
0027 #include <linux/usb/phy_companion.h>
0028 #include <linux/phy/omap_usb.h>
0029 #include <linux/usb/otg.h>
0030 #include <linux/iio/consumer.h>
0031 #include <linux/mfd/motorola-cpcap.h>
0032
0033 /*
0034  * CPCAP_REG_CRM register bits. For documentation of somewhat similar hardware,
0035  * see NXP "MC13783 Power Management and Audio Circuit Users's Guide"
0036  * MC13783UG.pdf chapter "8.5 Battery Interface Register Summary". The registers
0037  * and values for CPCAP are different, but some of the internal components seem
0038  * similar. Also see the Motorola Linux kernel cpcap-regbits.h. CPCAP_REG_CHRGR_1
0039  * bits that seem to describe the CRM register.
0040  */
0041 #define CPCAP_REG_CRM_UNUSED_641_15 BIT(15) /* 641 = register number */
0042 #define CPCAP_REG_CRM_UNUSED_641_14 BIT(14) /* 641 = register number */
0043 #define CPCAP_REG_CRM_CHRG_LED_EN   BIT(13) /* Charger LED */
0044 #define CPCAP_REG_CRM_RVRSMODE      BIT(12) /* USB VBUS output enable */
0045 #define CPCAP_REG_CRM_ICHRG_TR1     BIT(11) /* Trickle charge current */
0046 #define CPCAP_REG_CRM_ICHRG_TR0     BIT(10)
0047 #define CPCAP_REG_CRM_FET_OVRD      BIT(9)  /* 0 = hardware, 1 = FET_CTRL */
0048 #define CPCAP_REG_CRM_FET_CTRL      BIT(8)  /* BPFET 1 if FET_OVRD set */
0049 #define CPCAP_REG_CRM_VCHRG3        BIT(7)  /* Charge voltage bits */
0050 #define CPCAP_REG_CRM_VCHRG2        BIT(6)
0051 #define CPCAP_REG_CRM_VCHRG1        BIT(5)
0052 #define CPCAP_REG_CRM_VCHRG0        BIT(4)
0053 #define CPCAP_REG_CRM_ICHRG3        BIT(3)  /* Charge current bits */
0054 #define CPCAP_REG_CRM_ICHRG2        BIT(2)
0055 #define CPCAP_REG_CRM_ICHRG1        BIT(1)
0056 #define CPCAP_REG_CRM_ICHRG0        BIT(0)
0057
0058 /* CPCAP_REG_CRM trickle charge voltages */
0059 #define CPCAP_REG_CRM_TR(val)       (((val) & 0x3) << 10)
0060 #define CPCAP_REG_CRM_TR_0A00       CPCAP_REG_CRM_TR(0x0)
0061 #define CPCAP_REG_CRM_TR_0A24       CPCAP_REG_CRM_TR(0x1)
0062 #define CPCAP_REG_CRM_TR_0A48       CPCAP_REG_CRM_TR(0x2)
0063 #define CPCAP_REG_CRM_TR_0A72       CPCAP_REG_CRM_TR(0x4)
0064
0065 /*
0066  * CPCAP_REG_CRM charge voltages based on the ADC channel 1 values.
0067  * Note that these register bits don't match MC13783UG.pdf VCHRG
0068  * register bits.
0069  */
0070 #define CPCAP_REG_CRM_VCHRG(val)    (((val) & 0xf) << 4)
0071 #define CPCAP_REG_CRM_VCHRG_3V80    CPCAP_REG_CRM_VCHRG(0x0)
0072 #define CPCAP_REG_CRM_VCHRG_4V10    CPCAP_REG_CRM_VCHRG(0x1)
0073 #define CPCAP_REG_CRM_VCHRG_4V12    CPCAP_REG_CRM_VCHRG(0x2)
0074 #define CPCAP_REG_CRM_VCHRG_4V15    CPCAP_REG_CRM_VCHRG(0x3)
0075 #define CPCAP_REG_CRM_VCHRG_4V17    CPCAP_REG_CRM_VCHRG(0x4)
0076 #define CPCAP_REG_CRM_VCHRG_4V20    CPCAP_REG_CRM_VCHRG(0x5)
0077 #define CPCAP_REG_CRM_VCHRG_4V23    CPCAP_REG_CRM_VCHRG(0x6)
0078 #define CPCAP_REG_CRM_VCHRG_4V25    CPCAP_REG_CRM_VCHRG(0x7)
0079 #define CPCAP_REG_CRM_VCHRG_4V27    CPCAP_REG_CRM_VCHRG(0x8)
0080 #define CPCAP_REG_CRM_VCHRG_4V30    CPCAP_REG_CRM_VCHRG(0x9)
0081 #define CPCAP_REG_CRM_VCHRG_4V33    CPCAP_REG_CRM_VCHRG(0xa)
0082 #define CPCAP_REG_CRM_VCHRG_4V35    CPCAP_REG_CRM_VCHRG(0xb)
0083 #define CPCAP_REG_CRM_VCHRG_4V38    CPCAP_REG_CRM_VCHRG(0xc)
0084 #define CPCAP_REG_CRM_VCHRG_4V40    CPCAP_REG_CRM_VCHRG(0xd)
0085 #define CPCAP_REG_CRM_VCHRG_4V42    CPCAP_REG_CRM_VCHRG(0xe)
0086 #define CPCAP_REG_CRM_VCHRG_4V44    CPCAP_REG_CRM_VCHRG(0xf)
0087
0088 /*
0089  * CPCAP_REG_CRM charge currents. These seem to match MC13783UG.pdf
0090  * values in "Table 8-3. Charge Path Regulator Current Limit
0091  * Characteristics" for the nominal values.
0092  *
0093  * Except 70mA and 1.596A and unlimited, these are simply 88.7mA / step.
0094  */
0095 #define CPCAP_REG_CRM_ICHRG(val)    (((val) & 0xf) << 0)
0096 #define CPCAP_REG_CRM_ICHRG_0A000   CPCAP_REG_CRM_ICHRG(0x0)
0097 #define CPCAP_REG_CRM_ICHRG_0A070   CPCAP_REG_CRM_ICHRG(0x1)
0098 #define CPCAP_REG_CRM_ICHRG_0A177   CPCAP_REG_CRM_ICHRG(0x2)
0099 #define CPCAP_REG_CRM_ICHRG_0A266   CPCAP_REG_CRM_ICHRG(0x3)
0100 #define CPCAP_REG_CRM_ICHRG_0A355   CPCAP_REG_CRM_ICHRG(0x4)
0101 #define CPCAP_REG_CRM_ICHRG_0A443   CPCAP_REG_CRM_ICHRG(0x5)
0102 #define CPCAP_REG_CRM_ICHRG_0A532   CPCAP_REG_CRM_ICHRG(0x6)
0103 #define CPCAP_REG_CRM_ICHRG_0A621   CPCAP_REG_CRM_ICHRG(0x7)
0104 #define CPCAP_REG_CRM_ICHRG_0A709   CPCAP_REG_CRM_ICHRG(0x8)
0105 #define CPCAP_REG_CRM_ICHRG_0A798   CPCAP_REG_CRM_ICHRG(0x9)
0106 #define CPCAP_REG_CRM_ICHRG_0A886   CPCAP_REG_CRM_ICHRG(0xa)
0107 #define CPCAP_REG_CRM_ICHRG_0A975   CPCAP_REG_CRM_ICHRG(0xb)
0108 #define CPCAP_REG_CRM_ICHRG_1A064   CPCAP_REG_CRM_ICHRG(0xc)
0109 #define CPCAP_REG_CRM_ICHRG_1A152   CPCAP_REG_CRM_ICHRG(0xd)
0110 #define CPCAP_REG_CRM_ICHRG_1A596   CPCAP_REG_CRM_ICHRG(0xe)
0111 #define CPCAP_REG_CRM_ICHRG_NO_LIMIT    CPCAP_REG_CRM_ICHRG(0xf)
0112
0113 /* CPCAP_REG_VUSBC register bits needed for VBUS */
0114 #define CPCAP_BIT_VBUS_SWITCH       BIT(0)  /* VBUS boost to 5V */
0115
0116 enum {
0117     CPCAP_CHARGER_IIO_BATTDET,
0118     CPCAP_CHARGER_IIO_VOLTAGE,
0119     CPCAP_CHARGER_IIO_VBUS,
0120     CPCAP_CHARGER_IIO_CHRG_CURRENT,
0121     CPCAP_CHARGER_IIO_BATT_CURRENT,
0122     CPCAP_CHARGER_IIO_NR,
0123 };
0124
0125 struct cpcap_charger_ddata {
0126     struct device *dev;
0127     struct regmap *reg;
0128     struct list_head irq_list;
0129     struct delayed_work detect_work;
0130     struct delayed_work vbus_work;
0131     struct gpio_desc *gpio[2];      /* gpio_reven0 & 1 */
0132
0133     struct iio_channel *channels[CPCAP_CHARGER_IIO_NR];
0134
0135     struct power_supply *usb;
0136
0137     struct phy_companion comparator;    /* For USB VBUS */
0138     unsigned int vbus_enabled:1;
0139     unsigned int feeding_vbus:1;
0140     atomic_t active;
0141
0142     int status;
0143     int voltage;
0144     int limit_current;
0145 };
0146
0147 struct cpcap_interrupt_desc {
0148     int irq;
0149     struct list_head node;
0150     const char *name;
0151 };
0152
0153 struct cpcap_charger_ints_state {
0154     bool chrg_det;
0155     bool rvrs_chrg;
0156     bool vbusov;
0157
0158     bool chrg_se1b;
0159     bool rvrs_mode;
0160     bool chrgcurr2;
0161     bool chrgcurr1;
0162     bool vbusvld;
0163
0164     bool battdetb;
0165 };
0166
0167 static enum power_supply_property cpcap_charger_props[] = {
0168     POWER_SUPPLY_PROP_STATUS,
0169     POWER_SUPPLY_PROP_ONLINE,
0170     POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
0171     POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
0172     POWER_SUPPLY_PROP_VOLTAGE_NOW,
0173     POWER_SUPPLY_PROP_CURRENT_NOW,
0174 };
0175
0176 static int cpcap_charger_get_charge_voltage(struct cpcap_charger_ddata *ddata)
0177 {
0178     struct iio_channel *channel;
0179     int error, value = 0;
0180
0181     channel = ddata->channels[CPCAP_CHARGER_IIO_VOLTAGE];
0182     error = iio_read_channel_processed(channel, &value);
0183     if (error < 0) {
0184         dev_warn(ddata->dev, "%s failed: %i\n", __func__, error);
0185
0186         return 0;
0187     }
0188
0189     return value;
0190 }
0191
0192 static int cpcap_charger_get_charge_current(struct cpcap_charger_ddata *ddata)
0193 {
0194     struct iio_channel *channel;
0195     int error, value = 0;
0196
0197     channel = ddata->channels[CPCAP_CHARGER_IIO_CHRG_CURRENT];
0198     error = iio_read_channel_processed(channel, &value);
0199     if (error < 0) {
0200         dev_warn(ddata->dev, "%s failed: %i\n", __func__, error);
0201
0202         return 0;
0203     }
0204
0205     return value;
0206 }
0207
0208 static int cpcap_charger_get_property(struct power_supply *psy,
0209                       enum power_supply_property psp,
0210                       union power_supply_propval *val)
0211 {
0212     struct cpcap_charger_ddata *ddata = dev_get_drvdata(psy->dev.parent);
0213
0214     switch (psp) {
0215     case POWER_SUPPLY_PROP_STATUS:
0216         val->intval = ddata->status;
0217         break;
0218     case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
0219         val->intval = ddata->limit_current;
0220         break;
0221     case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
0222         val->intval = ddata->voltage;
0223         break;
0224     case POWER_SUPPLY_PROP_VOLTAGE_NOW:
0225         if (ddata->status == POWER_SUPPLY_STATUS_CHARGING)
0226             val->intval = cpcap_charger_get_charge_voltage(ddata) *
0227                 1000;
0228         else
0229             val->intval = 0;
0230         break;
0231     case POWER_SUPPLY_PROP_CURRENT_NOW:
0232         if (ddata->status == POWER_SUPPLY_STATUS_CHARGING)
0233             val->intval = cpcap_charger_get_charge_current(ddata) *
0234                 1000;
0235         else
0236             val->intval = 0;
0237         break;
0238     case POWER_SUPPLY_PROP_ONLINE:
0239         val->intval = ddata->status == POWER_SUPPLY_STATUS_CHARGING;
0240         break;
0241     default:
0242         return -EINVAL;
0243     }
0244
0245     return 0;
0246 }
0247
0248 static int cpcap_charger_match_voltage(int voltage)
0249 {
0250     switch (voltage) {
0251     case 0 ... 4100000 - 1: return 3800000;
0252     case 4100000 ... 4120000 - 1: return 4100000;
0253     case 4120000 ... 4150000 - 1: return 4120000;
0254     case 4150000 ... 4170000 - 1: return 4150000;
0255     case 4170000 ... 4200000 - 1: return 4170000;
0256     case 4200000 ... 4230000 - 1: return 4200000;
0257     case 4230000 ... 4250000 - 1: return 4230000;
0258     case 4250000 ... 4270000 - 1: return 4250000;
0259     case 4270000 ... 4300000 - 1: return 4270000;
0260     case 4300000 ... 4330000 - 1: return 4300000;
0261     case 4330000 ... 4350000 - 1: return 4330000;
0262     case 4350000 ... 4380000 - 1: return 4350000;
0263     case 4380000 ... 4400000 - 1: return 4380000;
0264     case 4400000 ... 4420000 - 1: return 4400000;
0265     case 4420000 ... 4440000 - 1: return 4420000;
0266     case 4440000: return 4440000;
0267     default: return 0;
0268     }
0269 }
0270
0271 static int
0272 cpcap_charger_get_bat_const_charge_voltage(struct cpcap_charger_ddata *ddata)
0273 {
0274     union power_supply_propval prop;
0275     struct power_supply *battery;
0276     int voltage = ddata->voltage;
0277     int error;
0278
0279     battery = power_supply_get_by_name("battery");
0280     if (battery) {
0281         error = power_supply_get_property(battery,
0282                 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
0283                 &prop);
0284         if (!error)
0285             voltage = prop.intval;
0286
0287         power_supply_put(battery);
0288     }
0289
0290     return voltage;
0291 }
0292
0293 static int cpcap_charger_current_to_regval(int microamp)
0294 {
0295     int miliamp = microamp / 1000;
0296     int res;
0297
0298     if (miliamp < 0)
0299         return -EINVAL;
0300     if (miliamp < 70)
0301         return CPCAP_REG_CRM_ICHRG(0x0);
0302     if (miliamp < 177)
0303         return CPCAP_REG_CRM_ICHRG(0x1);
0304     if (miliamp >= 1596)
0305         return CPCAP_REG_CRM_ICHRG(0xe);
0306
0307     res = microamp / 88666;
0308     if (res > 0xd)
0309         res = 0xd;
0310     return CPCAP_REG_CRM_ICHRG(res);
0311 }
0312
0313 static int cpcap_charger_set_property(struct power_supply *psy,
0314                       enum power_supply_property psp,
0315                       const union power_supply_propval *val)
0316 {
0317     struct cpcap_charger_ddata *ddata = dev_get_drvdata(psy->dev.parent);
0318     int voltage, batvolt;
0319
0320     switch (psp) {
0321     case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
0322         if (cpcap_charger_current_to_regval(val->intval) < 0)
0323             return -EINVAL;
0324         ddata->limit_current = val->intval;
0325         schedule_delayed_work(&ddata->detect_work, 0);
0326         break;
0327     case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
0328         voltage = cpcap_charger_match_voltage(val->intval);
0329         batvolt = cpcap_charger_get_bat_const_charge_voltage(ddata);
0330         if (voltage > batvolt)
0331             voltage = batvolt;
0332         ddata->voltage = voltage;
0333         schedule_delayed_work(&ddata->detect_work, 0);
0334         break;
0335     default:
0336         return -EINVAL;
0337     }
0338
0339     return 0;
0340 }
0341
0342 static int cpcap_charger_property_is_writeable(struct power_supply *psy,
0343                            enum power_supply_property psp)
0344 {
0345     switch (psp) {
0346     case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
0347     case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
0348         return 1;
0349     default:
0350         return 0;
0351     }
0352 }
0353
0354 static void cpcap_charger_set_cable_path(struct cpcap_charger_ddata *ddata,
0355                      bool enabled)
0356 {
0357     if (!ddata->gpio[0])
0358         return;
0359
0360     gpiod_set_value(ddata->gpio[0], enabled);
0361 }
0362
0363 static void cpcap_charger_set_inductive_path(struct cpcap_charger_ddata *ddata,
0364                          bool enabled)
0365 {
0366     if (!ddata->gpio[1])
0367         return;
0368
0369     gpiod_set_value(ddata->gpio[1], enabled);
0370 }
0371
0372 static void cpcap_charger_update_state(struct cpcap_charger_ddata *ddata,
0373                        int state)
0374 {
0375     const char *status;
0376
0377     if (state > POWER_SUPPLY_STATUS_FULL) {
0378         dev_warn(ddata->dev, "unknown state: %i\n", state);
0379
0380         return;
0381     }
0382
0383     ddata->status = state;
0384
0385     switch (state) {
0386     case POWER_SUPPLY_STATUS_DISCHARGING:
0387         status = "DISCONNECTED";
0388         break;
0389     case POWER_SUPPLY_STATUS_NOT_CHARGING:
0390         status = "DETECTING";
0391         break;
0392     case POWER_SUPPLY_STATUS_CHARGING:
0393         status = "CHARGING";
0394         break;
0395     case POWER_SUPPLY_STATUS_FULL:
0396         status = "DONE";
0397         break;
0398     default:
0399         return;
0400     }
0401
0402     dev_dbg(ddata->dev, "state: %s\n", status);
0403 }
0404
0405 static int cpcap_charger_disable(struct cpcap_charger_ddata *ddata)
0406 {
0407     int error;
0408
0409     error = regmap_update_bits(ddata->reg, CPCAP_REG_CRM, 0x3fff,
0410                    CPCAP_REG_CRM_FET_OVRD |
0411                    CPCAP_REG_CRM_FET_CTRL);
0412     if (error)
0413         dev_err(ddata->dev, "%s failed with %i\n", __func__, error);
0414
0415     return error;
0416 }
0417
0418 static int cpcap_charger_enable(struct cpcap_charger_ddata *ddata,
0419                 int max_voltage, int charge_current,
0420                 int trickle_current)
0421 {
0422     int error;
0423
0424     if (!max_voltage || !charge_current)
0425         return -EINVAL;
0426
0427     dev_dbg(ddata->dev, "enable: %i %i %i\n",
0428         max_voltage, charge_current, trickle_current);
0429
0430     error = regmap_update_bits(ddata->reg, CPCAP_REG_CRM, 0x3fff,
0431                    CPCAP_REG_CRM_CHRG_LED_EN |
0432                    trickle_current |
0433                    CPCAP_REG_CRM_FET_OVRD |
0434                    CPCAP_REG_CRM_FET_CTRL |
0435                    max_voltage |
0436                    charge_current);
0437     if (error)
0438         dev_err(ddata->dev, "%s failed with %i\n", __func__, error);
0439
0440     return error;
0441 }
0442
0443 static bool cpcap_charger_vbus_valid(struct cpcap_charger_ddata *ddata)
0444 {
0445     int error, value = 0;
0446     struct iio_channel *channel =
0447         ddata->channels[CPCAP_CHARGER_IIO_VBUS];
0448
0449     error = iio_read_channel_processed(channel, &value);
0450     if (error >= 0)
0451         return value > 3900;
0452
0453     dev_err(ddata->dev, "error reading VBUS: %i\n", error);
0454
0455     return false;
0456 }
0457
0458 /* VBUS control functions for the USB PHY companion */
0459 static void cpcap_charger_vbus_work(struct work_struct *work)
0460 {
0461     struct cpcap_charger_ddata *ddata;
0462     bool vbus = false;
0463     int error;
0464
0465     ddata = container_of(work, struct cpcap_charger_ddata,
0466                  vbus_work.work);
0467
0468     if (ddata->vbus_enabled) {
0469         vbus = cpcap_charger_vbus_valid(ddata);
0470         if (vbus) {
0471             dev_dbg(ddata->dev, "VBUS already provided\n");
0472
0473             return;
0474         }
0475
0476         ddata->feeding_vbus = true;
0477         cpcap_charger_set_cable_path(ddata, false);
0478         cpcap_charger_set_inductive_path(ddata, false);
0479
0480         error = cpcap_charger_disable(ddata);
0481         if (error)
0482             goto out_err;
0483
0484         cpcap_charger_update_state(ddata,
0485                        POWER_SUPPLY_STATUS_DISCHARGING);
0486
0487         error = regmap_update_bits(ddata->reg, CPCAP_REG_VUSBC,
0488                        CPCAP_BIT_VBUS_SWITCH,
0489                        CPCAP_BIT_VBUS_SWITCH);
0490         if (error)
0491             goto out_err;
0492
0493         error = regmap_update_bits(ddata->reg, CPCAP_REG_CRM,
0494                        CPCAP_REG_CRM_RVRSMODE,
0495                        CPCAP_REG_CRM_RVRSMODE);
0496         if (error)
0497             goto out_err;
0498     } else {
0499         error = regmap_update_bits(ddata->reg, CPCAP_REG_VUSBC,
0500                        CPCAP_BIT_VBUS_SWITCH, 0);
0501         if (error)
0502             goto out_err;
0503
0504         error = regmap_update_bits(ddata->reg, CPCAP_REG_CRM,
0505                        CPCAP_REG_CRM_RVRSMODE, 0);
0506         if (error)
0507             goto out_err;
0508
0509         cpcap_charger_set_cable_path(ddata, true);
0510         cpcap_charger_set_inductive_path(ddata, true);
0511         ddata->feeding_vbus = false;
0512     }
0513
0514     return;
0515
0516 out_err:
0517     cpcap_charger_update_state(ddata, POWER_SUPPLY_STATUS_UNKNOWN);
0518     dev_err(ddata->dev, "%s could not %s vbus: %i\n", __func__,
0519         ddata->vbus_enabled ? "enable" : "disable", error);
0520 }
0521
0522 static int cpcap_charger_set_vbus(struct phy_companion *comparator,
0523                   bool enabled)
0524 {
0525     struct cpcap_charger_ddata *ddata =
0526         container_of(comparator, struct cpcap_charger_ddata,
0527                  comparator);
0528
0529     ddata->vbus_enabled = enabled;
0530     schedule_delayed_work(&ddata->vbus_work, 0);
0531
0532     return 0;
0533 }
0534
0535 /* Charger interrupt handling functions */
0536
0537 static int cpcap_charger_get_ints_state(struct cpcap_charger_ddata *ddata,
0538                     struct cpcap_charger_ints_state *s)
0539 {
0540     int val, error;
0541
0542     error = regmap_read(ddata->reg, CPCAP_REG_INTS1, &val);
0543     if (error)
0544         return error;
0545
0546     s->chrg_det = val & BIT(13);
0547     s->rvrs_chrg = val & BIT(12);
0548     s->vbusov = val & BIT(11);
0549
0550     error = regmap_read(ddata->reg, CPCAP_REG_INTS2, &val);
0551     if (error)
0552         return error;
0553
0554     s->chrg_se1b = val & BIT(13);
0555     s->rvrs_mode = val & BIT(6);
0556     s->chrgcurr2 = val & BIT(5);
0557     s->chrgcurr1 = val & BIT(4);
0558     s->vbusvld = val & BIT(3);
0559
0560     error = regmap_read(ddata->reg, CPCAP_REG_INTS4, &val);
0561     if (error)
0562         return error;
0563
0564     s->battdetb = val & BIT(6);
0565
0566     return 0;
0567 }
0568
0569 static int cpcap_charger_voltage_to_regval(int voltage)
0570 {
0571     int offset;
0572
0573     switch (voltage) {
0574     case 0 ... 4100000 - 1:
0575         return 0;
0576     case 4100000 ... 4200000 - 1:
0577         offset = 1;
0578         break;
0579     case 4200000 ... 4300000 - 1:
0580         offset = 0;
0581         break;
0582     case 4300000 ... 4380000 - 1:
0583         offset = -1;
0584         break;
0585     case 4380000 ... 4440000:
0586         offset = -2;
0587         break;
0588     default:
0589         return 0;
0590     }
0591
0592     return ((voltage - 4100000) / 20000) + offset;
0593 }
0594
0595 static void cpcap_charger_disconnect(struct cpcap_charger_ddata *ddata,
0596                      int state, unsigned long delay)
0597 {
0598     int error;
0599
0600     /* Update battery state before disconnecting the charger */
0601     switch (state) {
0602     case POWER_SUPPLY_STATUS_DISCHARGING:
0603     case POWER_SUPPLY_STATUS_FULL:
0604         power_supply_changed(ddata->usb);
0605         break;
0606     default:
0607         break;
0608     }
0609
0610     error = cpcap_charger_disable(ddata);
0611     if (error) {
0612         cpcap_charger_update_state(ddata, POWER_SUPPLY_STATUS_UNKNOWN);
0613         return;
0614     }
0615
0616     cpcap_charger_update_state(ddata, state);
0617     power_supply_changed(ddata->usb);
0618     schedule_delayed_work(&ddata->detect_work, delay);
0619 }
0620
0621 static void cpcap_usb_detect(struct work_struct *work)
0622 {
0623     struct cpcap_charger_ddata *ddata;
0624     struct cpcap_charger_ints_state s;
0625     int error, new_state;
0626
0627     ddata = container_of(work, struct cpcap_charger_ddata,
0628                  detect_work.work);
0629
0630     error = cpcap_charger_get_ints_state(ddata, &s);
0631     if (error)
0632         return;
0633
0634     /* Just init the state if a charger is connected with no chrg_det set */
0635     if (!s.chrg_det && s.chrgcurr1 && s.vbusvld) {
0636         cpcap_charger_update_state(ddata,
0637                        POWER_SUPPLY_STATUS_NOT_CHARGING);
0638
0639         return;
0640     }
0641
0642     /*
0643      * If battery voltage is higher than charge voltage, it may have been
0644      * charged to 4.35V by Android. Try again in 10 minutes.
0645      */
0646     if (cpcap_charger_get_charge_voltage(ddata) > ddata->voltage) {
0647         cpcap_charger_disconnect(ddata,
0648                      POWER_SUPPLY_STATUS_NOT_CHARGING,
0649                      HZ * 60 * 10);
0650
0651         return;
0652     }
0653
0654     /* Delay for 80ms to avoid vbus bouncing when usb cable is plugged in */
0655     usleep_range(80000, 120000);
0656
0657     /* Throttle chrgcurr2 interrupt for charger done and retry */
0658     switch (ddata->status) {
0659     case POWER_SUPPLY_STATUS_CHARGING:
0660         if (s.chrgcurr2)
0661             break;
0662         new_state = POWER_SUPPLY_STATUS_FULL;
0663
0664         if (s.chrgcurr1 && s.vbusvld) {
0665             cpcap_charger_disconnect(ddata, new_state, HZ * 5);
0666             return;
0667         }
0668         break;
0669     case POWER_SUPPLY_STATUS_FULL:
0670         if (!s.chrgcurr2)
0671             break;
0672         if (s.vbusvld)
0673             new_state = POWER_SUPPLY_STATUS_NOT_CHARGING;
0674         else
0675             new_state = POWER_SUPPLY_STATUS_DISCHARGING;
0676
0677         cpcap_charger_disconnect(ddata, new_state, HZ * 5);
0678
0679         return;
0680     default:
0681         break;
0682     }
0683
0684     if (!ddata->feeding_vbus && cpcap_charger_vbus_valid(ddata) &&
0685         s.chrgcurr1) {
0686         int max_current;
0687         int vchrg, ichrg;
0688         union power_supply_propval val;
0689         struct power_supply *battery;
0690
0691         battery = power_supply_get_by_name("battery");
0692         if (IS_ERR_OR_NULL(battery)) {
0693             dev_err(ddata->dev, "battery power_supply not available %li\n",
0694                     PTR_ERR(battery));
0695             return;
0696         }
0697
0698         error = power_supply_get_property(battery, POWER_SUPPLY_PROP_PRESENT, &val);
0699         power_supply_put(battery);
0700         if (error)
0701             goto out_err;
0702
0703         if (val.intval) {
0704             max_current = 1596000;
0705         } else {
0706             dev_info(ddata->dev, "battery not inserted, charging disabled\n");
0707             max_current = 0;
0708         }
0709
0710         if (max_current > ddata->limit_current)
0711             max_current = ddata->limit_current;
0712
0713         ichrg = cpcap_charger_current_to_regval(max_current);
0714         vchrg = cpcap_charger_voltage_to_regval(ddata->voltage);
0715         error = cpcap_charger_enable(ddata,
0716                          CPCAP_REG_CRM_VCHRG(vchrg),
0717                          ichrg, 0);
0718         if (error)
0719             goto out_err;
0720         cpcap_charger_update_state(ddata,
0721                        POWER_SUPPLY_STATUS_CHARGING);
0722     } else {
0723         error = cpcap_charger_disable(ddata);
0724         if (error)
0725             goto out_err;
0726         cpcap_charger_update_state(ddata,
0727                        POWER_SUPPLY_STATUS_DISCHARGING);
0728     }
0729
0730     power_supply_changed(ddata->usb);
0731     return;
0732
0733 out_err:
0734     cpcap_charger_update_state(ddata, POWER_SUPPLY_STATUS_UNKNOWN);
0735     dev_err(ddata->dev, "%s failed with %i\n", __func__, error);
0736 }
0737
0738 static irqreturn_t cpcap_charger_irq_thread(int irq, void *data)
0739 {
0740     struct cpcap_charger_ddata *ddata = data;
0741
0742     if (!atomic_read(&ddata->active))
0743         return IRQ_NONE;
0744
0745     schedule_delayed_work(&ddata->detect_work, 0);
0746
0747     return IRQ_HANDLED;
0748 }
0749
0750 static int cpcap_usb_init_irq(struct platform_device *pdev,
0751                   struct cpcap_charger_ddata *ddata,
0752                   const char *name)
0753 {
0754     struct cpcap_interrupt_desc *d;
0755     int irq, error;
0756
0757     irq = platform_get_irq_byname(pdev, name);
0758     if (irq < 0)
0759         return -ENODEV;
0760
0761     error = devm_request_threaded_irq(ddata->dev, irq, NULL,
0762                       cpcap_charger_irq_thread,
0763                       IRQF_SHARED | IRQF_ONESHOT,
0764                       name, ddata);
0765     if (error) {
0766         dev_err(ddata->dev, "could not get irq %s: %i\n",
0767             name, error);
0768
0769         return error;
0770     }
0771
0772     d = devm_kzalloc(ddata->dev, sizeof(*d), GFP_KERNEL);
0773     if (!d)
0774         return -ENOMEM;
0775
0776     d->name = name;
0777     d->irq = irq;
0778     list_add(&d->node, &ddata->irq_list);
0779
0780     return 0;
0781 }
0782
0783 static const char * const cpcap_charger_irqs[] = {
0784     /* REG_INT_0 */
0785     "chrg_det", "rvrs_chrg",
0786
0787     /* REG_INT1 */
0788     "chrg_se1b", "se0conn", "rvrs_mode", "chrgcurr2", "chrgcurr1", "vbusvld",
0789
0790     /* REG_INT_3 */
0791     "battdetb",
0792 };
0793
0794 static int cpcap_usb_init_interrupts(struct platform_device *pdev,
0795                      struct cpcap_charger_ddata *ddata)
0796 {
0797     int i, error;
0798
0799     for (i = 0; i < ARRAY_SIZE(cpcap_charger_irqs); i++) {
0800         error = cpcap_usb_init_irq(pdev, ddata, cpcap_charger_irqs[i]);
0801         if (error)
0802             return error;
0803     }
0804
0805     return 0;
0806 }
0807
0808 static void cpcap_charger_init_optional_gpios(struct cpcap_charger_ddata *ddata)
0809 {
0810     int i;
0811
0812     for (i = 0; i < 2; i++) {
0813         ddata->gpio[i] = devm_gpiod_get_index(ddata->dev, "mode",
0814                               i, GPIOD_OUT_HIGH);
0815         if (IS_ERR(ddata->gpio[i])) {
0816             dev_info(ddata->dev, "no mode change GPIO%i: %li\n",
0817                  i, PTR_ERR(ddata->gpio[i]));
0818             ddata->gpio[i] = NULL;
0819         }
0820     }
0821 }
0822
0823 static int cpcap_charger_init_iio(struct cpcap_charger_ddata *ddata)
0824 {
0825     const char * const names[CPCAP_CHARGER_IIO_NR] = {
0826         "battdetb", "battp", "vbus", "chg_isense", "batti",
0827     };
0828     int error, i;
0829
0830     for (i = 0; i < CPCAP_CHARGER_IIO_NR; i++) {
0831         ddata->channels[i] = devm_iio_channel_get(ddata->dev,
0832                               names[i]);
0833         if (IS_ERR(ddata->channels[i])) {
0834             error = PTR_ERR(ddata->channels[i]);
0835             goto out_err;
0836         }
0837
0838         if (!ddata->channels[i]->indio_dev) {
0839             error = -ENXIO;
0840             goto out_err;
0841         }
0842     }
0843
0844     return 0;
0845
0846 out_err:
0847     if (error != -EPROBE_DEFER)
0848         dev_err(ddata->dev, "could not initialize VBUS or ID IIO: %i\n",
0849             error);
0850
0851     return error;
0852 }
0853
0854 static char *cpcap_charger_supplied_to[] = {
0855     "battery",
0856 };
0857
0858 static const struct power_supply_desc cpcap_charger_usb_desc = {
0859     .name       = "usb",
0860     .type       = POWER_SUPPLY_TYPE_USB,
0861     .properties = cpcap_charger_props,
0862     .num_properties = ARRAY_SIZE(cpcap_charger_props),
0863     .get_property   = cpcap_charger_get_property,
0864     .set_property   = cpcap_charger_set_property,
0865     .property_is_writeable = cpcap_charger_property_is_writeable,
0866 };
0867
0868 #ifdef CONFIG_OF
0869 static const struct of_device_id cpcap_charger_id_table[] = {
0870     {
0871         .compatible = "motorola,mapphone-cpcap-charger",
0872     },
0873     {},
0874 };
0875 MODULE_DEVICE_TABLE(of, cpcap_charger_id_table);
0876 #endif
0877
0878 static int cpcap_charger_probe(struct platform_device *pdev)
0879 {
0880     struct cpcap_charger_ddata *ddata;
0881     const struct of_device_id *of_id;
0882     struct power_supply_config psy_cfg = {};
0883     int error;
0884
0885     of_id = of_match_device(of_match_ptr(cpcap_charger_id_table),
0886                 &pdev->dev);
0887     if (!of_id)
0888         return -EINVAL;
0889
0890     ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL);
0891     if (!ddata)
0892         return -ENOMEM;
0893
0894     ddata->dev = &pdev->dev;
0895     ddata->voltage = 4200000;
0896     ddata->limit_current = 532000;
0897
0898     ddata->reg = dev_get_regmap(ddata->dev->parent, NULL);
0899     if (!ddata->reg)
0900         return -ENODEV;
0901
0902     INIT_LIST_HEAD(&ddata->irq_list);
0903     INIT_DELAYED_WORK(&ddata->detect_work, cpcap_usb_detect);
0904     INIT_DELAYED_WORK(&ddata->vbus_work, cpcap_charger_vbus_work);
0905     platform_set_drvdata(pdev, ddata);
0906
0907     error = cpcap_charger_init_iio(ddata);
0908     if (error)
0909         return error;
0910
0911     atomic_set(&ddata->active, 1);
0912
0913     psy_cfg.of_node = pdev->dev.of_node;
0914     psy_cfg.drv_data = ddata;
0915     psy_cfg.supplied_to = cpcap_charger_supplied_to;
0916     psy_cfg.num_supplicants = ARRAY_SIZE(cpcap_charger_supplied_to),
0917
0918     ddata->usb = devm_power_supply_register(ddata->dev,
0919                         &cpcap_charger_usb_desc,
0920                         &psy_cfg);
0921     if (IS_ERR(ddata->usb)) {
0922         error = PTR_ERR(ddata->usb);
0923         dev_err(ddata->dev, "failed to register USB charger: %i\n",
0924             error);
0925
0926         return error;
0927     }
0928
0929     error = cpcap_usb_init_interrupts(pdev, ddata);
0930     if (error)
0931         return error;
0932
0933     ddata->comparator.set_vbus = cpcap_charger_set_vbus;
0934     error = omap_usb2_set_comparator(&ddata->comparator);
0935     if (error == -ENODEV) {
0936         dev_info(ddata->dev, "charger needs phy, deferring probe\n");
0937         return -EPROBE_DEFER;
0938     }
0939
0940     cpcap_charger_init_optional_gpios(ddata);
0941
0942     schedule_delayed_work(&ddata->detect_work, 0);
0943
0944     return 0;
0945 }
0946
0947 static void cpcap_charger_shutdown(struct platform_device *pdev)
0948 {
0949     struct cpcap_charger_ddata *ddata = platform_get_drvdata(pdev);
0950     int error;
0951
0952     atomic_set(&ddata->active, 0);
0953     error = omap_usb2_set_comparator(NULL);
0954     if (error)
0955         dev_warn(ddata->dev, "could not clear USB comparator: %i\n",
0956              error);
0957
0958     error = cpcap_charger_disable(ddata);
0959     if (error) {
0960         cpcap_charger_update_state(ddata, POWER_SUPPLY_STATUS_UNKNOWN);
0961         dev_warn(ddata->dev, "could not clear charger: %i\n",
0962              error);
0963     }
0964     cpcap_charger_update_state(ddata, POWER_SUPPLY_STATUS_DISCHARGING);
0965     cancel_delayed_work_sync(&ddata->vbus_work);
0966     cancel_delayed_work_sync(&ddata->detect_work);
0967 }
0968
0969 static int cpcap_charger_remove(struct platform_device *pdev)
0970 {
0971     cpcap_charger_shutdown(pdev);
0972
0973     return 0;
0974 }
0975
0976 static struct platform_driver cpcap_charger_driver = {
0977     .probe = cpcap_charger_probe,
0978     .driver = {
0979         .name   = "cpcap-charger",
0980         .of_match_table = of_match_ptr(cpcap_charger_id_table),
0981     },
0982     .shutdown = cpcap_charger_shutdown,
0983     .remove = cpcap_charger_remove,
0984 };
0985 module_platform_driver(cpcap_charger_driver);
0986
0987 MODULE_AUTHOR("Tony Lindgren <tony@atomide.com>");
0988 MODULE_DESCRIPTION("CPCAP Battery Charger Interface driver");
0989 MODULE_LICENSE("GPL v2");
0990 MODULE_ALIAS("platform:cpcap-charger");