drivers/power/supply/lp8788-charger.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * TI LP8788 MFD - battery charger driver
   4  *
   5  * Copyright 2012 Texas Instruments
   6  *
   7  * Author: Milo(Woogyom) Kim <milo.kim@ti.com>
   8  */
   9
  10 #include <linux/err.h>
  11 #include <linux/iio/consumer.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/irqdomain.h>
  14 #include <linux/mfd/lp8788.h>
  15 #include <linux/module.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/power_supply.h>
  18 #include <linux/slab.h>
  19 #include <linux/workqueue.h>
  20
  21 /* register address */
  22 #define LP8788_CHG_STATUS               0x07
  23 #define LP8788_CHG_IDCIN                0x13
  24 #define LP8788_CHG_IBATT                0x14
  25 #define LP8788_CHG_VTERM                0x15
  26 #define LP8788_CHG_EOC                  0x16
  27
  28 /* mask/shift bits */
  29 #define LP8788_CHG_INPUT_STATE_M        0x03    /* Addr 07h */
  30 #define LP8788_CHG_STATE_M              0x3C
  31 #define LP8788_CHG_STATE_S              2
  32 #define LP8788_NO_BATT_M                BIT(6)
  33 #define LP8788_BAD_BATT_M               BIT(7)
  34 #define LP8788_CHG_IBATT_M              0x1F    /* Addr 14h */
  35 #define LP8788_CHG_VTERM_M              0x0F    /* Addr 15h */
  36 #define LP8788_CHG_EOC_LEVEL_M          0x30    /* Addr 16h */
  37 #define LP8788_CHG_EOC_LEVEL_S          4
  38 #define LP8788_CHG_EOC_TIME_M           0x0E
  39 #define LP8788_CHG_EOC_TIME_S           1
  40 #define LP8788_CHG_EOC_MODE_M           BIT(0)
  41
  42 #define LP8788_CHARGER_NAME             "charger"
  43 #define LP8788_BATTERY_NAME             "main_batt"
  44
  45 #define LP8788_CHG_START                0x11
  46 #define LP8788_CHG_END                  0x1C
  47
  48 #define LP8788_ISEL_MAX                 23
  49 #define LP8788_ISEL_STEP                50
  50 #define LP8788_VTERM_MIN                4100
  51 #define LP8788_VTERM_STEP               25
  52 #define LP8788_MAX_BATT_CAPACITY        100
  53 #define LP8788_MAX_CHG_IRQS             11
  54
  55 enum lp8788_charging_state {
  56         LP8788_OFF,
  57         LP8788_WARM_UP,
  58         LP8788_LOW_INPUT = 0x3,
  59         LP8788_PRECHARGE,
  60         LP8788_CC,
  61         LP8788_CV,
  62         LP8788_MAINTENANCE,
  63         LP8788_BATTERY_FAULT,
  64         LP8788_SYSTEM_SUPPORT = 0xC,
  65         LP8788_HIGH_CURRENT = 0xF,
  66         LP8788_MAX_CHG_STATE,
  67 };
  68
  69 enum lp8788_charger_adc_sel {
  70         LP8788_VBATT,
  71         LP8788_BATT_TEMP,
  72         LP8788_NUM_CHG_ADC,
  73 };
  74
  75 enum lp8788_charger_input_state {
  76         LP8788_SYSTEM_SUPPLY = 1,
  77         LP8788_FULL_FUNCTION,
  78 };
  79
  80 /*
  81  * struct lp8788_chg_irq
  82  * @which        : lp8788 interrupt id
  83  * @virq         : Linux IRQ number from irq_domain
  84  */
  85 struct lp8788_chg_irq {
  86         enum lp8788_int_id which;
  87         int virq;
  88 };
  89
  90 /*
  91  * struct lp8788_charger
  92  * @lp           : used for accessing the registers of mfd lp8788 device
  93  * @charger      : power supply driver for the battery charger
  94  * @battery      : power supply driver for the battery
  95  * @charger_work : work queue for charger input interrupts
  96  * @chan         : iio channels for getting adc values
  97  *                 eg) battery voltage, capacity and temperature
  98  * @irqs         : charger dedicated interrupts
  99  * @num_irqs     : total numbers of charger interrupts
 100  * @pdata        : charger platform specific data
 101  */
 102 struct lp8788_charger {
 103         struct lp8788 *lp;
 104         struct power_supply *charger;
 105         struct power_supply *battery;
 106         struct work_struct charger_work;
 107         struct iio_channel *chan[LP8788_NUM_CHG_ADC];
 108         struct lp8788_chg_irq irqs[LP8788_MAX_CHG_IRQS];
 109         int num_irqs;
 110         struct lp8788_charger_platform_data *pdata;
 111 };
 112
 113 static char *battery_supplied_to[] = {
 114         LP8788_BATTERY_NAME,
 115 };
 116
 117 static enum power_supply_property lp8788_charger_prop[] = {
 118         POWER_SUPPLY_PROP_ONLINE,
 119         POWER_SUPPLY_PROP_CURRENT_MAX,
 120 };
 121
 122 static enum power_supply_property lp8788_battery_prop[] = {
 123         POWER_SUPPLY_PROP_STATUS,
 124         POWER_SUPPLY_PROP_HEALTH,
 125         POWER_SUPPLY_PROP_PRESENT,
 126         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 127         POWER_SUPPLY_PROP_CAPACITY,
 128         POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
 129         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
 130         POWER_SUPPLY_PROP_TEMP,
 131 };
 132
 133 static bool lp8788_is_charger_detected(struct lp8788_charger *pchg)
 134 {
 135         u8 data;
 136
 137         lp8788_read_byte(pchg->lp, LP8788_CHG_STATUS, &data);
 138         data &= LP8788_CHG_INPUT_STATE_M;
 139
 140         return data == LP8788_SYSTEM_SUPPLY || data == LP8788_FULL_FUNCTION;
 141 }
 142
 143 static int lp8788_charger_get_property(struct power_supply *psy,
 144                                         enum power_supply_property psp,
 145                                         union power_supply_propval *val)
 146 {
 147         struct lp8788_charger *pchg = dev_get_drvdata(psy->dev.parent);
 148         u8 read;
 149
 150         switch (psp) {
 151         case POWER_SUPPLY_PROP_ONLINE:
 152                 val->intval = lp8788_is_charger_detected(pchg);
 153                 break;
 154         case POWER_SUPPLY_PROP_CURRENT_MAX:
 155                 lp8788_read_byte(pchg->lp, LP8788_CHG_IDCIN, &read);
 156                 val->intval = LP8788_ISEL_STEP *
 157                                 (min_t(int, read, LP8788_ISEL_MAX) + 1);
 158                 break;
 159         default:
 160                 return -EINVAL;
 161         }
 162
 163         return 0;
 164 }
 165
 166 static int lp8788_get_battery_status(struct lp8788_charger *pchg,
 167                                 union power_supply_propval *val)
 168 {
 169         enum lp8788_charging_state state;
 170         u8 data;
 171         int ret;
 172
 173         ret = lp8788_read_byte(pchg->lp, LP8788_CHG_STATUS, &data);
 174         if (ret)
 175                 return ret;
 176
 177         state = (data & LP8788_CHG_STATE_M) >> LP8788_CHG_STATE_S;
 178         switch (state) {
 179         case LP8788_OFF:
 180                 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 181                 break;
 182         case LP8788_PRECHARGE:
 183         case LP8788_CC:
 184         case LP8788_CV:
 185         case LP8788_HIGH_CURRENT:
 186                 val->intval = POWER_SUPPLY_STATUS_CHARGING;
 187                 break;
 188         case LP8788_MAINTENANCE:
 189                 val->intval = POWER_SUPPLY_STATUS_FULL;
 190                 break;
 191         default:
 192                 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
 193                 break;
 194         }
 195
 196         return 0;
 197 }
 198
 199 static int lp8788_get_battery_health(struct lp8788_charger *pchg,
 200                                 union power_supply_propval *val)
 201 {
 202         u8 data;
 203         int ret;
 204
 205         ret = lp8788_read_byte(pchg->lp, LP8788_CHG_STATUS, &data);
 206         if (ret)
 207                 return ret;
 208
 209         if (data & LP8788_NO_BATT_M)
 210                 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
 211         else if (data & LP8788_BAD_BATT_M)
 212                 val->intval = POWER_SUPPLY_HEALTH_DEAD;
 213         else
 214                 val->intval = POWER_SUPPLY_HEALTH_GOOD;
 215
 216         return 0;
 217 }
 218
 219 static int lp8788_get_battery_present(struct lp8788_charger *pchg,
 220                                 union power_supply_propval *val)
 221 {
 222         u8 data;
 223         int ret;
 224
 225         ret = lp8788_read_byte(pchg->lp, LP8788_CHG_STATUS, &data);
 226         if (ret)
 227                 return ret;
 228
 229         val->intval = !(data & LP8788_NO_BATT_M);
 230         return 0;
 231 }
 232
 233 static int lp8788_get_vbatt_adc(struct lp8788_charger *pchg, int *result)
 234 {
 235         struct iio_channel *channel = pchg->chan[LP8788_VBATT];
 236
 237         if (!channel)
 238                 return -EINVAL;
 239
 240         return iio_read_channel_processed(channel, result);
 241 }
 242
 243 static int lp8788_get_battery_voltage(struct lp8788_charger *pchg,
 244                                 union power_supply_propval *val)
 245 {
 246         return lp8788_get_vbatt_adc(pchg, &val->intval);
 247 }
 248
 249 static int lp8788_get_battery_capacity(struct lp8788_charger *pchg,
 250                                 union power_supply_propval *val)
 251 {
 252         struct lp8788 *lp = pchg->lp;
 253         struct lp8788_charger_platform_data *pdata = pchg->pdata;
 254         unsigned int max_vbatt;
 255         int vbatt;
 256         enum lp8788_charging_state state;
 257         u8 data;
 258         int ret;
 259
 260         if (!pdata)
 261                 return -EINVAL;
 262
 263         max_vbatt = pdata->max_vbatt_mv;
 264         if (max_vbatt == 0)
 265                 return -EINVAL;
 266
 267         ret = lp8788_read_byte(lp, LP8788_CHG_STATUS, &data);
 268         if (ret)
 269                 return ret;
 270
 271         state = (data & LP8788_CHG_STATE_M) >> LP8788_CHG_STATE_S;
 272
 273         if (state == LP8788_MAINTENANCE) {
 274                 val->intval = LP8788_MAX_BATT_CAPACITY;
 275         } else {
 276                 ret = lp8788_get_vbatt_adc(pchg, &vbatt);
 277                 if (ret)
 278                         return ret;
 279
 280                 val->intval = (vbatt * LP8788_MAX_BATT_CAPACITY) / max_vbatt;
 281                 val->intval = min(val->intval, LP8788_MAX_BATT_CAPACITY);
 282         }
 283
 284         return 0;
 285 }
 286
 287 static int lp8788_get_battery_temperature(struct lp8788_charger *pchg,
 288                                 union power_supply_propval *val)
 289 {
 290         struct iio_channel *channel = pchg->chan[LP8788_BATT_TEMP];
 291         int result;
 292         int ret;
 293
 294         if (!channel)
 295                 return -EINVAL;
 296
 297         ret = iio_read_channel_processed(channel, &result);
 298         if (ret < 0)
 299                 return -EINVAL;
 300
 301         /* unit: 0.1 'C */
 302         val->intval = result * 10;
 303
 304         return 0;
 305 }
 306
 307 static int lp8788_get_battery_charging_current(struct lp8788_charger *pchg,
 308                                 union power_supply_propval *val)
 309 {
 310         u8 read;
 311
 312         lp8788_read_byte(pchg->lp, LP8788_CHG_IBATT, &read);
 313         read &= LP8788_CHG_IBATT_M;
 314         val->intval = LP8788_ISEL_STEP *
 315                         (min_t(int, read, LP8788_ISEL_MAX) + 1);
 316
 317         return 0;
 318 }
 319
 320 static int lp8788_get_charging_termination_voltage(struct lp8788_charger *pchg,
 321                                 union power_supply_propval *val)
 322 {
 323         u8 read;
 324
 325         lp8788_read_byte(pchg->lp, LP8788_CHG_VTERM, &read);
 326         read &= LP8788_CHG_VTERM_M;
 327         val->intval = LP8788_VTERM_MIN + LP8788_VTERM_STEP * read;
 328
 329         return 0;
 330 }
 331
 332 static int lp8788_battery_get_property(struct power_supply *psy,
 333                                         enum power_supply_property psp,
 334                                         union power_supply_propval *val)
 335 {
 336         struct lp8788_charger *pchg = dev_get_drvdata(psy->dev.parent);
 337
 338         switch (psp) {
 339         case POWER_SUPPLY_PROP_STATUS:
 340                 return lp8788_get_battery_status(pchg, val);
 341         case POWER_SUPPLY_PROP_HEALTH:
 342                 return lp8788_get_battery_health(pchg, val);
 343         case POWER_SUPPLY_PROP_PRESENT:
 344                 return lp8788_get_battery_present(pchg, val);
 345         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 346                 return lp8788_get_battery_voltage(pchg, val);
 347         case POWER_SUPPLY_PROP_CAPACITY:
 348                 return lp8788_get_battery_capacity(pchg, val);
 349         case POWER_SUPPLY_PROP_TEMP:
 350                 return lp8788_get_battery_temperature(pchg, val);
 351         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
 352                 return lp8788_get_battery_charging_current(pchg, val);
 353         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
 354                 return lp8788_get_charging_termination_voltage(pchg, val);
 355         default:
 356                 return -EINVAL;
 357         }
 358 }
 359
 360 static inline bool lp8788_is_valid_charger_register(u8 addr)
 361 {
 362         return addr >= LP8788_CHG_START && addr <= LP8788_CHG_END;
 363 }
 364
 365 static int lp8788_update_charger_params(struct platform_device *pdev,
 366                                         struct lp8788_charger *pchg)
 367 {
 368         struct lp8788 *lp = pchg->lp;
 369         struct lp8788_charger_platform_data *pdata = pchg->pdata;
 370         struct lp8788_chg_param *param;
 371         int i;
 372         int ret;
 373
 374         if (!pdata || !pdata->chg_params) {
 375                 dev_info(&pdev->dev, "skip updating charger parameters\n");
 376                 return 0;
 377         }
 378
 379         /* settting charging parameters */
 380         for (i = 0; i < pdata->num_chg_params; i++) {
 381                 param = pdata->chg_params + i;
 382
 383                 if (lp8788_is_valid_charger_register(param->addr)) {
 384                         ret = lp8788_write_byte(lp, param->addr, param->val);
 385                         if (ret)
 386                                 return ret;
 387                 }
 388         }
 389
 390         return 0;
 391 }
 392
 393 static const struct power_supply_desc lp8788_psy_charger_desc = {
 394         .name           = LP8788_CHARGER_NAME,
 395         .type           = POWER_SUPPLY_TYPE_MAINS,
 396         .properties     = lp8788_charger_prop,
 397         .num_properties = ARRAY_SIZE(lp8788_charger_prop),
 398         .get_property   = lp8788_charger_get_property,
 399 };
 400
 401 static const struct power_supply_desc lp8788_psy_battery_desc = {
 402         .name           = LP8788_BATTERY_NAME,
 403         .type           = POWER_SUPPLY_TYPE_BATTERY,
 404         .properties     = lp8788_battery_prop,
 405         .num_properties = ARRAY_SIZE(lp8788_battery_prop),
 406         .get_property   = lp8788_battery_get_property,
 407 };
 408
 409 static void lp8788_psy_unregister(struct lp8788_charger *pchg)
 410 {
 411         power_supply_unregister(pchg->battery);
 412         power_supply_unregister(pchg->charger);
 413 }
 414
 415 static void lp8788_charger_event(struct work_struct *work)
 416 {
 417         struct lp8788_charger *pchg =
 418                 container_of(work, struct lp8788_charger, charger_work);
 419         struct lp8788_charger_platform_data *pdata = pchg->pdata;
 420         enum lp8788_charger_event event = lp8788_is_charger_detected(pchg);
 421
 422         pdata->charger_event(pchg->lp, event);
 423 }
 424
 425 static bool lp8788_find_irq_id(struct lp8788_charger *pchg, int virq, int *id)
 426 {
 427         bool found = false;
 428         int i;
 429
 430         for (i = 0; i < pchg->num_irqs; i++) {
 431                 if (pchg->irqs[i].virq == virq) {
 432                         *id = pchg->irqs[i].which;
 433                         found = true;
 434                         break;
 435                 }
 436         }
 437
 438         return found;
 439 }
 440
 441 static irqreturn_t lp8788_charger_irq_thread(int virq, void *ptr)
 442 {
 443         struct lp8788_charger *pchg = ptr;
 444         struct lp8788_charger_platform_data *pdata = pchg->pdata;
 445         int id = -1;
 446
 447         if (!lp8788_find_irq_id(pchg, virq, &id))
 448                 return IRQ_NONE;
 449
 450         switch (id) {
 451         case LP8788_INT_CHG_INPUT_STATE:
 452         case LP8788_INT_CHG_STATE:
 453         case LP8788_INT_EOC:
 454         case LP8788_INT_BATT_LOW:
 455         case LP8788_INT_NO_BATT:
 456                 power_supply_changed(pchg->charger);
 457                 power_supply_changed(pchg->battery);
 458                 break;
 459         default:
 460                 break;
 461         }
 462
 463         /* report charger dectection event if used */
 464         if (!pdata)
 465                 goto irq_handled;
 466
 467         if (pdata->charger_event && id == LP8788_INT_CHG_INPUT_STATE)
 468                 schedule_work(&pchg->charger_work);
 469
 470 irq_handled:
 471         return IRQ_HANDLED;
 472 }
 473
 474 static int lp8788_set_irqs(struct platform_device *pdev,
 475                         struct lp8788_charger *pchg, const char *name)
 476 {
 477         struct resource *r;
 478         struct irq_domain *irqdm = pchg->lp->irqdm;
 479         int irq_start;
 480         int irq_end;
 481         int virq;
 482         int nr_irq;
 483         int i;
 484         int ret;
 485
 486         /* no error even if no irq resource */
 487         r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, name);
 488         if (!r)
 489                 return 0;
 490
 491         irq_start = r->start;
 492         irq_end = r->end;
 493
 494         for (i = irq_start; i <= irq_end; i++) {
 495                 nr_irq = pchg->num_irqs;
 496
 497                 virq = irq_create_mapping(irqdm, i);
 498                 pchg->irqs[nr_irq].virq = virq;
 499                 pchg->irqs[nr_irq].which = i;
 500                 pchg->num_irqs++;
 501
 502                 ret = request_threaded_irq(virq, NULL,
 503                                         lp8788_charger_irq_thread,
 504                                         0, name, pchg);
 505                 if (ret)
 506                         break;
 507         }
 508
 509         if (i <= irq_end)
 510                 goto err_free_irq;
 511
 512         return 0;
 513
 514 err_free_irq:
 515         for (i = 0; i < pchg->num_irqs; i++)
 516                 free_irq(pchg->irqs[i].virq, pchg);
 517         return ret;
 518 }
 519
 520 static int lp8788_irq_register(struct platform_device *pdev,
 521                                 struct lp8788_charger *pchg)
 522 {
 523         const char *name[] = {
 524                 LP8788_CHG_IRQ, LP8788_PRSW_IRQ, LP8788_BATT_IRQ
 525         };
 526         int i;
 527         int ret;
 528
 529         INIT_WORK(&pchg->charger_work, lp8788_charger_event);
 530         pchg->num_irqs = 0;
 531
 532         for (i = 0; i < ARRAY_SIZE(name); i++) {
 533                 ret = lp8788_set_irqs(pdev, pchg, name[i]);
 534                 if (ret) {
 535                         dev_warn(&pdev->dev, "irq setup failed: %s\n", name[i]);
 536                         return ret;
 537                 }
 538         }
 539
 540         if (pchg->num_irqs > LP8788_MAX_CHG_IRQS) {
 541                 dev_err(&pdev->dev, "invalid total number of irqs: %d\n",
 542                         pchg->num_irqs);
 543                 return -EINVAL;
 544         }
 545
 546
 547         return 0;
 548 }
 549
 550 static void lp8788_irq_unregister(struct platform_device *pdev,
 551                                   struct lp8788_charger *pchg)
 552 {
 553         int i;
 554         int irq;
 555
 556         for (i = 0; i < pchg->num_irqs; i++) {
 557                 irq = pchg->irqs[i].virq;
 558                 if (!irq)
 559                         continue;
 560
 561                 free_irq(irq, pchg);
 562         }
 563 }
 564
 565 static void lp8788_setup_adc_channel(struct device *dev,
 566                                 struct lp8788_charger *pchg)
 567 {
 568         struct lp8788_charger_platform_data *pdata = pchg->pdata;
 569         struct iio_channel *chan;
 570
 571         if (!pdata)
 572                 return;
 573
 574         /* ADC channel for battery voltage */
 575         chan = iio_channel_get(dev, pdata->adc_vbatt);
 576         pchg->chan[LP8788_VBATT] = IS_ERR(chan) ? NULL : chan;
 577
 578         /* ADC channel for battery temperature */
 579         chan = iio_channel_get(dev, pdata->adc_batt_temp);
 580         pchg->chan[LP8788_BATT_TEMP] = IS_ERR(chan) ? NULL : chan;
 581 }
 582
 583 static void lp8788_release_adc_channel(struct lp8788_charger *pchg)
 584 {
 585         int i;
 586
 587         for (i = 0; i < LP8788_NUM_CHG_ADC; i++) {
 588                 if (!pchg->chan[i])
 589                         continue;
 590
 591                 iio_channel_release(pchg->chan[i]);
 592                 pchg->chan[i] = NULL;
 593         }
 594 }
 595
 596 static ssize_t lp8788_show_charger_status(struct device *dev,
 597                                 struct device_attribute *attr, char *buf)
 598 {
 599         struct lp8788_charger *pchg = dev_get_drvdata(dev);
 600         enum lp8788_charging_state state;
 601         static const char * const desc[LP8788_MAX_CHG_STATE] = {
 602                 [LP8788_OFF] = "CHARGER OFF",
 603                 [LP8788_WARM_UP] = "WARM UP",
 604                 [LP8788_LOW_INPUT] = "LOW INPUT STATE",
 605                 [LP8788_PRECHARGE] = "CHARGING - PRECHARGE",
 606                 [LP8788_CC] = "CHARGING - CC",
 607                 [LP8788_CV] = "CHARGING - CV",
 608                 [LP8788_MAINTENANCE] = "NO CHARGING - MAINTENANCE",
 609                 [LP8788_BATTERY_FAULT] = "BATTERY FAULT",
 610                 [LP8788_SYSTEM_SUPPORT] = "SYSTEM SUPPORT",
 611                 [LP8788_HIGH_CURRENT] = "HIGH CURRENT",
 612         };
 613         u8 data;
 614
 615         lp8788_read_byte(pchg->lp, LP8788_CHG_STATUS, &data);
 616         state = (data & LP8788_CHG_STATE_M) >> LP8788_CHG_STATE_S;
 617
 618         return scnprintf(buf, PAGE_SIZE, "%s\n", desc[state]);
 619 }
 620
 621 static ssize_t lp8788_show_eoc_time(struct device *dev,
 622                                 struct device_attribute *attr, char *buf)
 623 {
 624         struct lp8788_charger *pchg = dev_get_drvdata(dev);
 625         static const char * const stime[] = {
 626                 "400ms", "5min", "10min", "15min",
 627                 "20min", "25min", "30min", "No timeout"
 628         };
 629         u8 val;
 630
 631         lp8788_read_byte(pchg->lp, LP8788_CHG_EOC, &val);
 632         val = (val & LP8788_CHG_EOC_TIME_M) >> LP8788_CHG_EOC_TIME_S;
 633
 634         return scnprintf(buf, PAGE_SIZE, "End Of Charge Time: %s\n",
 635                         stime[val]);
 636 }
 637
 638 static ssize_t lp8788_show_eoc_level(struct device *dev,
 639                                 struct device_attribute *attr, char *buf)
 640 {
 641         struct lp8788_charger *pchg = dev_get_drvdata(dev);
 642         static const char * const abs_level[] = {
 643                         "25mA", "49mA", "75mA", "98mA"
 644         };
 645         static const char * const relative_level[] = {
 646                         "5%", "10%", "15%", "20%"
 647         };
 648         const char *level;
 649         u8 val;
 650         u8 mode;
 651
 652         lp8788_read_byte(pchg->lp, LP8788_CHG_EOC, &val);
 653
 654         mode = val & LP8788_CHG_EOC_MODE_M;
 655         val = (val & LP8788_CHG_EOC_LEVEL_M) >> LP8788_CHG_EOC_LEVEL_S;
 656         level = mode ? abs_level[val] : relative_level[val];
 657
 658         return scnprintf(buf, PAGE_SIZE, "End Of Charge Level: %s\n", level);
 659 }
 660
 661 static DEVICE_ATTR(charger_status, S_IRUSR, lp8788_show_charger_status, NULL);
 662 static DEVICE_ATTR(eoc_time, S_IRUSR, lp8788_show_eoc_time, NULL);
 663 static DEVICE_ATTR(eoc_level, S_IRUSR, lp8788_show_eoc_level, NULL);
 664
 665 static struct attribute *lp8788_charger_sysfs_attrs[] = {
 666         &dev_attr_charger_status.attr,
 667         &dev_attr_eoc_time.attr,
 668         &dev_attr_eoc_level.attr,
 669         NULL,
 670 };
 671
 672 ATTRIBUTE_GROUPS(lp8788_charger_sysfs);
 673
 674 static int lp8788_psy_register(struct platform_device *pdev,
 675                                 struct lp8788_charger *pchg)
 676 {
 677         struct power_supply_config charger_cfg = {};
 678
 679         charger_cfg.attr_grp = lp8788_charger_sysfs_groups;
 680         charger_cfg.supplied_to = battery_supplied_to;
 681         charger_cfg.num_supplicants = ARRAY_SIZE(battery_supplied_to);
 682
 683         pchg->charger = power_supply_register(&pdev->dev,
 684                                               &lp8788_psy_charger_desc,
 685                                               &charger_cfg);
 686         if (IS_ERR(pchg->charger))
 687                 return -EPERM;
 688
 689         pchg->battery = power_supply_register(&pdev->dev,
 690                                               &lp8788_psy_battery_desc, NULL);
 691         if (IS_ERR(pchg->battery)) {
 692                 power_supply_unregister(pchg->charger);
 693                 return -EPERM;
 694         }
 695
 696         return 0;
 697 }
 698
 699 static int lp8788_charger_probe(struct platform_device *pdev)
 700 {
 701         struct lp8788 *lp = dev_get_drvdata(pdev->dev.parent);
 702         struct lp8788_charger *pchg;
 703         struct device *dev = &pdev->dev;
 704         int ret;
 705
 706         pchg = devm_kzalloc(dev, sizeof(struct lp8788_charger), GFP_KERNEL);
 707         if (!pchg)
 708                 return -ENOMEM;
 709
 710         pchg->lp = lp;
 711         pchg->pdata = lp->pdata ? lp->pdata->chg_pdata : NULL;
 712         platform_set_drvdata(pdev, pchg);
 713
 714         ret = lp8788_update_charger_params(pdev, pchg);
 715         if (ret)
 716                 return ret;
 717
 718         lp8788_setup_adc_channel(&pdev->dev, pchg);
 719
 720         ret = lp8788_psy_register(pdev, pchg);
 721         if (ret)
 722                 return ret;
 723
 724         ret = lp8788_irq_register(pdev, pchg);
 725         if (ret)
 726                 dev_warn(dev, "failed to register charger irq: %d\n", ret);
 727
 728         return 0;
 729 }
 730
 731 static int lp8788_charger_remove(struct platform_device *pdev)
 732 {
 733         struct lp8788_charger *pchg = platform_get_drvdata(pdev);
 734
 735         flush_work(&pchg->charger_work);
 736         lp8788_irq_unregister(pdev, pchg);
 737         lp8788_psy_unregister(pchg);
 738         lp8788_release_adc_channel(pchg);
 739
 740         return 0;
 741 }
 742
 743 static struct platform_driver lp8788_charger_driver = {
 744         .probe = lp8788_charger_probe,
 745         .remove = lp8788_charger_remove,
 746         .driver = {
 747                 .name = LP8788_DEV_CHARGER,
 748         },
 749 };
 750 module_platform_driver(lp8788_charger_driver);
 751
 752 MODULE_DESCRIPTION("TI LP8788 Charger Driver");
 753 MODULE_AUTHOR("Milo Kim");
 754 MODULE_LICENSE("GPL");
 755 MODULE_ALIAS("platform:lp8788-charger");