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