drivers/power/supply/rn5t618_power.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Power supply driver for the RICOH RN5T618 power management chip family
   4  *
   5  * Copyright (C) 2020 Andreas Kemnade
   6  */
   7
   8 #include <linux/kernel.h>
   9 #include <linux/device.h>
  10 #include <linux/bitops.h>
  11 #include <linux/errno.h>
  12 #include <linux/iio/consumer.h>
  13 #include <linux/init.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/module.h>
  16 #include <linux/mfd/rn5t618.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/power_supply.h>
  19 #include <linux/regmap.h>
  20 #include <linux/slab.h>
  21
  22 #define CHG_STATE_ADP_INPUT 0x40
  23 #define CHG_STATE_USB_INPUT 0x80
  24 #define CHG_STATE_MASK  0x1f
  25 #define CHG_STATE_CHG_OFF       0
  26 #define CHG_STATE_CHG_READY_VADP        1
  27 #define CHG_STATE_CHG_TRICKLE   2
  28 #define CHG_STATE_CHG_RAPID     3
  29 #define CHG_STATE_CHG_COMPLETE  4
  30 #define CHG_STATE_SUSPEND       5
  31 #define CHG_STATE_VCHG_OVER_VOL 6
  32 #define CHG_STATE_BAT_ERROR     7
  33 #define CHG_STATE_NO_BAT        8
  34 #define CHG_STATE_BAT_OVER_VOL  9
  35 #define CHG_STATE_BAT_TEMP_ERR  10
  36 #define CHG_STATE_DIE_ERR       11
  37 #define CHG_STATE_DIE_SHUTDOWN  12
  38 #define CHG_STATE_NO_BAT2       13
  39 #define CHG_STATE_CHG_READY_VUSB        14
  40
  41 #define GCHGDET_TYPE_MASK 0x30
  42 #define GCHGDET_TYPE_SDP 0x00
  43 #define GCHGDET_TYPE_CDP 0x10
  44 #define GCHGDET_TYPE_DCP 0x20
  45
  46 #define FG_ENABLE 1
  47
  48 /*
  49  * Formula seems accurate for battery current, but for USB current around 70mA
  50  * per step was seen on Kobo Clara HD but all sources show the same formula
  51  * also fur USB current. To avoid accidentially unwanted high currents we stick
  52  * to that formula
  53  */
  54 #define TO_CUR_REG(x) ((x) / 100000 - 1)
  55 #define FROM_CUR_REG(x) ((((x) & 0x1f) + 1) * 100000)
  56 #define CHG_MIN_CUR 100000
  57 #define CHG_MAX_CUR 1800000
  58 #define ADP_MAX_CUR 2500000
  59 #define USB_MAX_CUR 1400000
  60
  61
  62 struct rn5t618_power_info {
  63         struct rn5t618 *rn5t618;
  64         struct platform_device *pdev;
  65         struct power_supply *battery;
  66         struct power_supply *usb;
  67         struct power_supply *adp;
  68         struct iio_channel *channel_vusb;
  69         struct iio_channel *channel_vadp;
  70         int irq;
  71 };
  72
  73 static enum power_supply_usb_type rn5t618_usb_types[] = {
  74         POWER_SUPPLY_USB_TYPE_SDP,
  75         POWER_SUPPLY_USB_TYPE_DCP,
  76         POWER_SUPPLY_USB_TYPE_CDP,
  77         POWER_SUPPLY_USB_TYPE_UNKNOWN
  78 };
  79
  80 static enum power_supply_property rn5t618_usb_props[] = {
  81         /* input current limit is not very accurate */
  82         POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
  83         POWER_SUPPLY_PROP_VOLTAGE_NOW,
  84         POWER_SUPPLY_PROP_STATUS,
  85         POWER_SUPPLY_PROP_USB_TYPE,
  86         POWER_SUPPLY_PROP_ONLINE,
  87 };
  88
  89 static enum power_supply_property rn5t618_adp_props[] = {
  90         /* input current limit is not very accurate */
  91         POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
  92         POWER_SUPPLY_PROP_VOLTAGE_NOW,
  93         POWER_SUPPLY_PROP_STATUS,
  94         POWER_SUPPLY_PROP_ONLINE,
  95 };
  96
  97
  98 static enum power_supply_property rn5t618_battery_props[] = {
  99         POWER_SUPPLY_PROP_STATUS,
 100         POWER_SUPPLY_PROP_PRESENT,
 101         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 102         POWER_SUPPLY_PROP_CURRENT_NOW,
 103         POWER_SUPPLY_PROP_CAPACITY,
 104         POWER_SUPPLY_PROP_TEMP,
 105         POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
 106         POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
 107         POWER_SUPPLY_PROP_TECHNOLOGY,
 108         POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT,
 109         POWER_SUPPLY_PROP_CHARGE_FULL,
 110         POWER_SUPPLY_PROP_CHARGE_NOW,
 111 };
 112
 113 static int rn5t618_battery_read_doublereg(struct rn5t618_power_info *info,
 114                                           u8 reg, u16 *result)
 115 {
 116         int ret, i;
 117         u8 data[2];
 118         u16 old, new;
 119
 120         old = 0;
 121         /* Prevent races when registers are changing. */
 122         for (i = 0; i < 3; i++) {
 123                 ret = regmap_bulk_read(info->rn5t618->regmap,
 124                                        reg, data, sizeof(data));
 125                 if (ret)
 126                         return ret;
 127
 128                 new = data[0] << 8;
 129                 new |= data[1];
 130                 if (new == old)
 131                         break;
 132
 133                 old = new;
 134         }
 135
 136         *result = new;
 137
 138         return 0;
 139 }
 140
 141 static int rn5t618_decode_status(unsigned int status)
 142 {
 143         switch (status & CHG_STATE_MASK) {
 144         case CHG_STATE_CHG_OFF:
 145         case CHG_STATE_SUSPEND:
 146         case CHG_STATE_VCHG_OVER_VOL:
 147         case CHG_STATE_DIE_SHUTDOWN:
 148                 return POWER_SUPPLY_STATUS_DISCHARGING;
 149
 150         case CHG_STATE_CHG_TRICKLE:
 151         case CHG_STATE_CHG_RAPID:
 152                 return POWER_SUPPLY_STATUS_CHARGING;
 153
 154         case CHG_STATE_CHG_COMPLETE:
 155                 return POWER_SUPPLY_STATUS_FULL;
 156
 157         default:
 158                 return POWER_SUPPLY_STATUS_NOT_CHARGING;
 159         }
 160 }
 161
 162 static int rn5t618_battery_status(struct rn5t618_power_info *info,
 163                                   union power_supply_propval *val)
 164 {
 165         unsigned int v;
 166         int ret;
 167
 168         ret = regmap_read(info->rn5t618->regmap, RN5T618_CHGSTATE, &v);
 169         if (ret)
 170                 return ret;
 171
 172         val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
 173
 174         if (v & 0xc0) { /* USB or ADP plugged */
 175                 val->intval = rn5t618_decode_status(v);
 176         } else
 177                 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 178
 179         return ret;
 180 }
 181
 182 static int rn5t618_battery_present(struct rn5t618_power_info *info,
 183                                    union power_supply_propval *val)
 184 {
 185         unsigned int v;
 186         int ret;
 187
 188         ret = regmap_read(info->rn5t618->regmap, RN5T618_CHGSTATE, &v);
 189         if (ret)
 190                 return ret;
 191
 192         v &= CHG_STATE_MASK;
 193         if ((v == CHG_STATE_NO_BAT) || (v == CHG_STATE_NO_BAT2))
 194                 val->intval = 0;
 195         else
 196                 val->intval = 1;
 197
 198         return ret;
 199 }
 200
 201 static int rn5t618_battery_voltage_now(struct rn5t618_power_info *info,
 202                                        union power_supply_propval *val)
 203 {
 204         u16 res;
 205         int ret;
 206
 207         ret = rn5t618_battery_read_doublereg(info, RN5T618_VOLTAGE_1, &res);
 208         if (ret)
 209                 return ret;
 210
 211         val->intval = res * 2 * 2500 / 4095 * 1000;
 212
 213         return 0;
 214 }
 215
 216 static int rn5t618_battery_current_now(struct rn5t618_power_info *info,
 217                                        union power_supply_propval *val)
 218 {
 219         u16 res;
 220         int ret;
 221
 222         ret = rn5t618_battery_read_doublereg(info, RN5T618_CC_AVEREG1, &res);
 223         if (ret)
 224                 return ret;
 225
 226         /* current is negative when discharging */
 227         val->intval = sign_extend32(res, 13) * 1000;
 228
 229         return 0;
 230 }
 231
 232 static int rn5t618_battery_capacity(struct rn5t618_power_info *info,
 233                                     union power_supply_propval *val)
 234 {
 235         unsigned int v;
 236         int ret;
 237
 238         ret = regmap_read(info->rn5t618->regmap, RN5T618_SOC, &v);
 239         if (ret)
 240                 return ret;
 241
 242         val->intval = v;
 243
 244         return 0;
 245 }
 246
 247 static int rn5t618_battery_temp(struct rn5t618_power_info *info,
 248                                 union power_supply_propval *val)
 249 {
 250         u16 res;
 251         int ret;
 252
 253         ret = rn5t618_battery_read_doublereg(info, RN5T618_TEMP_1, &res);
 254         if (ret)
 255                 return ret;
 256
 257         val->intval = sign_extend32(res, 11) * 10 / 16;
 258
 259         return 0;
 260 }
 261
 262 static int rn5t618_battery_tte(struct rn5t618_power_info *info,
 263                                union power_supply_propval *val)
 264 {
 265         u16 res;
 266         int ret;
 267
 268         ret = rn5t618_battery_read_doublereg(info, RN5T618_TT_EMPTY_H, &res);
 269         if (ret)
 270                 return ret;
 271
 272         if (res == 65535)
 273                 return -ENODATA;
 274
 275         val->intval = res * 60;
 276
 277         return 0;
 278 }
 279
 280 static int rn5t618_battery_ttf(struct rn5t618_power_info *info,
 281                                union power_supply_propval *val)
 282 {
 283         u16 res;
 284         int ret;
 285
 286         ret = rn5t618_battery_read_doublereg(info, RN5T618_TT_FULL_H, &res);
 287         if (ret)
 288                 return ret;
 289
 290         if (res == 65535)
 291                 return -ENODATA;
 292
 293         val->intval = res * 60;
 294
 295         return 0;
 296 }
 297
 298 static int rn5t618_battery_set_current_limit(struct rn5t618_power_info *info,
 299                                 const union power_supply_propval *val)
 300 {
 301         if (val->intval < CHG_MIN_CUR)
 302                 return -EINVAL;
 303
 304         if (val->intval >= CHG_MAX_CUR)
 305                 return -EINVAL;
 306
 307         return regmap_update_bits(info->rn5t618->regmap,
 308                                   RN5T618_CHGISET,
 309                                   0x1F, TO_CUR_REG(val->intval));
 310 }
 311
 312 static int rn5t618_battery_get_current_limit(struct rn5t618_power_info *info,
 313                                              union power_supply_propval *val)
 314 {
 315         unsigned int regval;
 316         int ret;
 317
 318         ret = regmap_read(info->rn5t618->regmap, RN5T618_CHGISET,
 319                           &regval);
 320         if (ret < 0)
 321                 return ret;
 322
 323         val->intval = FROM_CUR_REG(regval);
 324
 325         return 0;
 326 }
 327
 328 static int rn5t618_battery_charge_full(struct rn5t618_power_info *info,
 329                                        union power_supply_propval *val)
 330 {
 331         u16 res;
 332         int ret;
 333
 334         ret = rn5t618_battery_read_doublereg(info, RN5T618_FA_CAP_H, &res);
 335         if (ret)
 336                 return ret;
 337
 338         val->intval = res * 1000;
 339
 340         return 0;
 341 }
 342
 343 static int rn5t618_battery_charge_now(struct rn5t618_power_info *info,
 344                                       union power_supply_propval *val)
 345 {
 346         u16 res;
 347         int ret;
 348
 349         ret = rn5t618_battery_read_doublereg(info, RN5T618_RE_CAP_H, &res);
 350         if (ret)
 351                 return ret;
 352
 353         val->intval = res * 1000;
 354
 355         return 0;
 356 }
 357
 358 static int rn5t618_battery_get_property(struct power_supply *psy,
 359                                         enum power_supply_property psp,
 360                                         union power_supply_propval *val)
 361 {
 362         int ret = 0;
 363         struct rn5t618_power_info *info = power_supply_get_drvdata(psy);
 364
 365         switch (psp) {
 366         case POWER_SUPPLY_PROP_STATUS:
 367                 ret = rn5t618_battery_status(info, val);
 368                 break;
 369         case POWER_SUPPLY_PROP_PRESENT:
 370                 ret = rn5t618_battery_present(info, val);
 371                 break;
 372         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 373                 ret = rn5t618_battery_voltage_now(info, val);
 374                 break;
 375         case POWER_SUPPLY_PROP_CURRENT_NOW:
 376                 ret = rn5t618_battery_current_now(info, val);
 377                 break;
 378         case POWER_SUPPLY_PROP_CAPACITY:
 379                 ret = rn5t618_battery_capacity(info, val);
 380                 break;
 381         case POWER_SUPPLY_PROP_TEMP:
 382                 ret = rn5t618_battery_temp(info, val);
 383                 break;
 384         case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
 385                 ret = rn5t618_battery_tte(info, val);
 386                 break;
 387         case POWER_SUPPLY_PROP_TIME_TO_FULL_NOW:
 388                 ret = rn5t618_battery_ttf(info, val);
 389                 break;
 390         case POWER_SUPPLY_PROP_TECHNOLOGY:
 391                 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
 392                 break;
 393         case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT:
 394                 ret = rn5t618_battery_get_current_limit(info, val);
 395                 break;
 396         case POWER_SUPPLY_PROP_CHARGE_FULL:
 397                 ret = rn5t618_battery_charge_full(info, val);
 398                 break;
 399         case POWER_SUPPLY_PROP_CHARGE_NOW:
 400                 ret = rn5t618_battery_charge_now(info, val);
 401                 break;
 402         default:
 403                 return -EINVAL;
 404         }
 405
 406         return ret;
 407 }
 408
 409 static int rn5t618_battery_set_property(struct power_supply *psy,
 410                                         enum power_supply_property psp,
 411                                         const union power_supply_propval *val)
 412 {
 413         struct rn5t618_power_info *info = power_supply_get_drvdata(psy);
 414
 415         switch (psp) {
 416         case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT:
 417                 return rn5t618_battery_set_current_limit(info, val);
 418         default:
 419                 return -EINVAL;
 420         }
 421 }
 422
 423 static int rn5t618_battery_property_is_writeable(struct power_supply *psy,
 424                                                 enum power_supply_property psp)
 425 {
 426         switch (psp) {
 427         case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT:
 428                 return true;
 429         default:
 430                 return false;
 431         }
 432 }
 433
 434 static int rn5t618_adp_get_property(struct power_supply *psy,
 435                                     enum power_supply_property psp,
 436                                     union power_supply_propval *val)
 437 {
 438         struct rn5t618_power_info *info = power_supply_get_drvdata(psy);
 439         unsigned int chgstate;
 440         unsigned int regval;
 441         bool online;
 442         int ret;
 443
 444         ret = regmap_read(info->rn5t618->regmap, RN5T618_CHGSTATE, &chgstate);
 445         if (ret)
 446                 return ret;
 447
 448         online = !!(chgstate & CHG_STATE_ADP_INPUT);
 449
 450         switch (psp) {
 451         case POWER_SUPPLY_PROP_ONLINE:
 452                 val->intval = online;
 453                 break;
 454         case POWER_SUPPLY_PROP_STATUS:
 455                 if (!online) {
 456                         val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
 457                         break;
 458                 }
 459                 val->intval = rn5t618_decode_status(chgstate);
 460                 if (val->intval != POWER_SUPPLY_STATUS_CHARGING)
 461                         val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
 462
 463                 break;
 464         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
 465                 ret = regmap_read(info->rn5t618->regmap,
 466                                   RN5T618_REGISET1, &regval);
 467                 if (ret < 0)
 468                         return ret;
 469
 470                 val->intval = FROM_CUR_REG(regval);
 471                 break;
 472         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 473                 if (!info->channel_vadp)
 474                         return -ENODATA;
 475
 476                 ret = iio_read_channel_processed_scale(info->channel_vadp, &val->intval, 1000);
 477                 if (ret < 0)
 478                         return ret;
 479
 480                 break;
 481         default:
 482                 return -EINVAL;
 483         }
 484
 485         return 0;
 486 }
 487
 488 static int rn5t618_adp_set_property(struct power_supply *psy,
 489                                     enum power_supply_property psp,
 490                                     const union power_supply_propval *val)
 491 {
 492         struct rn5t618_power_info *info = power_supply_get_drvdata(psy);
 493         int ret;
 494
 495         switch (psp) {
 496         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
 497                 if (val->intval > ADP_MAX_CUR)
 498                         return -EINVAL;
 499
 500                 if (val->intval < CHG_MIN_CUR)
 501                         return -EINVAL;
 502
 503                 ret = regmap_write(info->rn5t618->regmap, RN5T618_REGISET1,
 504                                    TO_CUR_REG(val->intval));
 505                 if (ret < 0)
 506                         return ret;
 507
 508                 break;
 509         default:
 510                 return -EINVAL;
 511         }
 512
 513         return 0;
 514 }
 515
 516 static int rn5t618_adp_property_is_writeable(struct power_supply *psy,
 517                                              enum power_supply_property psp)
 518 {
 519         switch (psp) {
 520         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
 521                 return true;
 522         default:
 523                 return false;
 524         }
 525 }
 526
 527 static int rc5t619_usb_get_type(struct rn5t618_power_info *info,
 528                                 union power_supply_propval *val)
 529 {
 530         unsigned int regval;
 531         int ret;
 532
 533         ret = regmap_read(info->rn5t618->regmap, RN5T618_GCHGDET, &regval);
 534         if (ret < 0)
 535                 return ret;
 536
 537         switch (regval & GCHGDET_TYPE_MASK) {
 538         case GCHGDET_TYPE_SDP:
 539                 val->intval = POWER_SUPPLY_USB_TYPE_SDP;
 540                 break;
 541         case GCHGDET_TYPE_CDP:
 542                 val->intval = POWER_SUPPLY_USB_TYPE_CDP;
 543                 break;
 544         case GCHGDET_TYPE_DCP:
 545                 val->intval = POWER_SUPPLY_USB_TYPE_DCP;
 546                 break;
 547         default:
 548                 val->intval = POWER_SUPPLY_USB_TYPE_UNKNOWN;
 549         }
 550
 551         return 0;
 552 }
 553
 554 static int rn5t618_usb_get_property(struct power_supply *psy,
 555                                     enum power_supply_property psp,
 556                                     union power_supply_propval *val)
 557 {
 558         struct rn5t618_power_info *info = power_supply_get_drvdata(psy);
 559         unsigned int chgstate;
 560         unsigned int regval;
 561         bool online;
 562         int ret;
 563
 564         ret = regmap_read(info->rn5t618->regmap, RN5T618_CHGSTATE, &chgstate);
 565         if (ret)
 566                 return ret;
 567
 568         online = !!(chgstate & CHG_STATE_USB_INPUT);
 569
 570         switch (psp) {
 571         case POWER_SUPPLY_PROP_ONLINE:
 572                 val->intval = online;
 573                 break;
 574         case POWER_SUPPLY_PROP_STATUS:
 575                 if (!online) {
 576                         val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
 577                         break;
 578                 }
 579                 val->intval = rn5t618_decode_status(chgstate);
 580                 if (val->intval != POWER_SUPPLY_STATUS_CHARGING)
 581                         val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
 582
 583                 break;
 584         case POWER_SUPPLY_PROP_USB_TYPE:
 585                 if (!online || (info->rn5t618->variant != RC5T619))
 586                         return -ENODATA;
 587
 588                 return rc5t619_usb_get_type(info, val);
 589         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
 590                 ret = regmap_read(info->rn5t618->regmap, RN5T618_CHGCTL1,
 591                                   &regval);
 592                 if (ret < 0)
 593                         return ret;
 594
 595                 val->intval = 0;
 596                 if (regval & 2) {
 597                         ret = regmap_read(info->rn5t618->regmap,
 598                                           RN5T618_REGISET2,
 599                                           &regval);
 600                         if (ret < 0)
 601                                 return ret;
 602
 603                         val->intval = FROM_CUR_REG(regval);
 604                 }
 605                 break;
 606         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 607                 if (!info->channel_vusb)
 608                         return -ENODATA;
 609
 610                 ret = iio_read_channel_processed_scale(info->channel_vusb, &val->intval, 1000);
 611                 if (ret < 0)
 612                         return ret;
 613
 614                 break;
 615         default:
 616                 return -EINVAL;
 617         }
 618
 619         return 0;
 620 }
 621
 622 static int rn5t618_usb_set_property(struct power_supply *psy,
 623                                     enum power_supply_property psp,
 624                                     const union power_supply_propval *val)
 625 {
 626         struct rn5t618_power_info *info = power_supply_get_drvdata(psy);
 627         int ret;
 628
 629         switch (psp) {
 630         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
 631                 if (val->intval > USB_MAX_CUR)
 632                         return -EINVAL;
 633
 634                 if (val->intval < CHG_MIN_CUR)
 635                         return -EINVAL;
 636
 637                 ret = regmap_write(info->rn5t618->regmap, RN5T618_REGISET2,
 638                                    0xE0 | TO_CUR_REG(val->intval));
 639                 if (ret < 0)
 640                         return ret;
 641
 642                 break;
 643         default:
 644                 return -EINVAL;
 645         }
 646
 647         return 0;
 648 }
 649
 650 static int rn5t618_usb_property_is_writeable(struct power_supply *psy,
 651                                              enum power_supply_property psp)
 652 {
 653         switch (psp) {
 654         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
 655                 return true;
 656         default:
 657                 return false;
 658         }
 659 }
 660
 661 static const struct power_supply_desc rn5t618_battery_desc = {
 662         .name                   = "rn5t618-battery",
 663         .type                   = POWER_SUPPLY_TYPE_BATTERY,
 664         .properties             = rn5t618_battery_props,
 665         .num_properties         = ARRAY_SIZE(rn5t618_battery_props),
 666         .get_property           = rn5t618_battery_get_property,
 667         .set_property           = rn5t618_battery_set_property,
 668         .property_is_writeable  = rn5t618_battery_property_is_writeable,
 669 };
 670
 671 static const struct power_supply_desc rn5t618_adp_desc = {
 672         .name                   = "rn5t618-adp",
 673         .type                   = POWER_SUPPLY_TYPE_MAINS,
 674         .properties             = rn5t618_adp_props,
 675         .num_properties         = ARRAY_SIZE(rn5t618_adp_props),
 676         .get_property           = rn5t618_adp_get_property,
 677         .set_property           = rn5t618_adp_set_property,
 678         .property_is_writeable  = rn5t618_adp_property_is_writeable,
 679 };
 680
 681 static const struct power_supply_desc rn5t618_usb_desc = {
 682         .name                   = "rn5t618-usb",
 683         .type                   = POWER_SUPPLY_TYPE_USB,
 684         .usb_types              = rn5t618_usb_types,
 685         .num_usb_types          = ARRAY_SIZE(rn5t618_usb_types),
 686         .properties             = rn5t618_usb_props,
 687         .num_properties         = ARRAY_SIZE(rn5t618_usb_props),
 688         .get_property           = rn5t618_usb_get_property,
 689         .set_property           = rn5t618_usb_set_property,
 690         .property_is_writeable  = rn5t618_usb_property_is_writeable,
 691 };
 692
 693 static irqreturn_t rn5t618_charger_irq(int irq, void *data)
 694 {
 695         struct device *dev = data;
 696         struct rn5t618_power_info *info = dev_get_drvdata(dev);
 697
 698         unsigned int ctrl, stat1, stat2, err;
 699
 700         regmap_read(info->rn5t618->regmap, RN5T618_CHGERR_IRR, &err);
 701         regmap_read(info->rn5t618->regmap, RN5T618_CHGCTRL_IRR, &ctrl);
 702         regmap_read(info->rn5t618->regmap, RN5T618_CHGSTAT_IRR1, &stat1);
 703         regmap_read(info->rn5t618->regmap, RN5T618_CHGSTAT_IRR2, &stat2);
 704
 705         regmap_write(info->rn5t618->regmap, RN5T618_CHGERR_IRR, 0);
 706         regmap_write(info->rn5t618->regmap, RN5T618_CHGCTRL_IRR, 0);
 707         regmap_write(info->rn5t618->regmap, RN5T618_CHGSTAT_IRR1, 0);
 708         regmap_write(info->rn5t618->regmap, RN5T618_CHGSTAT_IRR2, 0);
 709
 710         dev_dbg(dev, "chgerr: %x chgctrl: %x chgstat: %x chgstat2: %x\n",
 711                 err, ctrl, stat1, stat2);
 712
 713         power_supply_changed(info->usb);
 714         power_supply_changed(info->adp);
 715         power_supply_changed(info->battery);
 716
 717         return IRQ_HANDLED;
 718 }
 719
 720 static int rn5t618_power_probe(struct platform_device *pdev)
 721 {
 722         int ret = 0;
 723         unsigned int v;
 724         struct power_supply_config psy_cfg = {};
 725         struct rn5t618_power_info *info;
 726
 727         info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
 728         if (!info)
 729                 return -ENOMEM;
 730
 731         info->pdev = pdev;
 732         info->rn5t618 = dev_get_drvdata(pdev->dev.parent);
 733         info->irq = -1;
 734
 735         platform_set_drvdata(pdev, info);
 736
 737         info->channel_vusb = devm_iio_channel_get(&pdev->dev, "vusb");
 738         if (IS_ERR(info->channel_vusb)) {
 739                 if (PTR_ERR(info->channel_vusb) == -ENODEV)
 740                         return -EPROBE_DEFER;
 741                 return PTR_ERR(info->channel_vusb);
 742         }
 743
 744         info->channel_vadp = devm_iio_channel_get(&pdev->dev, "vadp");
 745         if (IS_ERR(info->channel_vadp)) {
 746                 if (PTR_ERR(info->channel_vadp) == -ENODEV)
 747                         return -EPROBE_DEFER;
 748                 return PTR_ERR(info->channel_vadp);
 749         }
 750
 751         ret = regmap_read(info->rn5t618->regmap, RN5T618_CONTROL, &v);
 752         if (ret)
 753                 return ret;
 754
 755         if (!(v & FG_ENABLE)) {
 756                 /* E.g. the vendor kernels of various Kobo and Tolino Ebook
 757                  * readers disable the fuel gauge on shutdown. If a kernel
 758                  * without fuel gauge support is booted after that, the fuel
 759                  * gauge will get decalibrated.
 760                  */
 761                 dev_info(&pdev->dev, "Fuel gauge not enabled, enabling now\n");
 762                 dev_info(&pdev->dev, "Expect imprecise results\n");
 763                 regmap_update_bits(info->rn5t618->regmap, RN5T618_CONTROL,
 764                                    FG_ENABLE, FG_ENABLE);
 765         }
 766
 767         psy_cfg.drv_data = info;
 768         info->battery = devm_power_supply_register(&pdev->dev,
 769                                                    &rn5t618_battery_desc,
 770                                                    &psy_cfg);
 771         if (IS_ERR(info->battery)) {
 772                 ret = PTR_ERR(info->battery);
 773                 dev_err(&pdev->dev, "failed to register battery: %d\n", ret);
 774                 return ret;
 775         }
 776
 777         info->adp = devm_power_supply_register(&pdev->dev,
 778                                                &rn5t618_adp_desc,
 779                                                &psy_cfg);
 780         if (IS_ERR(info->adp)) {
 781                 ret = PTR_ERR(info->adp);
 782                 dev_err(&pdev->dev, "failed to register adp: %d\n", ret);
 783                 return ret;
 784         }
 785
 786         info->usb = devm_power_supply_register(&pdev->dev,
 787                                                &rn5t618_usb_desc,
 788                                                &psy_cfg);
 789         if (IS_ERR(info->usb)) {
 790                 ret = PTR_ERR(info->usb);
 791                 dev_err(&pdev->dev, "failed to register usb: %d\n", ret);
 792                 return ret;
 793         }
 794
 795         if (info->rn5t618->irq_data)
 796                 info->irq = regmap_irq_get_virq(info->rn5t618->irq_data,
 797                                                 RN5T618_IRQ_CHG);
 798
 799         if (info->irq < 0)
 800                 info->irq = -1;
 801         else {
 802                 ret = devm_request_threaded_irq(&pdev->dev, info->irq, NULL,
 803                                                 rn5t618_charger_irq,
 804                                                 IRQF_ONESHOT,
 805                                                 "rn5t618_power",
 806                                                 &pdev->dev);
 807
 808                 if (ret < 0) {
 809                         dev_err(&pdev->dev, "request IRQ:%d fail\n",
 810                                 info->irq);
 811                         info->irq = -1;
 812                 }
 813         }
 814
 815         return 0;
 816 }
 817
 818 static struct platform_driver rn5t618_power_driver = {
 819         .driver = {
 820                 .name   = "rn5t618-power",
 821         },
 822         .probe = rn5t618_power_probe,
 823 };
 824
 825 module_platform_driver(rn5t618_power_driver);
 826 MODULE_ALIAS("platform:rn5t618-power");
 827 MODULE_DESCRIPTION("Power supply driver for RICOH RN5T618");
 828 MODULE_LICENSE("GPL");