drivers/power/supply/mp2629_charger.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * MP2629 battery charger driver
   4  *
   5  * Copyright 2020 Monolithic Power Systems, Inc
   6  *
   7  * Author: Saravanan Sekar <sravanhome@gmail.com>
   8  */
   9
  10 #include <linux/bits.h>
  11 #include <linux/iio/consumer.h>
  12 #include <linux/iio/types.h>
  13 #include <linux/interrupt.h>
  14 #include <linux/mfd/mp2629.h>
  15 #include <linux/module.h>
  16 #include <linux/mod_devicetable.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/power_supply.h>
  19 #include <linux/regmap.h>
  20
  21 #define MP2629_REG_INPUT_ILIM           0x00
  22 #define MP2629_REG_INPUT_VLIM           0x01
  23 #define MP2629_REG_CHARGE_CTRL          0x04
  24 #define MP2629_REG_CHARGE_ILIM          0x05
  25 #define MP2629_REG_PRECHARGE            0x06
  26 #define MP2629_REG_TERM_CURRENT         0x06
  27 #define MP2629_REG_CHARGE_VLIM          0x07
  28 #define MP2629_REG_TIMER_CTRL           0x08
  29 #define MP2629_REG_IMPEDANCE_COMP       0x09
  30 #define MP2629_REG_INTERRUPT            0x0b
  31 #define MP2629_REG_STATUS               0x0c
  32 #define MP2629_REG_FAULT                0x0d
  33
  34 #define MP2629_MASK_INPUT_TYPE          GENMASK(7, 5)
  35 #define MP2629_MASK_CHARGE_TYPE         GENMASK(4, 3)
  36 #define MP2629_MASK_CHARGE_CTRL         GENMASK(5, 4)
  37 #define MP2629_MASK_WDOG_CTRL           GENMASK(5, 4)
  38 #define MP2629_MASK_IMPEDANCE           GENMASK(7, 4)
  39
  40 #define MP2629_INPUTSOURCE_CHANGE       GENMASK(7, 5)
  41 #define MP2629_CHARGING_CHANGE          GENMASK(4, 3)
  42 #define MP2629_FAULT_BATTERY            BIT(3)
  43 #define MP2629_FAULT_THERMAL            BIT(4)
  44 #define MP2629_FAULT_INPUT              BIT(5)
  45 #define MP2629_FAULT_OTG                BIT(6)
  46
  47 #define MP2629_MAX_BATT_CAPACITY        100
  48
  49 #define MP2629_PROPS(_idx, _min, _max, _step)           \
  50         [_idx] = {                                      \
  51                 .min    = _min,                         \
  52                 .max    = _max,                         \
  53                 .step   = _step,                        \
  54 }
  55
  56 enum mp2629_source_type {
  57         MP2629_SOURCE_TYPE_NO_INPUT,
  58         MP2629_SOURCE_TYPE_NON_STD,
  59         MP2629_SOURCE_TYPE_SDP,
  60         MP2629_SOURCE_TYPE_CDP,
  61         MP2629_SOURCE_TYPE_DCP,
  62         MP2629_SOURCE_TYPE_OTG = 7,
  63 };
  64
  65 enum mp2629_field {
  66         INPUT_ILIM,
  67         INPUT_VLIM,
  68         CHARGE_ILIM,
  69         CHARGE_VLIM,
  70         PRECHARGE,
  71         TERM_CURRENT,
  72         MP2629_MAX_FIELD
  73 };
  74
  75 struct mp2629_charger {
  76         struct device *dev;
  77         int status;
  78         int fault;
  79
  80         struct regmap *regmap;
  81         struct regmap_field *regmap_fields[MP2629_MAX_FIELD];
  82         struct mutex lock;
  83         struct power_supply *usb;
  84         struct power_supply *battery;
  85         struct iio_channel *iiochan[MP2629_ADC_CHAN_END];
  86 };
  87
  88 struct mp2629_prop {
  89         int reg;
  90         int mask;
  91         int min;
  92         int max;
  93         int step;
  94         int shift;
  95 };
  96
  97 static enum power_supply_usb_type mp2629_usb_types[] = {
  98         POWER_SUPPLY_USB_TYPE_SDP,
  99         POWER_SUPPLY_USB_TYPE_DCP,
 100         POWER_SUPPLY_USB_TYPE_CDP,
 101         POWER_SUPPLY_USB_TYPE_PD_DRP,
 102         POWER_SUPPLY_USB_TYPE_UNKNOWN
 103 };
 104
 105 static enum power_supply_property mp2629_charger_usb_props[] = {
 106         POWER_SUPPLY_PROP_ONLINE,
 107         POWER_SUPPLY_PROP_USB_TYPE,
 108         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 109         POWER_SUPPLY_PROP_CURRENT_NOW,
 110         POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
 111         POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT,
 112 };
 113
 114 static enum power_supply_property mp2629_charger_bat_props[] = {
 115         POWER_SUPPLY_PROP_STATUS,
 116         POWER_SUPPLY_PROP_HEALTH,
 117         POWER_SUPPLY_PROP_CHARGE_TYPE,
 118         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 119         POWER_SUPPLY_PROP_CURRENT_NOW,
 120         POWER_SUPPLY_PROP_CAPACITY,
 121         POWER_SUPPLY_PROP_PRECHARGE_CURRENT,
 122         POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT,
 123         POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
 124         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
 125         POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
 126         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
 127 };
 128
 129 static struct mp2629_prop props[] = {
 130         MP2629_PROPS(INPUT_ILIM, 100000, 3250000, 50000),
 131         MP2629_PROPS(INPUT_VLIM, 3800000, 5300000, 100000),
 132         MP2629_PROPS(CHARGE_ILIM, 320000, 4520000, 40000),
 133         MP2629_PROPS(CHARGE_VLIM, 3400000, 4670000, 10000),
 134         MP2629_PROPS(PRECHARGE, 120000, 720000, 40000),
 135         MP2629_PROPS(TERM_CURRENT, 80000, 680000, 40000),
 136 };
 137
 138 static const struct reg_field mp2629_reg_fields[] = {
 139         [INPUT_ILIM]    = REG_FIELD(MP2629_REG_INPUT_ILIM, 0, 5),
 140         [INPUT_VLIM]    = REG_FIELD(MP2629_REG_INPUT_VLIM, 0, 3),
 141         [CHARGE_ILIM]   = REG_FIELD(MP2629_REG_CHARGE_ILIM, 0, 6),
 142         [CHARGE_VLIM]   = REG_FIELD(MP2629_REG_CHARGE_VLIM, 1, 7),
 143         [PRECHARGE]     = REG_FIELD(MP2629_REG_PRECHARGE, 4, 7),
 144         [TERM_CURRENT]  = REG_FIELD(MP2629_REG_TERM_CURRENT, 0, 3),
 145 };
 146
 147 static char *adc_chan_name[] = {
 148         "mp2629-batt-volt",
 149         "mp2629-system-volt",
 150         "mp2629-input-volt",
 151         "mp2629-batt-current",
 152         "mp2629-input-current",
 153 };
 154
 155 static int mp2629_read_adc(struct mp2629_charger *charger,
 156                            enum mp2629_adc_chan ch,
 157                            union power_supply_propval *val)
 158 {
 159         int ret;
 160         int chval;
 161
 162         ret = iio_read_channel_processed(charger->iiochan[ch], &chval);
 163         if (ret)
 164                 return ret;
 165
 166         val->intval = chval * 1000;
 167
 168         return 0;
 169 }
 170
 171 static int mp2629_get_prop(struct mp2629_charger *charger,
 172                            enum mp2629_field fld,
 173                            union power_supply_propval *val)
 174 {
 175         int ret;
 176         unsigned int rval;
 177
 178         ret = regmap_field_read(charger->regmap_fields[fld], &rval);
 179         if (ret)
 180                 return ret;
 181
 182         val->intval = rval * props[fld].step + props[fld].min;
 183
 184         return 0;
 185 }
 186
 187 static int mp2629_set_prop(struct mp2629_charger *charger,
 188                            enum mp2629_field fld,
 189                            const union power_supply_propval *val)
 190 {
 191         unsigned int rval;
 192
 193         if (val->intval < props[fld].min || val->intval > props[fld].max)
 194                 return -EINVAL;
 195
 196         rval = (val->intval - props[fld].min) / props[fld].step;
 197         return regmap_field_write(charger->regmap_fields[fld], rval);
 198 }
 199
 200 static int mp2629_get_battery_capacity(struct mp2629_charger *charger,
 201                                        union power_supply_propval *val)
 202 {
 203         union power_supply_propval vnow, vlim;
 204         int ret;
 205
 206         ret = mp2629_read_adc(charger, MP2629_BATT_VOLT, &vnow);
 207         if (ret)
 208                 return ret;
 209
 210         ret = mp2629_get_prop(charger, CHARGE_VLIM, &vlim);
 211         if (ret)
 212                 return ret;
 213
 214         val->intval = (vnow.intval * 100) / vlim.intval;
 215         val->intval = min(val->intval, MP2629_MAX_BATT_CAPACITY);
 216
 217         return 0;
 218 }
 219
 220 static int mp2629_charger_battery_get_prop(struct power_supply *psy,
 221                                         enum power_supply_property psp,
 222                                         union power_supply_propval *val)
 223 {
 224         struct mp2629_charger *charger = dev_get_drvdata(psy->dev.parent);
 225         unsigned int rval;
 226         int ret = 0;
 227
 228         switch (psp) {
 229         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 230                 ret = mp2629_read_adc(charger, MP2629_BATT_VOLT, val);
 231                 break;
 232
 233         case POWER_SUPPLY_PROP_CURRENT_NOW:
 234                 ret = mp2629_read_adc(charger, MP2629_BATT_CURRENT, val);
 235                 break;
 236
 237         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
 238                 val->intval = 4520000;
 239                 break;
 240
 241         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
 242                 val->intval = 4670000;
 243                 break;
 244
 245         case POWER_SUPPLY_PROP_CAPACITY:
 246                 ret = mp2629_get_battery_capacity(charger, val);
 247                 break;
 248
 249         case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
 250                 ret = mp2629_get_prop(charger, TERM_CURRENT, val);
 251                 break;
 252
 253         case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
 254                 ret = mp2629_get_prop(charger, PRECHARGE, val);
 255                 break;
 256
 257         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
 258                 ret = mp2629_get_prop(charger, CHARGE_VLIM, val);
 259                 break;
 260
 261         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
 262                 ret = mp2629_get_prop(charger, CHARGE_ILIM, val);
 263                 break;
 264
 265         case POWER_SUPPLY_PROP_HEALTH:
 266                 if (!charger->fault)
 267                         val->intval = POWER_SUPPLY_HEALTH_GOOD;
 268                 if (MP2629_FAULT_BATTERY & charger->fault)
 269                         val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
 270                 else if (MP2629_FAULT_THERMAL & charger->fault)
 271                         val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
 272                 else if (MP2629_FAULT_INPUT & charger->fault)
 273                         val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
 274                 break;
 275
 276         case POWER_SUPPLY_PROP_STATUS:
 277                 ret = regmap_read(charger->regmap, MP2629_REG_STATUS, &rval);
 278                 if (ret)
 279                         break;
 280
 281                 rval = (rval & MP2629_MASK_CHARGE_TYPE) >> 3;
 282                 switch (rval) {
 283                 case 0x00:
 284                         val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 285                         break;
 286                 case 0x01:
 287                 case 0x10:
 288                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
 289                         break;
 290                 case 0x11:
 291                         val->intval = POWER_SUPPLY_STATUS_FULL;
 292                 }
 293                 break;
 294
 295         case POWER_SUPPLY_PROP_CHARGE_TYPE:
 296                 ret = regmap_read(charger->regmap, MP2629_REG_STATUS, &rval);
 297                 if (ret)
 298                         break;
 299
 300                 rval = (rval & MP2629_MASK_CHARGE_TYPE) >> 3;
 301                 switch (rval) {
 302                 case 0x00:
 303                         val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
 304                         break;
 305                 case 0x01:
 306                         val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
 307                         break;
 308                 case 0x10:
 309                         val->intval = POWER_SUPPLY_CHARGE_TYPE_STANDARD;
 310                         break;
 311                 default:
 312                         val->intval = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
 313                 }
 314                 break;
 315
 316         default:
 317                 return -EINVAL;
 318         }
 319
 320         return ret;
 321 }
 322
 323 static int mp2629_charger_battery_set_prop(struct power_supply *psy,
 324                                         enum power_supply_property psp,
 325                                         const union power_supply_propval *val)
 326 {
 327         struct mp2629_charger *charger = dev_get_drvdata(psy->dev.parent);
 328
 329         switch (psp) {
 330         case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
 331                 return mp2629_set_prop(charger, TERM_CURRENT, val);
 332
 333         case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
 334                 return mp2629_set_prop(charger, PRECHARGE, val);
 335
 336         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
 337                 return mp2629_set_prop(charger, CHARGE_VLIM, val);
 338
 339         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
 340                 return mp2629_set_prop(charger, CHARGE_ILIM, val);
 341
 342         default:
 343                 return -EINVAL;
 344         }
 345 }
 346
 347 static int mp2629_charger_usb_get_prop(struct power_supply *psy,
 348                                 enum power_supply_property psp,
 349                                 union power_supply_propval *val)
 350 {
 351         struct mp2629_charger *charger = dev_get_drvdata(psy->dev.parent);
 352         unsigned int rval;
 353         int ret;
 354
 355         switch (psp) {
 356         case POWER_SUPPLY_PROP_ONLINE:
 357                 ret = regmap_read(charger->regmap, MP2629_REG_STATUS, &rval);
 358                 if (ret)
 359                         break;
 360
 361                 val->intval = !!(rval & MP2629_MASK_INPUT_TYPE);
 362                 break;
 363
 364         case POWER_SUPPLY_PROP_USB_TYPE:
 365                 ret = regmap_read(charger->regmap, MP2629_REG_STATUS, &rval);
 366                 if (ret)
 367                         break;
 368
 369                 rval = (rval & MP2629_MASK_INPUT_TYPE) >> 5;
 370                 switch (rval) {
 371                 case MP2629_SOURCE_TYPE_SDP:
 372                         val->intval = POWER_SUPPLY_USB_TYPE_SDP;
 373                         break;
 374                 case MP2629_SOURCE_TYPE_CDP:
 375                         val->intval = POWER_SUPPLY_USB_TYPE_CDP;
 376                         break;
 377                 case MP2629_SOURCE_TYPE_DCP:
 378                         val->intval = POWER_SUPPLY_USB_TYPE_DCP;
 379                         break;
 380                 case MP2629_SOURCE_TYPE_OTG:
 381                         val->intval = POWER_SUPPLY_USB_TYPE_PD_DRP;
 382                         break;
 383                 default:
 384                         val->intval = POWER_SUPPLY_USB_TYPE_UNKNOWN;
 385                         break;
 386                 }
 387                 break;
 388
 389         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 390                 ret = mp2629_read_adc(charger, MP2629_INPUT_VOLT, val);
 391                 break;
 392
 393         case POWER_SUPPLY_PROP_CURRENT_NOW:
 394                 ret = mp2629_read_adc(charger, MP2629_INPUT_CURRENT, val);
 395                 break;
 396
 397         case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT:
 398                 ret = mp2629_get_prop(charger, INPUT_VLIM, val);
 399                 break;
 400
 401         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
 402                 ret = mp2629_get_prop(charger, INPUT_ILIM, val);
 403                 break;
 404
 405         default:
 406                 return -EINVAL;
 407         }
 408
 409         return ret;
 410 }
 411
 412 static int mp2629_charger_usb_set_prop(struct power_supply *psy,
 413                                 enum power_supply_property psp,
 414                                 const union power_supply_propval *val)
 415 {
 416         struct mp2629_charger *charger = dev_get_drvdata(psy->dev.parent);
 417
 418         switch (psp) {
 419         case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT:
 420                 return mp2629_set_prop(charger, INPUT_VLIM, val);
 421
 422         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
 423                 return mp2629_set_prop(charger, INPUT_ILIM, val);
 424
 425         default:
 426                 return -EINVAL;
 427         }
 428 }
 429
 430 static int mp2629_charger_battery_prop_writeable(struct power_supply *psy,
 431                                      enum power_supply_property psp)
 432 {
 433         return (psp == POWER_SUPPLY_PROP_PRECHARGE_CURRENT) ||
 434                (psp == POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT) ||
 435                (psp == POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT) ||
 436                (psp == POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE);
 437 }
 438
 439 static int mp2629_charger_usb_prop_writeable(struct power_supply *psy,
 440                                      enum power_supply_property psp)
 441 {
 442         return (psp == POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT) ||
 443                (psp == POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT);
 444 }
 445
 446 static irqreturn_t mp2629_irq_handler(int irq, void *dev_id)
 447 {
 448         struct mp2629_charger *charger = dev_id;
 449         unsigned int rval;
 450         int ret;
 451
 452         mutex_lock(&charger->lock);
 453
 454         ret = regmap_read(charger->regmap, MP2629_REG_FAULT, &rval);
 455         if (ret)
 456                 goto unlock;
 457
 458         if (rval) {
 459                 charger->fault = rval;
 460                 if (MP2629_FAULT_BATTERY & rval)
 461                         dev_err(charger->dev, "Battery fault OVP\n");
 462                 else if (MP2629_FAULT_THERMAL & rval)
 463                         dev_err(charger->dev, "Thermal shutdown fault\n");
 464                 else if (MP2629_FAULT_INPUT & rval)
 465                         dev_err(charger->dev, "no input or input OVP\n");
 466                 else if (MP2629_FAULT_OTG & rval)
 467                         dev_err(charger->dev, "VIN overloaded\n");
 468
 469                 goto unlock;
 470         }
 471
 472         ret = regmap_read(charger->regmap, MP2629_REG_STATUS, &rval);
 473         if (ret)
 474                 goto unlock;
 475
 476         if (rval & MP2629_INPUTSOURCE_CHANGE)
 477                 power_supply_changed(charger->usb);
 478         else if (rval & MP2629_CHARGING_CHANGE)
 479                 power_supply_changed(charger->battery);
 480
 481 unlock:
 482         mutex_unlock(&charger->lock);
 483
 484         return IRQ_HANDLED;
 485 }
 486
 487 static const struct power_supply_desc mp2629_usb_desc = {
 488         .name           = "mp2629_usb",
 489         .type           = POWER_SUPPLY_TYPE_USB,
 490         .usb_types      = mp2629_usb_types,
 491         .num_usb_types  = ARRAY_SIZE(mp2629_usb_types),
 492         .properties     = mp2629_charger_usb_props,
 493         .num_properties = ARRAY_SIZE(mp2629_charger_usb_props),
 494         .get_property   = mp2629_charger_usb_get_prop,
 495         .set_property   = mp2629_charger_usb_set_prop,
 496         .property_is_writeable = mp2629_charger_usb_prop_writeable,
 497 };
 498
 499 static const struct power_supply_desc mp2629_battery_desc = {
 500         .name           = "mp2629_battery",
 501         .type           = POWER_SUPPLY_TYPE_BATTERY,
 502         .properties     = mp2629_charger_bat_props,
 503         .num_properties = ARRAY_SIZE(mp2629_charger_bat_props),
 504         .get_property   = mp2629_charger_battery_get_prop,
 505         .set_property   = mp2629_charger_battery_set_prop,
 506         .property_is_writeable = mp2629_charger_battery_prop_writeable,
 507 };
 508
 509 static ssize_t batt_impedance_compensation_show(struct device *dev,
 510                                            struct device_attribute *attr,
 511                                            char *buf)
 512 {
 513         struct mp2629_charger *charger = dev_get_drvdata(dev->parent);
 514         unsigned int rval;
 515         int ret;
 516
 517         ret = regmap_read(charger->regmap, MP2629_REG_IMPEDANCE_COMP, &rval);
 518         if (ret)
 519                 return ret;
 520
 521         rval = (rval >> 4) * 10;
 522         return sprintf(buf, "%d mohm\n", rval);
 523 }
 524
 525 static ssize_t batt_impedance_compensation_store(struct device *dev,
 526                                             struct device_attribute *attr,
 527                                             const char *buf,
 528                                             size_t count)
 529 {
 530         struct mp2629_charger *charger = dev_get_drvdata(dev->parent);
 531         unsigned int val;
 532         int ret;
 533
 534         ret = kstrtouint(buf, 10, &val);
 535         if (ret)
 536                 return ret;
 537
 538         if (val > 140)
 539                 return -ERANGE;
 540
 541         /* multiples of 10 mohm so round off */
 542         val = val / 10;
 543         ret = regmap_update_bits(charger->regmap, MP2629_REG_IMPEDANCE_COMP,
 544                                         MP2629_MASK_IMPEDANCE, val << 4);
 545         if (ret)
 546                 return ret;
 547
 548         return count;
 549 }
 550
 551 static DEVICE_ATTR_RW(batt_impedance_compensation);
 552
 553 static struct attribute *mp2629_charger_sysfs_attrs[] = {
 554         &dev_attr_batt_impedance_compensation.attr,
 555         NULL
 556 };
 557 ATTRIBUTE_GROUPS(mp2629_charger_sysfs);
 558
 559 static void mp2629_charger_disable(void *data)
 560 {
 561         struct mp2629_charger *charger = data;
 562
 563         regmap_update_bits(charger->regmap, MP2629_REG_CHARGE_CTRL,
 564                                         MP2629_MASK_CHARGE_CTRL, 0);
 565 }
 566
 567 static int mp2629_charger_probe(struct platform_device *pdev)
 568 {
 569         struct device *dev = &pdev->dev;
 570         struct mp2629_data *ddata = dev_get_drvdata(dev->parent);
 571         struct mp2629_charger *charger;
 572         struct power_supply_config psy_cfg = {};
 573         int ret, i, irq;
 574
 575         charger = devm_kzalloc(dev, sizeof(*charger), GFP_KERNEL);
 576         if (!charger)
 577                 return -ENOMEM;
 578
 579         charger->regmap = ddata->regmap;
 580         charger->dev = dev;
 581         platform_set_drvdata(pdev, charger);
 582
 583         irq = platform_get_irq_optional(to_platform_device(dev->parent), 0);
 584         if (irq < 0) {
 585                 dev_err(dev, "get irq fail: %d\n", irq);
 586                 return irq;
 587         }
 588
 589         for (i = 0; i < MP2629_MAX_FIELD; i++) {
 590                 charger->regmap_fields[i] = devm_regmap_field_alloc(dev,
 591                                         charger->regmap, mp2629_reg_fields[i]);
 592                 if (IS_ERR(charger->regmap_fields[i])) {
 593                         dev_err(dev, "regmap field alloc fail %d\n", i);
 594                         return PTR_ERR(charger->regmap_fields[i]);
 595                 }
 596         }
 597
 598         for (i = 0; i < MP2629_ADC_CHAN_END; i++) {
 599                 charger->iiochan[i] = devm_iio_channel_get(dev,
 600                                                         adc_chan_name[i]);
 601                 if (IS_ERR(charger->iiochan[i])) {
 602                         dev_err(dev, "iio chan get %s err\n", adc_chan_name[i]);
 603                         return PTR_ERR(charger->iiochan[i]);
 604                 }
 605         }
 606
 607         ret = devm_add_action_or_reset(dev, mp2629_charger_disable, charger);
 608         if (ret)
 609                 return ret;
 610
 611         charger->usb = devm_power_supply_register(dev, &mp2629_usb_desc, NULL);
 612         if (IS_ERR(charger->usb)) {
 613                 dev_err(dev, "power supply register usb failed\n");
 614                 return PTR_ERR(charger->usb);
 615         }
 616
 617         psy_cfg.drv_data = charger;
 618         psy_cfg.attr_grp = mp2629_charger_sysfs_groups;
 619         charger->battery = devm_power_supply_register(dev,
 620                                          &mp2629_battery_desc, &psy_cfg);
 621         if (IS_ERR(charger->battery)) {
 622                 dev_err(dev, "power supply register battery failed\n");
 623                 return PTR_ERR(charger->battery);
 624         }
 625
 626         ret = regmap_update_bits(charger->regmap, MP2629_REG_CHARGE_CTRL,
 627                                         MP2629_MASK_CHARGE_CTRL, BIT(4));
 628         if (ret) {
 629                 dev_err(dev, "enable charge fail: %d\n", ret);
 630                 return ret;
 631         }
 632
 633         regmap_update_bits(charger->regmap, MP2629_REG_TIMER_CTRL,
 634                                         MP2629_MASK_WDOG_CTRL, 0);
 635
 636         mutex_init(&charger->lock);
 637
 638         ret = devm_request_threaded_irq(dev, irq, NULL, mp2629_irq_handler,
 639                                         IRQF_ONESHOT | IRQF_TRIGGER_RISING,
 640                                         "mp2629-charger", charger);
 641         if (ret) {
 642                 dev_err(dev, "failed to request gpio IRQ\n");
 643                 return ret;
 644         }
 645
 646         regmap_update_bits(charger->regmap, MP2629_REG_INTERRUPT,
 647                                 GENMASK(6, 5), BIT(6) | BIT(5));
 648
 649         return 0;
 650 }
 651
 652 static const struct of_device_id mp2629_charger_of_match[] = {
 653         { .compatible = "mps,mp2629_charger"},
 654         {}
 655 };
 656 MODULE_DEVICE_TABLE(of, mp2629_charger_of_match);
 657
 658 static struct platform_driver mp2629_charger_driver = {
 659         .driver = {
 660                 .name = "mp2629_charger",
 661                 .of_match_table = mp2629_charger_of_match,
 662         },
 663         .probe          = mp2629_charger_probe,
 664 };
 665 module_platform_driver(mp2629_charger_driver);
 666
 667 MODULE_AUTHOR("Saravanan Sekar <sravanhome@gmail.com>");
 668 MODULE_DESCRIPTION("MP2629 Charger driver");
 669 MODULE_LICENSE("GPL");