drivers/power/supply/rt9455_charger.c

   1 /*
   2  * Driver for Richtek RT9455WSC battery charger.
   3  *
   4  * Copyright (C) 2015 Intel Corporation
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  */
  16
  17 #include <linux/module.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/delay.h>
  20 #include <linux/of_irq.h>
  21 #include <linux/of_device.h>
  22 #include <linux/pm_runtime.h>
  23 #include <linux/power_supply.h>
  24 #include <linux/i2c.h>
  25 #include <linux/acpi.h>
  26 #include <linux/usb/phy.h>
  27 #include <linux/regmap.h>
  28
  29 #define RT9455_MANUFACTURER                     "Richtek"
  30 #define RT9455_MODEL_NAME                       "RT9455"
  31 #define RT9455_DRIVER_NAME                      "rt9455-charger"
  32
  33 #define RT9455_IRQ_NAME                         "interrupt"
  34
  35 #define RT9455_PWR_RDY_DELAY                    1 /* 1 second */
  36 #define RT9455_MAX_CHARGING_TIME                21600 /* 6 hrs */
  37 #define RT9455_BATT_PRESENCE_DELAY              60 /* 60 seconds */
  38
  39 #define RT9455_CHARGE_MODE                      0x00
  40 #define RT9455_BOOST_MODE                       0x01
  41
  42 #define RT9455_FAULT                            0x03
  43
  44 #define RT9455_IAICR_100MA                      0x00
  45 #define RT9455_IAICR_500MA                      0x01
  46 #define RT9455_IAICR_NO_LIMIT                   0x03
  47
  48 #define RT9455_CHARGE_DISABLE                   0x00
  49 #define RT9455_CHARGE_ENABLE                    0x01
  50
  51 #define RT9455_PWR_FAULT                        0x00
  52 #define RT9455_PWR_GOOD                         0x01
  53
  54 #define RT9455_REG_CTRL1                        0x00 /* CTRL1 reg address */
  55 #define RT9455_REG_CTRL2                        0x01 /* CTRL2 reg address */
  56 #define RT9455_REG_CTRL3                        0x02 /* CTRL3 reg address */
  57 #define RT9455_REG_DEV_ID                       0x03 /* DEV_ID reg address */
  58 #define RT9455_REG_CTRL4                        0x04 /* CTRL4 reg address */
  59 #define RT9455_REG_CTRL5                        0x05 /* CTRL5 reg address */
  60 #define RT9455_REG_CTRL6                        0x06 /* CTRL6 reg address */
  61 #define RT9455_REG_CTRL7                        0x07 /* CTRL7 reg address */
  62 #define RT9455_REG_IRQ1                         0x08 /* IRQ1 reg address */
  63 #define RT9455_REG_IRQ2                         0x09 /* IRQ2 reg address */
  64 #define RT9455_REG_IRQ3                         0x0A /* IRQ3 reg address */
  65 #define RT9455_REG_MASK1                        0x0B /* MASK1 reg address */
  66 #define RT9455_REG_MASK2                        0x0C /* MASK2 reg address */
  67 #define RT9455_REG_MASK3                        0x0D /* MASK3 reg address */
  68
  69 enum rt9455_fields {
  70         F_STAT, F_BOOST, F_PWR_RDY, F_OTG_PIN_POLARITY, /* CTRL1 reg fields */
  71
  72         F_IAICR, F_TE_SHDN_EN, F_HIGHER_OCP, F_TE, F_IAICR_INT, F_HIZ,
  73         F_OPA_MODE, /* CTRL2 reg fields */
  74
  75         F_VOREG, F_OTG_PL, F_OTG_EN, /* CTRL3 reg fields */
  76
  77         F_VENDOR_ID, F_CHIP_REV, /* DEV_ID reg fields */
  78
  79         F_RST, /* CTRL4 reg fields */
  80
  81         F_TMR_EN, F_MIVR, F_IPREC, F_IEOC_PERCENTAGE, /* CTRL5 reg fields*/
  82
  83         F_IAICR_SEL, F_ICHRG, F_VPREC, /* CTRL6 reg fields */
  84
  85         F_BATD_EN, F_CHG_EN, F_VMREG, /* CTRL7 reg fields */
  86
  87         F_TSDI, F_VINOVPI, F_BATAB, /* IRQ1 reg fields */
  88
  89         F_CHRVPI, F_CHBATOVI, F_CHTERMI, F_CHRCHGI, F_CH32MI, F_CHTREGI,
  90         F_CHMIVRI, /* IRQ2 reg fields */
  91
  92         F_BSTBUSOVI, F_BSTOLI, F_BSTLOWVI, F_BST32SI, /* IRQ3 reg fields */
  93
  94         F_TSDM, F_VINOVPIM, F_BATABM, /* MASK1 reg fields */
  95
  96         F_CHRVPIM, F_CHBATOVIM, F_CHTERMIM, F_CHRCHGIM, F_CH32MIM, F_CHTREGIM,
  97         F_CHMIVRIM, /* MASK2 reg fields */
  98
  99         F_BSTVINOVIM, F_BSTOLIM, F_BSTLOWVIM, F_BST32SIM, /* MASK3 reg fields */
 100
 101         F_MAX_FIELDS
 102 };
 103
 104 static const struct reg_field rt9455_reg_fields[] = {
 105         [F_STAT]                = REG_FIELD(RT9455_REG_CTRL1, 4, 5),
 106         [F_BOOST]               = REG_FIELD(RT9455_REG_CTRL1, 3, 3),
 107         [F_PWR_RDY]             = REG_FIELD(RT9455_REG_CTRL1, 2, 2),
 108         [F_OTG_PIN_POLARITY]    = REG_FIELD(RT9455_REG_CTRL1, 1, 1),
 109
 110         [F_IAICR]               = REG_FIELD(RT9455_REG_CTRL2, 6, 7),
 111         [F_TE_SHDN_EN]          = REG_FIELD(RT9455_REG_CTRL2, 5, 5),
 112         [F_HIGHER_OCP]          = REG_FIELD(RT9455_REG_CTRL2, 4, 4),
 113         [F_TE]                  = REG_FIELD(RT9455_REG_CTRL2, 3, 3),
 114         [F_IAICR_INT]           = REG_FIELD(RT9455_REG_CTRL2, 2, 2),
 115         [F_HIZ]                 = REG_FIELD(RT9455_REG_CTRL2, 1, 1),
 116         [F_OPA_MODE]            = REG_FIELD(RT9455_REG_CTRL2, 0, 0),
 117
 118         [F_VOREG]               = REG_FIELD(RT9455_REG_CTRL3, 2, 7),
 119         [F_OTG_PL]              = REG_FIELD(RT9455_REG_CTRL3, 1, 1),
 120         [F_OTG_EN]              = REG_FIELD(RT9455_REG_CTRL3, 0, 0),
 121
 122         [F_VENDOR_ID]           = REG_FIELD(RT9455_REG_DEV_ID, 4, 7),
 123         [F_CHIP_REV]            = REG_FIELD(RT9455_REG_DEV_ID, 0, 3),
 124
 125         [F_RST]                 = REG_FIELD(RT9455_REG_CTRL4, 7, 7),
 126
 127         [F_TMR_EN]              = REG_FIELD(RT9455_REG_CTRL5, 7, 7),
 128         [F_MIVR]                = REG_FIELD(RT9455_REG_CTRL5, 4, 5),
 129         [F_IPREC]               = REG_FIELD(RT9455_REG_CTRL5, 2, 3),
 130         [F_IEOC_PERCENTAGE]     = REG_FIELD(RT9455_REG_CTRL5, 0, 1),
 131
 132         [F_IAICR_SEL]           = REG_FIELD(RT9455_REG_CTRL6, 7, 7),
 133         [F_ICHRG]               = REG_FIELD(RT9455_REG_CTRL6, 4, 6),
 134         [F_VPREC]               = REG_FIELD(RT9455_REG_CTRL6, 0, 2),
 135
 136         [F_BATD_EN]             = REG_FIELD(RT9455_REG_CTRL7, 6, 6),
 137         [F_CHG_EN]              = REG_FIELD(RT9455_REG_CTRL7, 4, 4),
 138         [F_VMREG]               = REG_FIELD(RT9455_REG_CTRL7, 0, 3),
 139
 140         [F_TSDI]                = REG_FIELD(RT9455_REG_IRQ1, 7, 7),
 141         [F_VINOVPI]             = REG_FIELD(RT9455_REG_IRQ1, 6, 6),
 142         [F_BATAB]               = REG_FIELD(RT9455_REG_IRQ1, 0, 0),
 143
 144         [F_CHRVPI]              = REG_FIELD(RT9455_REG_IRQ2, 7, 7),
 145         [F_CHBATOVI]            = REG_FIELD(RT9455_REG_IRQ2, 5, 5),
 146         [F_CHTERMI]             = REG_FIELD(RT9455_REG_IRQ2, 4, 4),
 147         [F_CHRCHGI]             = REG_FIELD(RT9455_REG_IRQ2, 3, 3),
 148         [F_CH32MI]              = REG_FIELD(RT9455_REG_IRQ2, 2, 2),
 149         [F_CHTREGI]             = REG_FIELD(RT9455_REG_IRQ2, 1, 1),
 150         [F_CHMIVRI]             = REG_FIELD(RT9455_REG_IRQ2, 0, 0),
 151
 152         [F_BSTBUSOVI]           = REG_FIELD(RT9455_REG_IRQ3, 7, 7),
 153         [F_BSTOLI]              = REG_FIELD(RT9455_REG_IRQ3, 6, 6),
 154         [F_BSTLOWVI]            = REG_FIELD(RT9455_REG_IRQ3, 5, 5),
 155         [F_BST32SI]             = REG_FIELD(RT9455_REG_IRQ3, 3, 3),
 156
 157         [F_TSDM]                = REG_FIELD(RT9455_REG_MASK1, 7, 7),
 158         [F_VINOVPIM]            = REG_FIELD(RT9455_REG_MASK1, 6, 6),
 159         [F_BATABM]              = REG_FIELD(RT9455_REG_MASK1, 0, 0),
 160
 161         [F_CHRVPIM]             = REG_FIELD(RT9455_REG_MASK2, 7, 7),
 162         [F_CHBATOVIM]           = REG_FIELD(RT9455_REG_MASK2, 5, 5),
 163         [F_CHTERMIM]            = REG_FIELD(RT9455_REG_MASK2, 4, 4),
 164         [F_CHRCHGIM]            = REG_FIELD(RT9455_REG_MASK2, 3, 3),
 165         [F_CH32MIM]             = REG_FIELD(RT9455_REG_MASK2, 2, 2),
 166         [F_CHTREGIM]            = REG_FIELD(RT9455_REG_MASK2, 1, 1),
 167         [F_CHMIVRIM]            = REG_FIELD(RT9455_REG_MASK2, 0, 0),
 168
 169         [F_BSTVINOVIM]          = REG_FIELD(RT9455_REG_MASK3, 7, 7),
 170         [F_BSTOLIM]             = REG_FIELD(RT9455_REG_MASK3, 6, 6),
 171         [F_BSTLOWVIM]           = REG_FIELD(RT9455_REG_MASK3, 5, 5),
 172         [F_BST32SIM]            = REG_FIELD(RT9455_REG_MASK3, 3, 3),
 173 };
 174
 175 #define GET_MASK(fid)   (BIT(rt9455_reg_fields[fid].msb + 1) - \
 176                          BIT(rt9455_reg_fields[fid].lsb))
 177
 178 /*
 179  * Each array initialised below shows the possible real-world values for a
 180  * group of bits belonging to RT9455 registers. The arrays are sorted in
 181  * ascending order. The index of each real-world value represents the value
 182  * that is encoded in the group of bits belonging to RT9455 registers.
 183  */
 184 /* REG06[6:4] (ICHRG) in uAh */
 185 static const int rt9455_ichrg_values[] = {
 186          500000,  650000,  800000,  950000, 1100000, 1250000, 1400000, 1550000
 187 };
 188
 189 /*
 190  * When the charger is in charge mode, REG02[7:2] represent battery regulation
 191  * voltage.
 192  */
 193 /* REG02[7:2] (VOREG) in uV */
 194 static const int rt9455_voreg_values[] = {
 195         3500000, 3520000, 3540000, 3560000, 3580000, 3600000, 3620000, 3640000,
 196         3660000, 3680000, 3700000, 3720000, 3740000, 3760000, 3780000, 3800000,
 197         3820000, 3840000, 3860000, 3880000, 3900000, 3920000, 3940000, 3960000,
 198         3980000, 4000000, 4020000, 4040000, 4060000, 4080000, 4100000, 4120000,
 199         4140000, 4160000, 4180000, 4200000, 4220000, 4240000, 4260000, 4280000,
 200         4300000, 4330000, 4350000, 4370000, 4390000, 4410000, 4430000, 4450000,
 201         4450000, 4450000, 4450000, 4450000, 4450000, 4450000, 4450000, 4450000,
 202         4450000, 4450000, 4450000, 4450000, 4450000, 4450000, 4450000, 4450000
 203 };
 204
 205 /*
 206  * When the charger is in boost mode, REG02[7:2] represent boost output
 207  * voltage.
 208  */
 209 /* REG02[7:2] (Boost output voltage) in uV */
 210 static const int rt9455_boost_voltage_values[] = {
 211         4425000, 4450000, 4475000, 4500000, 4525000, 4550000, 4575000, 4600000,
 212         4625000, 4650000, 4675000, 4700000, 4725000, 4750000, 4775000, 4800000,
 213         4825000, 4850000, 4875000, 4900000, 4925000, 4950000, 4975000, 5000000,
 214         5025000, 5050000, 5075000, 5100000, 5125000, 5150000, 5175000, 5200000,
 215         5225000, 5250000, 5275000, 5300000, 5325000, 5350000, 5375000, 5400000,
 216         5425000, 5450000, 5475000, 5500000, 5525000, 5550000, 5575000, 5600000,
 217         5600000, 5600000, 5600000, 5600000, 5600000, 5600000, 5600000, 5600000,
 218         5600000, 5600000, 5600000, 5600000, 5600000, 5600000, 5600000, 5600000,
 219 };
 220
 221 /* REG07[3:0] (VMREG) in uV */
 222 static const int rt9455_vmreg_values[] = {
 223         4200000, 4220000, 4240000, 4260000, 4280000, 4300000, 4320000, 4340000,
 224         4360000, 4380000, 4400000, 4430000, 4450000, 4450000, 4450000, 4450000
 225 };
 226
 227 /* REG05[5:4] (IEOC_PERCENTAGE) */
 228 static const int rt9455_ieoc_percentage_values[] = {
 229         10, 30, 20, 30
 230 };
 231
 232 /* REG05[1:0] (MIVR) in uV */
 233 static const int rt9455_mivr_values[] = {
 234         4000000, 4250000, 4500000, 5000000
 235 };
 236
 237 /* REG05[1:0] (IAICR) in uA */
 238 static const int rt9455_iaicr_values[] = {
 239         100000, 500000, 1000000, 2000000
 240 };
 241
 242 struct rt9455_info {
 243         struct i2c_client               *client;
 244         struct regmap                   *regmap;
 245         struct regmap_field             *regmap_fields[F_MAX_FIELDS];
 246         struct power_supply             *charger;
 247 #if IS_ENABLED(CONFIG_USB_PHY)
 248         struct usb_phy                  *usb_phy;
 249         struct notifier_block           nb;
 250 #endif
 251         struct delayed_work             pwr_rdy_work;
 252         struct delayed_work             max_charging_time_work;
 253         struct delayed_work             batt_presence_work;
 254         u32                             voreg;
 255         u32                             boost_voltage;
 256 };
 257
 258 /*
 259  * Iterate through each element of the 'tbl' array until an element whose value
 260  * is greater than v is found. Return the index of the respective element,
 261  * or the index of the last element in the array, if no such element is found.
 262  */
 263 static unsigned int rt9455_find_idx(const int tbl[], int tbl_size, int v)
 264 {
 265         int i;
 266
 267         /*
 268          * No need to iterate until the last index in the table because
 269          * if no element greater than v is found in the table,
 270          * or if only the last element is greater than v,
 271          * function returns the index of the last element.
 272          */
 273         for (i = 0; i < tbl_size - 1; i++)
 274                 if (v <= tbl[i])
 275                         return i;
 276
 277         return (tbl_size - 1);
 278 }
 279
 280 static int rt9455_get_field_val(struct rt9455_info *info,
 281                                 enum rt9455_fields field,
 282                                 const int tbl[], int tbl_size, int *val)
 283 {
 284         unsigned int v;
 285         int ret;
 286
 287         ret = regmap_field_read(info->regmap_fields[field], &v);
 288         if (ret)
 289                 return ret;
 290
 291         v = (v >= tbl_size) ? (tbl_size - 1) : v;
 292         *val = tbl[v];
 293
 294         return 0;
 295 }
 296
 297 static int rt9455_set_field_val(struct rt9455_info *info,
 298                                 enum rt9455_fields field,
 299                                 const int tbl[], int tbl_size, int val)
 300 {
 301         unsigned int idx = rt9455_find_idx(tbl, tbl_size, val);
 302
 303         return regmap_field_write(info->regmap_fields[field], idx);
 304 }
 305
 306 static int rt9455_register_reset(struct rt9455_info *info)
 307 {
 308         struct device *dev = &info->client->dev;
 309         unsigned int v;
 310         int ret, limit = 100;
 311
 312         ret = regmap_field_write(info->regmap_fields[F_RST], 0x01);
 313         if (ret) {
 314                 dev_err(dev, "Failed to set RST bit\n");
 315                 return ret;
 316         }
 317
 318         /*
 319          * To make sure that reset operation has finished, loop until RST bit
 320          * is set to 0.
 321          */
 322         do {
 323                 ret = regmap_field_read(info->regmap_fields[F_RST], &v);
 324                 if (ret) {
 325                         dev_err(dev, "Failed to read RST bit\n");
 326                         return ret;
 327                 }
 328
 329                 if (!v)
 330                         break;
 331
 332                 usleep_range(10, 100);
 333         } while (--limit);
 334
 335         if (!limit)
 336                 return -EIO;
 337
 338         return 0;
 339 }
 340
 341 /* Charger power supply property routines */
 342 static enum power_supply_property rt9455_charger_properties[] = {
 343         POWER_SUPPLY_PROP_STATUS,
 344         POWER_SUPPLY_PROP_HEALTH,
 345         POWER_SUPPLY_PROP_PRESENT,
 346         POWER_SUPPLY_PROP_ONLINE,
 347         POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
 348         POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
 349         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
 350         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
 351         POWER_SUPPLY_PROP_SCOPE,
 352         POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT,
 353         POWER_SUPPLY_PROP_MODEL_NAME,
 354         POWER_SUPPLY_PROP_MANUFACTURER,
 355 };
 356
 357 static char *rt9455_charger_supplied_to[] = {
 358         "main-battery",
 359 };
 360
 361 static int rt9455_charger_get_status(struct rt9455_info *info,
 362                                      union power_supply_propval *val)
 363 {
 364         unsigned int v, pwr_rdy;
 365         int ret;
 366
 367         ret = regmap_field_read(info->regmap_fields[F_PWR_RDY],
 368                                 &pwr_rdy);
 369         if (ret) {
 370                 dev_err(&info->client->dev, "Failed to read PWR_RDY bit\n");
 371                 return ret;
 372         }
 373
 374         /*
 375          * If PWR_RDY bit is unset, the battery is discharging. Otherwise,
 376          * STAT bits value must be checked.
 377          */
 378         if (!pwr_rdy) {
 379                 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 380                 return 0;
 381         }
 382
 383         ret = regmap_field_read(info->regmap_fields[F_STAT], &v);
 384         if (ret) {
 385                 dev_err(&info->client->dev, "Failed to read STAT bits\n");
 386                 return ret;
 387         }
 388
 389         switch (v) {
 390         case 0:
 391                 /*
 392                  * If PWR_RDY bit is set, but STAT bits value is 0, the charger
 393                  * may be in one of the following cases:
 394                  * 1. CHG_EN bit is 0.
 395                  * 2. CHG_EN bit is 1 but the battery is not connected.
 396                  * In any of these cases, POWER_SUPPLY_STATUS_NOT_CHARGING is
 397                  * returned.
 398                  */
 399                 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
 400                 return 0;
 401         case 1:
 402                 val->intval = POWER_SUPPLY_STATUS_CHARGING;
 403                 return 0;
 404         case 2:
 405                 val->intval = POWER_SUPPLY_STATUS_FULL;
 406                 return 0;
 407         default:
 408                 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
 409                 return 0;
 410         }
 411 }
 412
 413 static int rt9455_charger_get_health(struct rt9455_info *info,
 414                                      union power_supply_propval *val)
 415 {
 416         struct device *dev = &info->client->dev;
 417         unsigned int v;
 418         int ret;
 419
 420         val->intval = POWER_SUPPLY_HEALTH_GOOD;
 421
 422         ret = regmap_read(info->regmap, RT9455_REG_IRQ1, &v);
 423         if (ret) {
 424                 dev_err(dev, "Failed to read IRQ1 register\n");
 425                 return ret;
 426         }
 427
 428         if (v & GET_MASK(F_TSDI)) {
 429                 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
 430                 return 0;
 431         }
 432         if (v & GET_MASK(F_VINOVPI)) {
 433                 val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
 434                 return 0;
 435         }
 436         if (v & GET_MASK(F_BATAB)) {
 437                 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
 438                 return 0;
 439         }
 440
 441         ret = regmap_read(info->regmap, RT9455_REG_IRQ2, &v);
 442         if (ret) {
 443                 dev_err(dev, "Failed to read IRQ2 register\n");
 444                 return ret;
 445         }
 446
 447         if (v & GET_MASK(F_CHBATOVI)) {
 448                 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
 449                 return 0;
 450         }
 451         if (v & GET_MASK(F_CH32MI)) {
 452                 val->intval = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
 453                 return 0;
 454         }
 455
 456         ret = regmap_read(info->regmap, RT9455_REG_IRQ3, &v);
 457         if (ret) {
 458                 dev_err(dev, "Failed to read IRQ3 register\n");
 459                 return ret;
 460         }
 461
 462         if (v & GET_MASK(F_BSTBUSOVI)) {
 463                 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
 464                 return 0;
 465         }
 466         if (v & GET_MASK(F_BSTOLI)) {
 467                 val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
 468                 return 0;
 469         }
 470         if (v & GET_MASK(F_BSTLOWVI)) {
 471                 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
 472                 return 0;
 473         }
 474         if (v & GET_MASK(F_BST32SI)) {
 475                 val->intval = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
 476                 return 0;
 477         }
 478
 479         ret = regmap_field_read(info->regmap_fields[F_STAT], &v);
 480         if (ret) {
 481                 dev_err(dev, "Failed to read STAT bits\n");
 482                 return ret;
 483         }
 484
 485         if (v == RT9455_FAULT) {
 486                 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
 487                 return 0;
 488         }
 489
 490         return 0;
 491 }
 492
 493 static int rt9455_charger_get_battery_presence(struct rt9455_info *info,
 494                                                union power_supply_propval *val)
 495 {
 496         unsigned int v;
 497         int ret;
 498
 499         ret = regmap_field_read(info->regmap_fields[F_BATAB], &v);
 500         if (ret) {
 501                 dev_err(&info->client->dev, "Failed to read BATAB bit\n");
 502                 return ret;
 503         }
 504
 505         /*
 506          * Since BATAB is 1 when battery is NOT present and 0 otherwise,
 507          * !BATAB is returned.
 508          */
 509         val->intval = !v;
 510
 511         return 0;
 512 }
 513
 514 static int rt9455_charger_get_online(struct rt9455_info *info,
 515                                      union power_supply_propval *val)
 516 {
 517         unsigned int v;
 518         int ret;
 519
 520         ret = regmap_field_read(info->regmap_fields[F_PWR_RDY], &v);
 521         if (ret) {
 522                 dev_err(&info->client->dev, "Failed to read PWR_RDY bit\n");
 523                 return ret;
 524         }
 525
 526         val->intval = (int)v;
 527
 528         return 0;
 529 }
 530
 531 static int rt9455_charger_get_current(struct rt9455_info *info,
 532                                       union power_supply_propval *val)
 533 {
 534         int curr;
 535         int ret;
 536
 537         ret = rt9455_get_field_val(info, F_ICHRG,
 538                                    rt9455_ichrg_values,
 539                                    ARRAY_SIZE(rt9455_ichrg_values),
 540                                    &curr);
 541         if (ret) {
 542                 dev_err(&info->client->dev, "Failed to read ICHRG value\n");
 543                 return ret;
 544         }
 545
 546         val->intval = curr;
 547
 548         return 0;
 549 }
 550
 551 static int rt9455_charger_get_current_max(struct rt9455_info *info,
 552                                           union power_supply_propval *val)
 553 {
 554         int idx = ARRAY_SIZE(rt9455_ichrg_values) - 1;
 555
 556         val->intval = rt9455_ichrg_values[idx];
 557
 558         return 0;
 559 }
 560
 561 static int rt9455_charger_get_voltage(struct rt9455_info *info,
 562                                       union power_supply_propval *val)
 563 {
 564         int voltage;
 565         int ret;
 566
 567         ret = rt9455_get_field_val(info, F_VOREG,
 568                                    rt9455_voreg_values,
 569                                    ARRAY_SIZE(rt9455_voreg_values),
 570                                    &voltage);
 571         if (ret) {
 572                 dev_err(&info->client->dev, "Failed to read VOREG value\n");
 573                 return ret;
 574         }
 575
 576         val->intval = voltage;
 577
 578         return 0;
 579 }
 580
 581 static int rt9455_charger_get_voltage_max(struct rt9455_info *info,
 582                                           union power_supply_propval *val)
 583 {
 584         int idx = ARRAY_SIZE(rt9455_vmreg_values) - 1;
 585
 586         val->intval = rt9455_vmreg_values[idx];
 587
 588         return 0;
 589 }
 590
 591 static int rt9455_charger_get_term_current(struct rt9455_info *info,
 592                                            union power_supply_propval *val)
 593 {
 594         struct device *dev = &info->client->dev;
 595         int ichrg, ieoc_percentage, ret;
 596
 597         ret = rt9455_get_field_val(info, F_ICHRG,
 598                                    rt9455_ichrg_values,
 599                                    ARRAY_SIZE(rt9455_ichrg_values),
 600                                    &ichrg);
 601         if (ret) {
 602                 dev_err(dev, "Failed to read ICHRG value\n");
 603                 return ret;
 604         }
 605
 606         ret = rt9455_get_field_val(info, F_IEOC_PERCENTAGE,
 607                                    rt9455_ieoc_percentage_values,
 608                                    ARRAY_SIZE(rt9455_ieoc_percentage_values),
 609                                    &ieoc_percentage);
 610         if (ret) {
 611                 dev_err(dev, "Failed to read IEOC value\n");
 612                 return ret;
 613         }
 614
 615         val->intval = ichrg * ieoc_percentage / 100;
 616
 617         return 0;
 618 }
 619
 620 static int rt9455_charger_get_property(struct power_supply *psy,
 621                                        enum power_supply_property psp,
 622                                        union power_supply_propval *val)
 623 {
 624         struct rt9455_info *info = power_supply_get_drvdata(psy);
 625
 626         switch (psp) {
 627         case POWER_SUPPLY_PROP_STATUS:
 628                 return rt9455_charger_get_status(info, val);
 629         case POWER_SUPPLY_PROP_HEALTH:
 630                 return rt9455_charger_get_health(info, val);
 631         case POWER_SUPPLY_PROP_PRESENT:
 632                 return rt9455_charger_get_battery_presence(info, val);
 633         case POWER_SUPPLY_PROP_ONLINE:
 634                 return rt9455_charger_get_online(info, val);
 635         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
 636                 return rt9455_charger_get_current(info, val);
 637         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
 638                 return rt9455_charger_get_current_max(info, val);
 639         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
 640                 return rt9455_charger_get_voltage(info, val);
 641         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
 642                 return rt9455_charger_get_voltage_max(info, val);
 643         case POWER_SUPPLY_PROP_SCOPE:
 644                 val->intval = POWER_SUPPLY_SCOPE_SYSTEM;
 645                 return 0;
 646         case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
 647                 return rt9455_charger_get_term_current(info, val);
 648         case POWER_SUPPLY_PROP_MODEL_NAME:
 649                 val->strval = RT9455_MODEL_NAME;
 650                 return 0;
 651         case POWER_SUPPLY_PROP_MANUFACTURER:
 652                 val->strval = RT9455_MANUFACTURER;
 653                 return 0;
 654         default:
 655                 return -ENODATA;
 656         }
 657 }
 658
 659 static int rt9455_hw_init(struct rt9455_info *info, u32 ichrg,
 660                           u32 ieoc_percentage,
 661                           u32 mivr, u32 iaicr)
 662 {
 663         struct device *dev = &info->client->dev;
 664         int idx, ret;
 665
 666         ret = rt9455_register_reset(info);
 667         if (ret) {
 668                 dev_err(dev, "Power On Reset failed\n");
 669                 return ret;
 670         }
 671
 672         /* Set TE bit in order to enable end of charge detection */
 673         ret = regmap_field_write(info->regmap_fields[F_TE], 1);
 674         if (ret) {
 675                 dev_err(dev, "Failed to set TE bit\n");
 676                 return ret;
 677         }
 678
 679         /* Set TE_SHDN_EN bit in order to enable end of charge detection */
 680         ret = regmap_field_write(info->regmap_fields[F_TE_SHDN_EN], 1);
 681         if (ret) {
 682                 dev_err(dev, "Failed to set TE_SHDN_EN bit\n");
 683                 return ret;
 684         }
 685
 686         /*
 687          * Set BATD_EN bit in order to enable battery detection
 688          * when charging is done
 689          */
 690         ret = regmap_field_write(info->regmap_fields[F_BATD_EN], 1);
 691         if (ret) {
 692                 dev_err(dev, "Failed to set BATD_EN bit\n");
 693                 return ret;
 694         }
 695
 696         /*
 697          * Disable Safety Timer. In charge mode, this timer terminates charging
 698          * if no read or write via I2C is done within 32 minutes. This timer
 699          * avoids overcharging the baterry when the OS is not loaded and the
 700          * charger is connected to a power source.
 701          * In boost mode, this timer triggers BST32SI interrupt if no read or
 702          * write via I2C is done within 32 seconds.
 703          * When the OS is loaded and the charger driver is inserted, it is used
 704          * delayed_work, named max_charging_time_work, to avoid overcharging
 705          * the battery.
 706          */
 707         ret = regmap_field_write(info->regmap_fields[F_TMR_EN], 0x00);
 708         if (ret) {
 709                 dev_err(dev, "Failed to disable Safety Timer\n");
 710                 return ret;
 711         }
 712
 713         /* Set ICHRG to value retrieved from device-specific data */
 714         ret = rt9455_set_field_val(info, F_ICHRG,
 715                                    rt9455_ichrg_values,
 716                                    ARRAY_SIZE(rt9455_ichrg_values), ichrg);
 717         if (ret) {
 718                 dev_err(dev, "Failed to set ICHRG value\n");
 719                 return ret;
 720         }
 721
 722         /* Set IEOC Percentage to value retrieved from device-specific data */
 723         ret = rt9455_set_field_val(info, F_IEOC_PERCENTAGE,
 724                                    rt9455_ieoc_percentage_values,
 725                                    ARRAY_SIZE(rt9455_ieoc_percentage_values),
 726                                    ieoc_percentage);
 727         if (ret) {
 728                 dev_err(dev, "Failed to set IEOC Percentage value\n");
 729                 return ret;
 730         }
 731
 732         /* Set VOREG to value retrieved from device-specific data */
 733         ret = rt9455_set_field_val(info, F_VOREG,
 734                                    rt9455_voreg_values,
 735                                    ARRAY_SIZE(rt9455_voreg_values),
 736                                    info->voreg);
 737         if (ret) {
 738                 dev_err(dev, "Failed to set VOREG value\n");
 739                 return ret;
 740         }
 741
 742         /* Set VMREG value to maximum (4.45V). */
 743         idx = ARRAY_SIZE(rt9455_vmreg_values) - 1;
 744         ret = rt9455_set_field_val(info, F_VMREG,
 745                                    rt9455_vmreg_values,
 746                                    ARRAY_SIZE(rt9455_vmreg_values),
 747                                    rt9455_vmreg_values[idx]);
 748         if (ret) {
 749                 dev_err(dev, "Failed to set VMREG value\n");
 750                 return ret;
 751         }
 752
 753         /*
 754          * Set MIVR to value retrieved from device-specific data.
 755          * If no value is specified, default value for MIVR is 4.5V.
 756          */
 757         if (mivr == -1)
 758                 mivr = 4500000;
 759
 760         ret = rt9455_set_field_val(info, F_MIVR,
 761                                    rt9455_mivr_values,
 762                                    ARRAY_SIZE(rt9455_mivr_values), mivr);
 763         if (ret) {
 764                 dev_err(dev, "Failed to set MIVR value\n");
 765                 return ret;
 766         }
 767
 768         /*
 769          * Set IAICR to value retrieved from device-specific data.
 770          * If no value is specified, default value for IAICR is 500 mA.
 771          */
 772         if (iaicr == -1)
 773                 iaicr = 500000;
 774
 775         ret = rt9455_set_field_val(info, F_IAICR,
 776                                    rt9455_iaicr_values,
 777                                    ARRAY_SIZE(rt9455_iaicr_values), iaicr);
 778         if (ret) {
 779                 dev_err(dev, "Failed to set IAICR value\n");
 780                 return ret;
 781         }
 782
 783         /*
 784          * Set IAICR_INT bit so that IAICR value is determined by IAICR bits
 785          * and not by OTG pin.
 786          */
 787         ret = regmap_field_write(info->regmap_fields[F_IAICR_INT], 0x01);
 788         if (ret) {
 789                 dev_err(dev, "Failed to set IAICR_INT bit\n");
 790                 return ret;
 791         }
 792
 793         /*
 794          * Disable CHMIVRI interrupt. Because the driver sets MIVR value,
 795          * CHMIVRI is triggered, but there is no action to be taken by the
 796          * driver when CHMIVRI is triggered.
 797          */
 798         ret = regmap_field_write(info->regmap_fields[F_CHMIVRIM], 0x01);
 799         if (ret) {
 800                 dev_err(dev, "Failed to mask CHMIVRI interrupt\n");
 801                 return ret;
 802         }
 803
 804         return 0;
 805 }
 806
 807 #if IS_ENABLED(CONFIG_USB_PHY)
 808 /*
 809  * Before setting the charger into boost mode, boost output voltage is
 810  * set. This is needed because boost output voltage may differ from battery
 811  * regulation voltage. F_VOREG bits represent either battery regulation voltage
 812  * or boost output voltage, depending on the mode the charger is. Both battery
 813  * regulation voltage and boost output voltage are read from DT/ACPI during
 814  * probe.
 815  */
 816 static int rt9455_set_boost_voltage_before_boost_mode(struct rt9455_info *info)
 817 {
 818         struct device *dev = &info->client->dev;
 819         int ret;
 820
 821         ret = rt9455_set_field_val(info, F_VOREG,
 822                                    rt9455_boost_voltage_values,
 823                                    ARRAY_SIZE(rt9455_boost_voltage_values),
 824                                    info->boost_voltage);
 825         if (ret) {
 826                 dev_err(dev, "Failed to set boost output voltage value\n");
 827                 return ret;
 828         }
 829
 830         return 0;
 831 }
 832 #endif
 833
 834 /*
 835  * Before setting the charger into charge mode, battery regulation voltage is
 836  * set. This is needed because boost output voltage may differ from battery
 837  * regulation voltage. F_VOREG bits represent either battery regulation voltage
 838  * or boost output voltage, depending on the mode the charger is. Both battery
 839  * regulation voltage and boost output voltage are read from DT/ACPI during
 840  * probe.
 841  */
 842 static int rt9455_set_voreg_before_charge_mode(struct rt9455_info *info)
 843 {
 844         struct device *dev = &info->client->dev;
 845         int ret;
 846
 847         ret = rt9455_set_field_val(info, F_VOREG,
 848                                    rt9455_voreg_values,
 849                                    ARRAY_SIZE(rt9455_voreg_values),
 850                                    info->voreg);
 851         if (ret) {
 852                 dev_err(dev, "Failed to set VOREG value\n");
 853                 return ret;
 854         }
 855
 856         return 0;
 857 }
 858
 859 static int rt9455_irq_handler_check_irq1_register(struct rt9455_info *info,
 860                                                   bool *_is_battery_absent,
 861                                                   bool *_alert_userspace)
 862 {
 863         unsigned int irq1, mask1, mask2;
 864         struct device *dev = &info->client->dev;
 865         bool is_battery_absent = false;
 866         bool alert_userspace = false;
 867         int ret;
 868
 869         ret = regmap_read(info->regmap, RT9455_REG_IRQ1, &irq1);
 870         if (ret) {
 871                 dev_err(dev, "Failed to read IRQ1 register\n");
 872                 return ret;
 873         }
 874
 875         ret = regmap_read(info->regmap, RT9455_REG_MASK1, &mask1);
 876         if (ret) {
 877                 dev_err(dev, "Failed to read MASK1 register\n");
 878                 return ret;
 879         }
 880
 881         if (irq1 & GET_MASK(F_TSDI)) {
 882                 dev_err(dev, "Thermal shutdown fault occurred\n");
 883                 alert_userspace = true;
 884         }
 885
 886         if (irq1 & GET_MASK(F_VINOVPI)) {
 887                 dev_err(dev, "Overvoltage input occurred\n");
 888                 alert_userspace = true;
 889         }
 890
 891         if (irq1 & GET_MASK(F_BATAB)) {
 892                 dev_err(dev, "Battery absence occurred\n");
 893                 is_battery_absent = true;
 894                 alert_userspace = true;
 895
 896                 if ((mask1 & GET_MASK(F_BATABM)) == 0) {
 897                         ret = regmap_field_write(info->regmap_fields[F_BATABM],
 898                                                  0x01);
 899                         if (ret) {
 900                                 dev_err(dev, "Failed to mask BATAB interrupt\n");
 901                                 return ret;
 902                         }
 903                 }
 904
 905                 ret = regmap_read(info->regmap, RT9455_REG_MASK2, &mask2);
 906                 if (ret) {
 907                         dev_err(dev, "Failed to read MASK2 register\n");
 908                         return ret;
 909                 }
 910
 911                 if (mask2 & GET_MASK(F_CHTERMIM)) {
 912                         ret = regmap_field_write(
 913                                 info->regmap_fields[F_CHTERMIM], 0x00);
 914                         if (ret) {
 915                                 dev_err(dev, "Failed to unmask CHTERMI interrupt\n");
 916                                 return ret;
 917                         }
 918                 }
 919
 920                 if (mask2 & GET_MASK(F_CHRCHGIM)) {
 921                         ret = regmap_field_write(
 922                                 info->regmap_fields[F_CHRCHGIM], 0x00);
 923                         if (ret) {
 924                                 dev_err(dev, "Failed to unmask CHRCHGI interrupt\n");
 925                                 return ret;
 926                         }
 927                 }
 928
 929                 /*
 930                  * When the battery is absent, max_charging_time_work is
 931                  * cancelled, since no charging is done.
 932                  */
 933                 cancel_delayed_work_sync(&info->max_charging_time_work);
 934                 /*
 935                  * Since no interrupt is triggered when the battery is
 936                  * reconnected, max_charging_time_work is not rescheduled.
 937                  * Therefore, batt_presence_work is scheduled to check whether
 938                  * the battery is still absent or not.
 939                  */
 940                 queue_delayed_work(system_power_efficient_wq,
 941                                    &info->batt_presence_work,
 942                                    RT9455_BATT_PRESENCE_DELAY * HZ);
 943         }
 944
 945         *_is_battery_absent = is_battery_absent;
 946
 947         if (alert_userspace)
 948                 *_alert_userspace = alert_userspace;
 949
 950         return 0;
 951 }
 952
 953 static int rt9455_irq_handler_check_irq2_register(struct rt9455_info *info,
 954                                                   bool is_battery_absent,
 955                                                   bool *_alert_userspace)
 956 {
 957         unsigned int irq2, mask2;
 958         struct device *dev = &info->client->dev;
 959         bool alert_userspace = false;
 960         int ret;
 961
 962         ret = regmap_read(info->regmap, RT9455_REG_IRQ2, &irq2);
 963         if (ret) {
 964                 dev_err(dev, "Failed to read IRQ2 register\n");
 965                 return ret;
 966         }
 967
 968         ret = regmap_read(info->regmap, RT9455_REG_MASK2, &mask2);
 969         if (ret) {
 970                 dev_err(dev, "Failed to read MASK2 register\n");
 971                 return ret;
 972         }
 973
 974         if (irq2 & GET_MASK(F_CHRVPI)) {
 975                 dev_dbg(dev, "Charger fault occurred\n");
 976                 /*
 977                  * CHRVPI bit is set in 2 cases:
 978                  * 1. when the power source is connected to the charger.
 979                  * 2. when the power source is disconnected from the charger.
 980                  * To identify the case, PWR_RDY bit is checked. Because
 981                  * PWR_RDY bit is set / cleared after CHRVPI interrupt is
 982                  * triggered, it is used delayed_work to later read PWR_RDY bit.
 983                  * Also, do not set to true alert_userspace, because there is no
 984                  * need to notify userspace when CHRVPI interrupt has occurred.
 985                  * Userspace will be notified after PWR_RDY bit is read.
 986                  */
 987                 queue_delayed_work(system_power_efficient_wq,
 988                                    &info->pwr_rdy_work,
 989                                    RT9455_PWR_RDY_DELAY * HZ);
 990         }
 991         if (irq2 & GET_MASK(F_CHBATOVI)) {
 992                 dev_err(dev, "Battery OVP occurred\n");
 993                 alert_userspace = true;
 994         }
 995         if (irq2 & GET_MASK(F_CHTERMI)) {
 996                 dev_dbg(dev, "Charge terminated\n");
 997                 if (!is_battery_absent) {
 998                         if ((mask2 & GET_MASK(F_CHTERMIM)) == 0) {
 999                                 ret = regmap_field_write(
1000                                         info->regmap_fields[F_CHTERMIM], 0x01);
1001                                 if (ret) {
1002                                         dev_err(dev, "Failed to mask CHTERMI interrupt\n");
1003                                         return ret;
1004                                 }
1005                                 /*
1006                                  * Update MASK2 value, since CHTERMIM bit is
1007                                  * set.
1008                                  */
1009                                 mask2 = mask2 | GET_MASK(F_CHTERMIM);
1010                         }
1011                         cancel_delayed_work_sync(&info->max_charging_time_work);
1012                         alert_userspace = true;
1013                 }
1014         }
1015         if (irq2 & GET_MASK(F_CHRCHGI)) {
1016                 dev_dbg(dev, "Recharge request\n");
1017                 ret = regmap_field_write(info->regmap_fields[F_CHG_EN],
1018                                          RT9455_CHARGE_ENABLE);
1019                 if (ret) {
1020                         dev_err(dev, "Failed to enable charging\n");
1021                         return ret;
1022                 }
1023                 if (mask2 & GET_MASK(F_CHTERMIM)) {
1024                         ret = regmap_field_write(
1025                                 info->regmap_fields[F_CHTERMIM], 0x00);
1026                         if (ret) {
1027                                 dev_err(dev, "Failed to unmask CHTERMI interrupt\n");
1028                                 return ret;
1029                         }
1030                         /* Update MASK2 value, since CHTERMIM bit is cleared. */
1031                         mask2 = mask2 & ~GET_MASK(F_CHTERMIM);
1032                 }
1033                 if (!is_battery_absent) {
1034                         /*
1035                          * No need to check whether the charger is connected to
1036                          * power source when CHRCHGI is received, since CHRCHGI
1037                          * is not triggered if the charger is not connected to
1038                          * the power source.
1039                          */
1040                         queue_delayed_work(system_power_efficient_wq,
1041                                            &info->max_charging_time_work,
1042                                            RT9455_MAX_CHARGING_TIME * HZ);
1043                         alert_userspace = true;
1044                 }
1045         }
1046         if (irq2 & GET_MASK(F_CH32MI)) {
1047                 dev_err(dev, "Charger fault. 32 mins timeout occurred\n");
1048                 alert_userspace = true;
1049         }
1050         if (irq2 & GET_MASK(F_CHTREGI)) {
1051                 dev_warn(dev,
1052                          "Charger warning. Thermal regulation loop active\n");
1053                 alert_userspace = true;
1054         }
1055         if (irq2 & GET_MASK(F_CHMIVRI)) {
1056                 dev_dbg(dev,
1057                         "Charger warning. Input voltage MIVR loop active\n");
1058         }
1059
1060         if (alert_userspace)
1061                 *_alert_userspace = alert_userspace;
1062
1063         return 0;
1064 }
1065
1066 static int rt9455_irq_handler_check_irq3_register(struct rt9455_info *info,
1067                                                   bool *_alert_userspace)
1068 {
1069         unsigned int irq3, mask3;
1070         struct device *dev = &info->client->dev;
1071         bool alert_userspace = false;
1072         int ret;
1073
1074         ret = regmap_read(info->regmap, RT9455_REG_IRQ3, &irq3);
1075         if (ret) {
1076                 dev_err(dev, "Failed to read IRQ3 register\n");
1077                 return ret;
1078         }
1079
1080         ret = regmap_read(info->regmap, RT9455_REG_MASK3, &mask3);
1081         if (ret) {
1082                 dev_err(dev, "Failed to read MASK3 register\n");
1083                 return ret;
1084         }
1085
1086         if (irq3 & GET_MASK(F_BSTBUSOVI)) {
1087                 dev_err(dev, "Boost fault. Overvoltage input occurred\n");
1088                 alert_userspace = true;
1089         }
1090         if (irq3 & GET_MASK(F_BSTOLI)) {
1091                 dev_err(dev, "Boost fault. Overload\n");
1092                 alert_userspace = true;
1093         }
1094         if (irq3 & GET_MASK(F_BSTLOWVI)) {
1095                 dev_err(dev, "Boost fault. Battery voltage too low\n");
1096                 alert_userspace = true;
1097         }
1098         if (irq3 & GET_MASK(F_BST32SI)) {
1099                 dev_err(dev, "Boost fault. 32 seconds timeout occurred.\n");
1100                 alert_userspace = true;
1101         }
1102
1103         if (alert_userspace) {
1104                 dev_info(dev, "Boost fault occurred, therefore the charger goes into charge mode\n");
1105                 ret = rt9455_set_voreg_before_charge_mode(info);
1106                 if (ret) {
1107                         dev_err(dev, "Failed to set VOREG before entering charge mode\n");
1108                         return ret;
1109                 }
1110                 ret = regmap_field_write(info->regmap_fields[F_OPA_MODE],
1111                                          RT9455_CHARGE_MODE);
1112                 if (ret) {
1113                         dev_err(dev, "Failed to set charger in charge mode\n");
1114                         return ret;
1115                 }
1116                 *_alert_userspace = alert_userspace;
1117         }
1118
1119         return 0;
1120 }
1121
1122 static irqreturn_t rt9455_irq_handler_thread(int irq, void *data)
1123 {
1124         struct rt9455_info *info = data;
1125         struct device *dev;
1126         bool alert_userspace = false;
1127         bool is_battery_absent = false;
1128         unsigned int status;
1129         int ret;
1130
1131         if (!info)
1132                 return IRQ_NONE;
1133
1134         dev = &info->client->dev;
1135
1136         if (irq != info->client->irq) {
1137                 dev_err(dev, "Interrupt is not for RT9455 charger\n");
1138                 return IRQ_NONE;
1139         }
1140
1141         ret = regmap_field_read(info->regmap_fields[F_STAT], &status);
1142         if (ret) {
1143                 dev_err(dev, "Failed to read STAT bits\n");
1144                 return IRQ_HANDLED;
1145         }
1146         dev_dbg(dev, "Charger status is %d\n", status);
1147
1148         /*
1149          * Each function that processes an IRQ register receives as output
1150          * parameter alert_userspace pointer. alert_userspace is set to true
1151          * in such a function only if an interrupt has occurred in the
1152          * respective interrupt register. This way, it is avoided the following
1153          * case: interrupt occurs only in IRQ1 register,
1154          * rt9455_irq_handler_check_irq1_register() function sets to true
1155          * alert_userspace, but rt9455_irq_handler_check_irq2_register()
1156          * and rt9455_irq_handler_check_irq3_register() functions set to false
1157          * alert_userspace and power_supply_changed() is never called.
1158          */
1159         ret = rt9455_irq_handler_check_irq1_register(info, &is_battery_absent,
1160                                                      &alert_userspace);
1161         if (ret) {
1162                 dev_err(dev, "Failed to handle IRQ1 register\n");
1163                 return IRQ_HANDLED;
1164         }
1165
1166         ret = rt9455_irq_handler_check_irq2_register(info, is_battery_absent,
1167                                                      &alert_userspace);
1168         if (ret) {
1169                 dev_err(dev, "Failed to handle IRQ2 register\n");
1170                 return IRQ_HANDLED;
1171         }
1172
1173         ret = rt9455_irq_handler_check_irq3_register(info, &alert_userspace);
1174         if (ret) {
1175                 dev_err(dev, "Failed to handle IRQ3 register\n");
1176                 return IRQ_HANDLED;
1177         }
1178
1179         if (alert_userspace) {
1180                 /*
1181                  * Sometimes, an interrupt occurs while rt9455_probe() function
1182                  * is executing and power_supply_register() is not yet called.
1183                  * Do not call power_supply_changed() in this case.
1184                  */
1185                 if (info->charger)
1186                         power_supply_changed(info->charger);
1187         }
1188
1189         return IRQ_HANDLED;
1190 }
1191
1192 static int rt9455_discover_charger(struct rt9455_info *info, u32 *ichrg,
1193                                    u32 *ieoc_percentage,
1194                                    u32 *mivr, u32 *iaicr)
1195 {
1196         struct device *dev = &info->client->dev;
1197         int ret;
1198
1199         if (!dev->of_node && !ACPI_HANDLE(dev)) {
1200                 dev_err(dev, "No support for either device tree or ACPI\n");
1201                 return -EINVAL;
1202         }
1203         /*
1204          * ICHRG, IEOC_PERCENTAGE, VOREG and boost output voltage are mandatory
1205          * parameters.
1206          */
1207         ret = device_property_read_u32(dev, "richtek,output-charge-current",
1208                                        ichrg);
1209         if (ret) {
1210                 dev_err(dev, "Error: missing \"output-charge-current\" property\n");
1211                 return ret;
1212         }
1213
1214         ret = device_property_read_u32(dev, "richtek,end-of-charge-percentage",
1215                                        ieoc_percentage);
1216         if (ret) {
1217                 dev_err(dev, "Error: missing \"end-of-charge-percentage\" property\n");
1218                 return ret;
1219         }
1220
1221         ret = device_property_read_u32(dev,
1222                                        "richtek,battery-regulation-voltage",
1223                                        &info->voreg);
1224         if (ret) {
1225                 dev_err(dev, "Error: missing \"battery-regulation-voltage\" property\n");
1226                 return ret;
1227         }
1228
1229         ret = device_property_read_u32(dev, "richtek,boost-output-voltage",
1230                                        &info->boost_voltage);
1231         if (ret) {
1232                 dev_err(dev, "Error: missing \"boost-output-voltage\" property\n");
1233                 return ret;
1234         }
1235
1236         /*
1237          * MIVR and IAICR are optional parameters. Do not return error if one of
1238          * them is not present in ACPI table or device tree specification.
1239          */
1240         device_property_read_u32(dev, "richtek,min-input-voltage-regulation",
1241                                  mivr);
1242         device_property_read_u32(dev, "richtek,avg-input-current-regulation",
1243                                  iaicr);
1244
1245         return 0;
1246 }
1247
1248 #if IS_ENABLED(CONFIG_USB_PHY)
1249 static int rt9455_usb_event_none(struct rt9455_info *info,
1250                                  u8 opa_mode, u8 iaicr)
1251 {
1252         struct device *dev = &info->client->dev;
1253         int ret;
1254
1255         if (opa_mode == RT9455_BOOST_MODE) {
1256                 ret = rt9455_set_voreg_before_charge_mode(info);
1257                 if (ret) {
1258                         dev_err(dev, "Failed to set VOREG before entering charge mode\n");
1259                         return ret;
1260                 }
1261                 /*
1262                  * If the charger is in boost mode, and it has received
1263                  * USB_EVENT_NONE, this means the consumer device powered by the
1264                  * charger is not connected anymore.
1265                  * In this case, the charger goes into charge mode.
1266                  */
1267                 dev_dbg(dev, "USB_EVENT_NONE received, therefore the charger goes into charge mode\n");
1268                 ret = regmap_field_write(info->regmap_fields[F_OPA_MODE],
1269                                          RT9455_CHARGE_MODE);
1270                 if (ret) {
1271                         dev_err(dev, "Failed to set charger in charge mode\n");
1272                         return NOTIFY_DONE;
1273                 }
1274         }
1275
1276         dev_dbg(dev, "USB_EVENT_NONE received, therefore IAICR is set to its minimum value\n");
1277         if (iaicr != RT9455_IAICR_100MA) {
1278                 ret = regmap_field_write(info->regmap_fields[F_IAICR],
1279                                          RT9455_IAICR_100MA);
1280                 if (ret) {
1281                         dev_err(dev, "Failed to set IAICR value\n");
1282                         return NOTIFY_DONE;
1283                 }
1284         }
1285
1286         return NOTIFY_OK;
1287 }
1288
1289 static int rt9455_usb_event_vbus(struct rt9455_info *info,
1290                                  u8 opa_mode, u8 iaicr)
1291 {
1292         struct device *dev = &info->client->dev;
1293         int ret;
1294
1295         if (opa_mode == RT9455_BOOST_MODE) {
1296                 ret = rt9455_set_voreg_before_charge_mode(info);
1297                 if (ret) {
1298                         dev_err(dev, "Failed to set VOREG before entering charge mode\n");
1299                         return ret;
1300                 }
1301                 /*
1302                  * If the charger is in boost mode, and it has received
1303                  * USB_EVENT_VBUS, this means the consumer device powered by the
1304                  * charger is not connected anymore.
1305                  * In this case, the charger goes into charge mode.
1306                  */
1307                 dev_dbg(dev, "USB_EVENT_VBUS received, therefore the charger goes into charge mode\n");
1308                 ret = regmap_field_write(info->regmap_fields[F_OPA_MODE],
1309                                          RT9455_CHARGE_MODE);
1310                 if (ret) {
1311                         dev_err(dev, "Failed to set charger in charge mode\n");
1312                         return NOTIFY_DONE;
1313                 }
1314         }
1315
1316         dev_dbg(dev, "USB_EVENT_VBUS received, therefore IAICR is set to 500 mA\n");
1317         if (iaicr != RT9455_IAICR_500MA) {
1318                 ret = regmap_field_write(info->regmap_fields[F_IAICR],
1319                                          RT9455_IAICR_500MA);
1320                 if (ret) {
1321                         dev_err(dev, "Failed to set IAICR value\n");
1322                         return NOTIFY_DONE;
1323                 }
1324         }
1325
1326         return NOTIFY_OK;
1327 }
1328
1329 static int rt9455_usb_event_id(struct rt9455_info *info,
1330                                u8 opa_mode, u8 iaicr)
1331 {
1332         struct device *dev = &info->client->dev;
1333         int ret;
1334
1335         if (opa_mode == RT9455_CHARGE_MODE) {
1336                 ret = rt9455_set_boost_voltage_before_boost_mode(info);
1337                 if (ret) {
1338                         dev_err(dev, "Failed to set boost output voltage before entering boost mode\n");
1339                         return ret;
1340                 }
1341                 /*
1342                  * If the charger is in charge mode, and it has received
1343                  * USB_EVENT_ID, this means a consumer device is connected and
1344                  * it should be powered by the charger.
1345                  * In this case, the charger goes into boost mode.
1346                  */
1347                 dev_dbg(dev, "USB_EVENT_ID received, therefore the charger goes into boost mode\n");
1348                 ret = regmap_field_write(info->regmap_fields[F_OPA_MODE],
1349                                          RT9455_BOOST_MODE);
1350                 if (ret) {
1351                         dev_err(dev, "Failed to set charger in boost mode\n");
1352                         return NOTIFY_DONE;
1353                 }
1354         }
1355
1356         dev_dbg(dev, "USB_EVENT_ID received, therefore IAICR is set to its minimum value\n");
1357         if (iaicr != RT9455_IAICR_100MA) {
1358                 ret = regmap_field_write(info->regmap_fields[F_IAICR],
1359                                          RT9455_IAICR_100MA);
1360                 if (ret) {
1361                         dev_err(dev, "Failed to set IAICR value\n");
1362                         return NOTIFY_DONE;
1363                 }
1364         }
1365
1366         return NOTIFY_OK;
1367 }
1368
1369 static int rt9455_usb_event_charger(struct rt9455_info *info,
1370                                     u8 opa_mode, u8 iaicr)
1371 {
1372         struct device *dev = &info->client->dev;
1373         int ret;
1374
1375         if (opa_mode == RT9455_BOOST_MODE) {
1376                 ret = rt9455_set_voreg_before_charge_mode(info);
1377                 if (ret) {
1378                         dev_err(dev, "Failed to set VOREG before entering charge mode\n");
1379                         return ret;
1380                 }
1381                 /*
1382                  * If the charger is in boost mode, and it has received
1383                  * USB_EVENT_CHARGER, this means the consumer device powered by
1384                  * the charger is not connected anymore.
1385                  * In this case, the charger goes into charge mode.
1386                  */
1387                 dev_dbg(dev, "USB_EVENT_CHARGER received, therefore the charger goes into charge mode\n");
1388                 ret = regmap_field_write(info->regmap_fields[F_OPA_MODE],
1389                                          RT9455_CHARGE_MODE);
1390                 if (ret) {
1391                         dev_err(dev, "Failed to set charger in charge mode\n");
1392                         return NOTIFY_DONE;
1393                 }
1394         }
1395
1396         dev_dbg(dev, "USB_EVENT_CHARGER received, therefore IAICR is set to no current limit\n");
1397         if (iaicr != RT9455_IAICR_NO_LIMIT) {
1398                 ret = regmap_field_write(info->regmap_fields[F_IAICR],
1399                                          RT9455_IAICR_NO_LIMIT);
1400                 if (ret) {
1401                         dev_err(dev, "Failed to set IAICR value\n");
1402                         return NOTIFY_DONE;
1403                 }
1404         }
1405
1406         return NOTIFY_OK;
1407 }
1408
1409 static int rt9455_usb_event(struct notifier_block *nb,
1410                             unsigned long event, void *power)
1411 {
1412         struct rt9455_info *info = container_of(nb, struct rt9455_info, nb);
1413         struct device *dev = &info->client->dev;
1414         unsigned int opa_mode, iaicr;
1415         int ret;
1416
1417         /*
1418          * Determine whether the charger is in charge mode
1419          * or in boost mode.
1420          */
1421         ret = regmap_field_read(info->regmap_fields[F_OPA_MODE],
1422                                 &opa_mode);
1423         if (ret) {
1424                 dev_err(dev, "Failed to read OPA_MODE value\n");
1425                 return NOTIFY_DONE;
1426         }
1427
1428         ret = regmap_field_read(info->regmap_fields[F_IAICR],
1429                                 &iaicr);
1430         if (ret) {
1431                 dev_err(dev, "Failed to read IAICR value\n");
1432                 return NOTIFY_DONE;
1433         }
1434
1435         dev_dbg(dev, "Received USB event %lu\n", event);
1436         switch (event) {
1437         case USB_EVENT_NONE:
1438                 return rt9455_usb_event_none(info, opa_mode, iaicr);
1439         case USB_EVENT_VBUS:
1440                 return rt9455_usb_event_vbus(info, opa_mode, iaicr);
1441         case USB_EVENT_ID:
1442                 return rt9455_usb_event_id(info, opa_mode, iaicr);
1443         case USB_EVENT_CHARGER:
1444                 return rt9455_usb_event_charger(info, opa_mode, iaicr);
1445         default:
1446                 dev_err(dev, "Unknown USB event\n");
1447         }
1448         return NOTIFY_DONE;
1449 }
1450 #endif
1451
1452 static void rt9455_pwr_rdy_work_callback(struct work_struct *work)
1453 {
1454         struct rt9455_info *info = container_of(work, struct rt9455_info,
1455                                                 pwr_rdy_work.work);
1456         struct device *dev = &info->client->dev;
1457         unsigned int pwr_rdy;
1458         int ret;
1459
1460         ret = regmap_field_read(info->regmap_fields[F_PWR_RDY], &pwr_rdy);
1461         if (ret) {
1462                 dev_err(dev, "Failed to read PWR_RDY bit\n");
1463                 return;
1464         }
1465         switch (pwr_rdy) {
1466         case RT9455_PWR_FAULT:
1467                 dev_dbg(dev, "Charger disconnected from power source\n");
1468                 cancel_delayed_work_sync(&info->max_charging_time_work);
1469                 break;
1470         case RT9455_PWR_GOOD:
1471                 dev_dbg(dev, "Charger connected to power source\n");
1472                 ret = regmap_field_write(info->regmap_fields[F_CHG_EN],
1473                                          RT9455_CHARGE_ENABLE);
1474                 if (ret) {
1475                         dev_err(dev, "Failed to enable charging\n");
1476                         return;
1477                 }
1478                 queue_delayed_work(system_power_efficient_wq,
1479                                    &info->max_charging_time_work,
1480                                    RT9455_MAX_CHARGING_TIME * HZ);
1481                 break;
1482         }
1483         /*
1484          * Notify userspace that the charger has been either connected to or
1485          * disconnected from the power source.
1486          */
1487         power_supply_changed(info->charger);
1488 }
1489
1490 static void rt9455_max_charging_time_work_callback(struct work_struct *work)
1491 {
1492         struct rt9455_info *info = container_of(work, struct rt9455_info,
1493                                                 max_charging_time_work.work);
1494         struct device *dev = &info->client->dev;
1495         int ret;
1496
1497         dev_err(dev, "Battery has been charging for at least 6 hours and is not yet fully charged. Battery is dead, therefore charging is disabled.\n");
1498         ret = regmap_field_write(info->regmap_fields[F_CHG_EN],
1499                                  RT9455_CHARGE_DISABLE);
1500         if (ret)
1501                 dev_err(dev, "Failed to disable charging\n");
1502 }
1503
1504 static void rt9455_batt_presence_work_callback(struct work_struct *work)
1505 {
1506         struct rt9455_info *info = container_of(work, struct rt9455_info,
1507                                                 batt_presence_work.work);
1508         struct device *dev = &info->client->dev;
1509         unsigned int irq1, mask1;
1510         int ret;
1511
1512         ret = regmap_read(info->regmap, RT9455_REG_IRQ1, &irq1);
1513         if (ret) {
1514                 dev_err(dev, "Failed to read IRQ1 register\n");
1515                 return;
1516         }
1517
1518         /*
1519          * If the battery is still absent, batt_presence_work is rescheduled.
1520          * Otherwise, max_charging_time is scheduled.
1521          */
1522         if (irq1 & GET_MASK(F_BATAB)) {
1523                 queue_delayed_work(system_power_efficient_wq,
1524                                    &info->batt_presence_work,
1525                                    RT9455_BATT_PRESENCE_DELAY * HZ);
1526         } else {
1527                 queue_delayed_work(system_power_efficient_wq,
1528                                    &info->max_charging_time_work,
1529                                    RT9455_MAX_CHARGING_TIME * HZ);
1530
1531                 ret = regmap_read(info->regmap, RT9455_REG_MASK1, &mask1);
1532                 if (ret) {
1533                         dev_err(dev, "Failed to read MASK1 register\n");
1534                         return;
1535                 }
1536
1537                 if (mask1 & GET_MASK(F_BATABM)) {
1538                         ret = regmap_field_write(info->regmap_fields[F_BATABM],
1539                                                  0x00);
1540                         if (ret)
1541                                 dev_err(dev, "Failed to unmask BATAB interrupt\n");
1542                 }
1543                 /*
1544                  * Notify userspace that the battery is now connected to the
1545                  * charger.
1546                  */
1547                 power_supply_changed(info->charger);
1548         }
1549 }
1550
1551 static const struct power_supply_desc rt9455_charger_desc = {
1552         .name                   = RT9455_DRIVER_NAME,
1553         .type                   = POWER_SUPPLY_TYPE_USB,
1554         .properties             = rt9455_charger_properties,
1555         .num_properties         = ARRAY_SIZE(rt9455_charger_properties),
1556         .get_property           = rt9455_charger_get_property,
1557 };
1558
1559 static bool rt9455_is_writeable_reg(struct device *dev, unsigned int reg)
1560 {
1561         switch (reg) {
1562         case RT9455_REG_DEV_ID:
1563         case RT9455_REG_IRQ1:
1564         case RT9455_REG_IRQ2:
1565         case RT9455_REG_IRQ3:
1566                 return false;
1567         default:
1568                 return true;
1569         }
1570 }
1571
1572 static bool rt9455_is_volatile_reg(struct device *dev, unsigned int reg)
1573 {
1574         switch (reg) {
1575         case RT9455_REG_DEV_ID:
1576         case RT9455_REG_CTRL5:
1577         case RT9455_REG_CTRL6:
1578                 return false;
1579         default:
1580                 return true;
1581         }
1582 }
1583
1584 static const struct regmap_config rt9455_regmap_config = {
1585         .reg_bits       = 8,
1586         .val_bits       = 8,
1587         .writeable_reg  = rt9455_is_writeable_reg,
1588         .volatile_reg   = rt9455_is_volatile_reg,
1589         .max_register   = RT9455_REG_MASK3,
1590         .cache_type     = REGCACHE_RBTREE,
1591 };
1592
1593 static int rt9455_probe(struct i2c_client *client,
1594                         const struct i2c_device_id *id)
1595 {
1596         struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
1597         struct device *dev = &client->dev;
1598         struct rt9455_info *info;
1599         struct power_supply_config rt9455_charger_config = {};
1600         /*
1601          * Mandatory device-specific data values. Also, VOREG and boost output
1602          * voltage are mandatory values, but they are stored in rt9455_info
1603          * structure.
1604          */
1605         u32 ichrg, ieoc_percentage;
1606         /* Optional device-specific data values. */
1607         u32 mivr = -1, iaicr = -1;
1608         int i, ret;
1609
1610         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1611                 dev_err(dev, "No support for SMBUS_BYTE_DATA\n");
1612                 return -ENODEV;
1613         }
1614         info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL);
1615         if (!info)
1616                 return -ENOMEM;
1617
1618         info->client = client;
1619         i2c_set_clientdata(client, info);
1620
1621         info->regmap = devm_regmap_init_i2c(client,
1622                                             &rt9455_regmap_config);
1623         if (IS_ERR(info->regmap)) {
1624                 dev_err(dev, "Failed to initialize register map\n");
1625                 return -EINVAL;
1626         }
1627
1628         for (i = 0; i < F_MAX_FIELDS; i++) {
1629                 info->regmap_fields[i] =
1630                         devm_regmap_field_alloc(dev, info->regmap,
1631                                                 rt9455_reg_fields[i]);
1632                 if (IS_ERR(info->regmap_fields[i])) {
1633                         dev_err(dev,
1634                                 "Failed to allocate regmap field = %d\n", i);
1635                         return PTR_ERR(info->regmap_fields[i]);
1636                 }
1637         }
1638
1639         ret = rt9455_discover_charger(info, &ichrg, &ieoc_percentage,
1640                                       &mivr, &iaicr);
1641         if (ret) {
1642                 dev_err(dev, "Failed to discover charger\n");
1643                 return ret;
1644         }
1645
1646 #if IS_ENABLED(CONFIG_USB_PHY)
1647         info->usb_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2);
1648         if (IS_ERR(info->usb_phy)) {
1649                 dev_err(dev, "Failed to get USB transceiver\n");
1650         } else {
1651                 info->nb.notifier_call = rt9455_usb_event;
1652                 ret = usb_register_notifier(info->usb_phy, &info->nb);
1653                 if (ret) {
1654                         dev_err(dev, "Failed to register USB notifier\n");
1655                         /*
1656                          * If usb_register_notifier() fails, set notifier_call
1657                          * to NULL, to avoid calling usb_unregister_notifier().
1658                          */
1659                         info->nb.notifier_call = NULL;
1660                 }
1661         }
1662 #endif
1663
1664         INIT_DEFERRABLE_WORK(&info->pwr_rdy_work, rt9455_pwr_rdy_work_callback);
1665         INIT_DEFERRABLE_WORK(&info->max_charging_time_work,
1666                              rt9455_max_charging_time_work_callback);
1667         INIT_DEFERRABLE_WORK(&info->batt_presence_work,
1668                              rt9455_batt_presence_work_callback);
1669
1670         rt9455_charger_config.of_node           = dev->of_node;
1671         rt9455_charger_config.drv_data          = info;
1672         rt9455_charger_config.supplied_to       = rt9455_charger_supplied_to;
1673         rt9455_charger_config.num_supplicants   =
1674                                         ARRAY_SIZE(rt9455_charger_supplied_to);
1675         ret = devm_request_threaded_irq(dev, client->irq, NULL,
1676                                         rt9455_irq_handler_thread,
1677                                         IRQF_TRIGGER_LOW | IRQF_ONESHOT,
1678                                         RT9455_DRIVER_NAME, info);
1679         if (ret) {
1680                 dev_err(dev, "Failed to register IRQ handler\n");
1681                 goto put_usb_notifier;
1682         }
1683
1684         ret = rt9455_hw_init(info, ichrg, ieoc_percentage, mivr, iaicr);
1685         if (ret) {
1686                 dev_err(dev, "Failed to set charger to its default values\n");
1687                 goto put_usb_notifier;
1688         }
1689
1690         info->charger = devm_power_supply_register(dev, &rt9455_charger_desc,
1691                                                    &rt9455_charger_config);
1692         if (IS_ERR(info->charger)) {
1693                 dev_err(dev, "Failed to register charger\n");
1694                 ret = PTR_ERR(info->charger);
1695                 goto put_usb_notifier;
1696         }
1697
1698         return 0;
1699
1700 put_usb_notifier:
1701 #if IS_ENABLED(CONFIG_USB_PHY)
1702         if (info->nb.notifier_call)  {
1703                 usb_unregister_notifier(info->usb_phy, &info->nb);
1704                 info->nb.notifier_call = NULL;
1705         }
1706 #endif
1707         return ret;
1708 }
1709
1710 static int rt9455_remove(struct i2c_client *client)
1711 {
1712         int ret;
1713         struct rt9455_info *info = i2c_get_clientdata(client);
1714
1715         ret = rt9455_register_reset(info);
1716         if (ret)
1717                 dev_err(&info->client->dev, "Failed to set charger to its default values\n");
1718
1719 #if IS_ENABLED(CONFIG_USB_PHY)
1720         if (info->nb.notifier_call)
1721                 usb_unregister_notifier(info->usb_phy, &info->nb);
1722 #endif
1723
1724         cancel_delayed_work_sync(&info->pwr_rdy_work);
1725         cancel_delayed_work_sync(&info->max_charging_time_work);
1726         cancel_delayed_work_sync(&info->batt_presence_work);
1727
1728         return ret;
1729 }
1730
1731 static const struct i2c_device_id rt9455_i2c_id_table[] = {
1732         { RT9455_DRIVER_NAME, 0 },
1733         { },
1734 };
1735 MODULE_DEVICE_TABLE(i2c, rt9455_i2c_id_table);
1736
1737 static const struct of_device_id rt9455_of_match[] = {
1738         { .compatible = "richtek,rt9455", },
1739         { },
1740 };
1741 MODULE_DEVICE_TABLE(of, rt9455_of_match);
1742
1743 static const struct acpi_device_id rt9455_i2c_acpi_match[] = {
1744         { "RT945500", 0 },
1745         { }
1746 };
1747 MODULE_DEVICE_TABLE(acpi, rt9455_i2c_acpi_match);
1748
1749 static struct i2c_driver rt9455_driver = {
1750         .probe          = rt9455_probe,
1751         .remove         = rt9455_remove,
1752         .id_table       = rt9455_i2c_id_table,
1753         .driver = {
1754                 .name           = RT9455_DRIVER_NAME,
1755                 .of_match_table = of_match_ptr(rt9455_of_match),
1756                 .acpi_match_table = ACPI_PTR(rt9455_i2c_acpi_match),
1757         },
1758 };
1759 module_i2c_driver(rt9455_driver);
1760
1761 MODULE_LICENSE("GPL");
1762 MODULE_AUTHOR("Anda-Maria Nicolae <anda-maria.nicolae@intel.com>");
1763 MODULE_DESCRIPTION("Richtek RT9455 Charger Driver");