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         /* setting 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_charger_event(struct work_struct *work)
 410 {
 411         struct lp8788_charger *pchg =
 412                 container_of(work, struct lp8788_charger, charger_work);
 413         struct lp8788_charger_platform_data *pdata = pchg->pdata;
 414         enum lp8788_charger_event event = lp8788_is_charger_detected(pchg);
 415
 416         pdata->charger_event(pchg->lp, event);
 417 }
 418
 419 static bool lp8788_find_irq_id(struct lp8788_charger *pchg, int virq, int *id)
 420 {
 421         bool found = false;
 422         int i;
 423
 424         for (i = 0; i < pchg->num_irqs; i++) {
 425                 if (pchg->irqs[i].virq == virq) {
 426                         *id = pchg->irqs[i].which;
 427                         found = true;
 428                         break;
 429                 }
 430         }
 431
 432         return found;
 433 }
 434
 435 static irqreturn_t lp8788_charger_irq_thread(int virq, void *ptr)
 436 {
 437         struct lp8788_charger *pchg = ptr;
 438         struct lp8788_charger_platform_data *pdata = pchg->pdata;
 439         int id = -1;
 440
 441         if (!lp8788_find_irq_id(pchg, virq, &id))
 442                 return IRQ_NONE;
 443
 444         switch (id) {
 445         case LP8788_INT_CHG_INPUT_STATE:
 446         case LP8788_INT_CHG_STATE:
 447         case LP8788_INT_EOC:
 448         case LP8788_INT_BATT_LOW:
 449         case LP8788_INT_NO_BATT:
 450                 power_supply_changed(pchg->charger);
 451                 power_supply_changed(pchg->battery);
 452                 break;
 453         default:
 454                 break;
 455         }
 456
 457         /* report charger dectection event if used */
 458         if (!pdata)
 459                 goto irq_handled;
 460
 461         if (pdata->charger_event && id == LP8788_INT_CHG_INPUT_STATE)
 462                 schedule_work(&pchg->charger_work);
 463
 464 irq_handled:
 465         return IRQ_HANDLED;
 466 }
 467
 468 static int lp8788_set_irqs(struct platform_device *pdev,
 469                         struct lp8788_charger *pchg, const char *name)
 470 {
 471         struct resource *r;
 472         struct irq_domain *irqdm = pchg->lp->irqdm;
 473         int irq_start;
 474         int irq_end;
 475         int virq;
 476         int nr_irq;
 477         int i;
 478         int ret;
 479
 480         /* no error even if no irq resource */
 481         r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, name);
 482         if (!r)
 483                 return 0;
 484
 485         irq_start = r->start;
 486         irq_end = r->end;
 487
 488         for (i = irq_start; i <= irq_end; i++) {
 489                 nr_irq = pchg->num_irqs;
 490
 491                 virq = irq_create_mapping(irqdm, i);
 492                 pchg->irqs[nr_irq].virq = virq;
 493                 pchg->irqs[nr_irq].which = i;
 494                 pchg->num_irqs++;
 495
 496                 ret = request_threaded_irq(virq, NULL,
 497                                         lp8788_charger_irq_thread,
 498                                         IRQF_ONESHOT, name, pchg);
 499                 if (ret)
 500                         break;
 501         }
 502
 503         if (i <= irq_end)
 504                 goto err_free_irq;
 505
 506         return 0;
 507
 508 err_free_irq:
 509         for (i = 0; i < pchg->num_irqs; i++)
 510                 free_irq(pchg->irqs[i].virq, pchg);
 511         return ret;
 512 }
 513
 514 static int lp8788_irq_register(struct platform_device *pdev,
 515                                 struct lp8788_charger *pchg)
 516 {
 517         static const char * const name[] = {
 518                 LP8788_CHG_IRQ, LP8788_PRSW_IRQ, LP8788_BATT_IRQ
 519         };
 520         int i;
 521         int ret;
 522
 523         INIT_WORK(&pchg->charger_work, lp8788_charger_event);
 524         pchg->num_irqs = 0;
 525
 526         for (i = 0; i < ARRAY_SIZE(name); i++) {
 527                 ret = lp8788_set_irqs(pdev, pchg, name[i]);
 528                 if (ret) {
 529                         dev_warn(&pdev->dev, "irq setup failed: %s\n", name[i]);
 530                         return ret;
 531                 }
 532         }
 533
 534         if (pchg->num_irqs > LP8788_MAX_CHG_IRQS) {
 535                 dev_err(&pdev->dev, "invalid total number of irqs: %d\n",
 536                         pchg->num_irqs);
 537                 return -EINVAL;
 538         }
 539
 540
 541         return 0;
 542 }
 543
 544 static void lp8788_irq_unregister(struct platform_device *pdev,
 545                                   struct lp8788_charger *pchg)
 546 {
 547         int i;
 548         int irq;
 549
 550         for (i = 0; i < pchg->num_irqs; i++) {
 551                 irq = pchg->irqs[i].virq;
 552                 if (!irq)
 553                         continue;
 554
 555                 free_irq(irq, pchg);
 556         }
 557 }
 558
 559 static void lp8788_setup_adc_channel(struct device *dev,
 560                                 struct lp8788_charger *pchg)
 561 {
 562         struct lp8788_charger_platform_data *pdata = pchg->pdata;
 563         struct iio_channel *chan;
 564
 565         if (!pdata)
 566                 return;
 567
 568         /* ADC channel for battery voltage */
 569         chan = devm_iio_channel_get(dev, pdata->adc_vbatt);
 570         pchg->chan[LP8788_VBATT] = IS_ERR(chan) ? NULL : chan;
 571
 572         /* ADC channel for battery temperature */
 573         chan = devm_iio_channel_get(dev, pdata->adc_batt_temp);
 574         pchg->chan[LP8788_BATT_TEMP] = IS_ERR(chan) ? NULL : chan;
 575 }
 576
 577 static ssize_t lp8788_show_charger_status(struct device *dev,
 578                                 struct device_attribute *attr, char *buf)
 579 {
 580         struct lp8788_charger *pchg = dev_get_drvdata(dev);
 581         enum lp8788_charging_state state;
 582         static const char * const desc[LP8788_MAX_CHG_STATE] = {
 583                 [LP8788_OFF] = "CHARGER OFF",
 584                 [LP8788_WARM_UP] = "WARM UP",
 585                 [LP8788_LOW_INPUT] = "LOW INPUT STATE",
 586                 [LP8788_PRECHARGE] = "CHARGING - PRECHARGE",
 587                 [LP8788_CC] = "CHARGING - CC",
 588                 [LP8788_CV] = "CHARGING - CV",
 589                 [LP8788_MAINTENANCE] = "NO CHARGING - MAINTENANCE",
 590                 [LP8788_BATTERY_FAULT] = "BATTERY FAULT",
 591                 [LP8788_SYSTEM_SUPPORT] = "SYSTEM SUPPORT",
 592                 [LP8788_HIGH_CURRENT] = "HIGH CURRENT",
 593         };
 594         u8 data;
 595
 596         lp8788_read_byte(pchg->lp, LP8788_CHG_STATUS, &data);
 597         state = (data & LP8788_CHG_STATE_M) >> LP8788_CHG_STATE_S;
 598
 599         return sysfs_emit(buf, "%s\n", desc[state]);
 600 }
 601
 602 static ssize_t lp8788_show_eoc_time(struct device *dev,
 603                                 struct device_attribute *attr, char *buf)
 604 {
 605         struct lp8788_charger *pchg = dev_get_drvdata(dev);
 606         static const char * const stime[] = {
 607                 "400ms", "5min", "10min", "15min",
 608                 "20min", "25min", "30min", "No timeout"
 609         };
 610         u8 val;
 611
 612         lp8788_read_byte(pchg->lp, LP8788_CHG_EOC, &val);
 613         val = (val & LP8788_CHG_EOC_TIME_M) >> LP8788_CHG_EOC_TIME_S;
 614
 615         return sysfs_emit(buf, "End Of Charge Time: %s\n", stime[val]);
 616 }
 617
 618 static ssize_t lp8788_show_eoc_level(struct device *dev,
 619                                 struct device_attribute *attr, char *buf)
 620 {
 621         struct lp8788_charger *pchg = dev_get_drvdata(dev);
 622         static const char * const abs_level[] = {
 623                         "25mA", "49mA", "75mA", "98mA"
 624         };
 625         static const char * const relative_level[] = {
 626                         "5%", "10%", "15%", "20%"
 627         };
 628         const char *level;
 629         u8 val;
 630         u8 mode;
 631
 632         lp8788_read_byte(pchg->lp, LP8788_CHG_EOC, &val);
 633
 634         mode = val & LP8788_CHG_EOC_MODE_M;
 635         val = (val & LP8788_CHG_EOC_LEVEL_M) >> LP8788_CHG_EOC_LEVEL_S;
 636         level = mode ? abs_level[val] : relative_level[val];
 637
 638         return sysfs_emit(buf, "End Of Charge Level: %s\n", level);
 639 }
 640
 641 static DEVICE_ATTR(charger_status, S_IRUSR, lp8788_show_charger_status, NULL);
 642 static DEVICE_ATTR(eoc_time, S_IRUSR, lp8788_show_eoc_time, NULL);
 643 static DEVICE_ATTR(eoc_level, S_IRUSR, lp8788_show_eoc_level, NULL);
 644
 645 static struct attribute *lp8788_charger_sysfs_attrs[] = {
 646         &dev_attr_charger_status.attr,
 647         &dev_attr_eoc_time.attr,
 648         &dev_attr_eoc_level.attr,
 649         NULL,
 650 };
 651
 652 ATTRIBUTE_GROUPS(lp8788_charger_sysfs);
 653
 654 static int lp8788_psy_register(struct platform_device *pdev,
 655                                 struct lp8788_charger *pchg)
 656 {
 657         struct power_supply_config charger_cfg = {};
 658
 659         charger_cfg.attr_grp = lp8788_charger_sysfs_groups;
 660         charger_cfg.supplied_to = battery_supplied_to;
 661         charger_cfg.num_supplicants = ARRAY_SIZE(battery_supplied_to);
 662
 663         pchg->charger = devm_power_supply_register(&pdev->dev,
 664                                                    &lp8788_psy_charger_desc,
 665                                                    &charger_cfg);
 666         if (IS_ERR(pchg->charger))
 667                 return -EPERM;
 668
 669         pchg->battery = devm_power_supply_register(&pdev->dev,
 670                                                    &lp8788_psy_battery_desc, NULL);
 671         if (IS_ERR(pchg->battery))
 672                 return -EPERM;
 673
 674         return 0;
 675 }
 676
 677 static int lp8788_charger_probe(struct platform_device *pdev)
 678 {
 679         struct lp8788 *lp = dev_get_drvdata(pdev->dev.parent);
 680         struct lp8788_charger *pchg;
 681         struct device *dev = &pdev->dev;
 682         int ret;
 683
 684         pchg = devm_kzalloc(dev, sizeof(struct lp8788_charger), GFP_KERNEL);
 685         if (!pchg)
 686                 return -ENOMEM;
 687
 688         pchg->lp = lp;
 689         pchg->pdata = lp->pdata ? lp->pdata->chg_pdata : NULL;
 690         platform_set_drvdata(pdev, pchg);
 691
 692         ret = lp8788_update_charger_params(pdev, pchg);
 693         if (ret)
 694                 return ret;
 695
 696         lp8788_setup_adc_channel(&pdev->dev, pchg);
 697
 698         ret = lp8788_psy_register(pdev, pchg);
 699         if (ret)
 700                 return ret;
 701
 702         ret = lp8788_irq_register(pdev, pchg);
 703         if (ret)
 704                 dev_warn(dev, "failed to register charger irq: %d\n", ret);
 705
 706         return 0;
 707 }
 708
 709 static void lp8788_charger_remove(struct platform_device *pdev)
 710 {
 711         struct lp8788_charger *pchg = platform_get_drvdata(pdev);
 712
 713         flush_work(&pchg->charger_work);
 714         lp8788_irq_unregister(pdev, pchg);
 715 }
 716
 717 static struct platform_driver lp8788_charger_driver = {
 718         .probe = lp8788_charger_probe,
 719         .remove_new = lp8788_charger_remove,
 720         .driver = {
 721                 .name = LP8788_DEV_CHARGER,
 722         },
 723 };
 724 module_platform_driver(lp8788_charger_driver);
 725
 726 MODULE_DESCRIPTION("TI LP8788 Charger Driver");
 727 MODULE_AUTHOR("Milo Kim");
 728 MODULE_LICENSE("GPL");
 729 MODULE_ALIAS("platform:lp8788-charger");