drivers/power/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                 alert_userspace = true;
 977                 /*
 978                  * CHRVPI bit is set in 2 cases:
 979                  * 1. when the power source is connected to the charger.
 980                  * 2. when the power source is disconnected from the charger.
 981                  * To identify the case, PWR_RDY bit is checked. Because
 982                  * PWR_RDY bit is set / cleared after CHRVPI interrupt is
 983                  * triggered, it is used delayed_work to later read PWR_RDY bit.
 984                  */
 985                 queue_delayed_work(system_power_efficient_wq,
 986                                    &info->pwr_rdy_work,
 987                                    RT9455_PWR_RDY_DELAY * HZ);
 988         }
 989         if (irq2 & GET_MASK(F_CHBATOVI)) {
 990                 dev_err(dev, "Battery OVP occurred\n");
 991                 alert_userspace = true;
 992         }
 993         if (irq2 & GET_MASK(F_CHTERMI)) {
 994                 dev_dbg(dev, "Charge terminated\n");
 995                 if (!is_battery_absent) {
 996                         if ((mask2 & GET_MASK(F_CHTERMIM)) == 0) {
 997                                 ret = regmap_field_write(
 998                                         info->regmap_fields[F_CHTERMIM], 0x01);
 999                                 if (ret) {
1000                                         dev_err(dev, "Failed to mask CHTERMI interrupt\n");
1001                                         return ret;
1002                                 }
1003                                 /*
1004                                  * Update MASK2 value, since CHTERMIM bit is
1005                                  * set.
1006                                  */
1007                                 mask2 = mask2 | GET_MASK(F_CHTERMIM);
1008                         }
1009                         cancel_delayed_work_sync(&info->max_charging_time_work);
1010                         alert_userspace = true;
1011                 }
1012         }
1013         if (irq2 & GET_MASK(F_CHRCHGI)) {
1014                 dev_dbg(dev, "Recharge request\n");
1015                 ret = regmap_field_write(info->regmap_fields[F_CHG_EN],
1016                                          RT9455_CHARGE_ENABLE);
1017                 if (ret) {
1018                         dev_err(dev, "Failed to enable charging\n");
1019                         return ret;
1020                 }
1021                 if (mask2 & GET_MASK(F_CHTERMIM)) {
1022                         ret = regmap_field_write(
1023                                 info->regmap_fields[F_CHTERMIM], 0x00);
1024                         if (ret) {
1025                                 dev_err(dev, "Failed to unmask CHTERMI interrupt\n");
1026                                 return ret;
1027                         }
1028                         /* Update MASK2 value, since CHTERMIM bit is cleared. */
1029                         mask2 = mask2 & ~GET_MASK(F_CHTERMIM);
1030                 }
1031                 if (!is_battery_absent) {
1032                         /*
1033                          * No need to check whether the charger is connected to
1034                          * power source when CHRCHGI is received, since CHRCHGI
1035                          * is not triggered if the charger is not connected to
1036                          * the power source.
1037                          */
1038                         queue_delayed_work(system_power_efficient_wq,
1039                                            &info->max_charging_time_work,
1040                                            RT9455_MAX_CHARGING_TIME * HZ);
1041                         alert_userspace = true;
1042                 }
1043         }
1044         if (irq2 & GET_MASK(F_CH32MI)) {
1045                 dev_err(dev, "Charger fault. 32 mins timeout occurred\n");
1046                 alert_userspace = true;
1047         }
1048         if (irq2 & GET_MASK(F_CHTREGI)) {
1049                 dev_warn(dev,
1050                          "Charger warning. Thermal regulation loop active\n");
1051                 alert_userspace = true;
1052         }
1053         if (irq2 & GET_MASK(F_CHMIVRI)) {
1054                 dev_dbg(dev,
1055                         "Charger warning. Input voltage MIVR loop active\n");
1056         }
1057
1058         if (alert_userspace)
1059                 *_alert_userspace = alert_userspace;
1060
1061         return 0;
1062 }
1063
1064 static int rt9455_irq_handler_check_irq3_register(struct rt9455_info *info,
1065                                                   bool *_alert_userspace)
1066 {
1067         unsigned int irq3, mask3;
1068         struct device *dev = &info->client->dev;
1069         bool alert_userspace = false;
1070         int ret;
1071
1072         ret = regmap_read(info->regmap, RT9455_REG_IRQ3, &irq3);
1073         if (ret) {
1074                 dev_err(dev, "Failed to read IRQ3 register\n");
1075                 return ret;
1076         }
1077
1078         ret = regmap_read(info->regmap, RT9455_REG_MASK3, &mask3);
1079         if (ret) {
1080                 dev_err(dev, "Failed to read MASK3 register\n");
1081                 return ret;
1082         }
1083
1084         if (irq3 & GET_MASK(F_BSTBUSOVI)) {
1085                 dev_err(dev, "Boost fault. Overvoltage input occurred\n");
1086                 alert_userspace = true;
1087         }
1088         if (irq3 & GET_MASK(F_BSTOLI)) {
1089                 dev_err(dev, "Boost fault. Overload\n");
1090                 alert_userspace = true;
1091         }
1092         if (irq3 & GET_MASK(F_BSTLOWVI)) {
1093                 dev_err(dev, "Boost fault. Battery voltage too low\n");
1094                 alert_userspace = true;
1095         }
1096         if (irq3 & GET_MASK(F_BST32SI)) {
1097                 dev_err(dev, "Boost fault. 32 seconds timeout occurred.\n");
1098                 alert_userspace = true;
1099         }
1100
1101         if (alert_userspace) {
1102                 dev_info(dev, "Boost fault occurred, therefore the charger goes into charge mode\n");
1103                 ret = rt9455_set_voreg_before_charge_mode(info);
1104                 if (ret) {
1105                         dev_err(dev, "Failed to set VOREG before entering charge mode\n");
1106                         return ret;
1107                 }
1108                 ret = regmap_field_write(info->regmap_fields[F_OPA_MODE],
1109                                          RT9455_CHARGE_MODE);
1110                 if (ret) {
1111                         dev_err(dev, "Failed to set charger in charge mode\n");
1112                         return ret;
1113                 }
1114                 *_alert_userspace = alert_userspace;
1115         }
1116
1117         return 0;
1118 }
1119
1120 static irqreturn_t rt9455_irq_handler_thread(int irq, void *data)
1121 {
1122         struct rt9455_info *info = data;
1123         struct device *dev;
1124         bool alert_userspace = false;
1125         bool is_battery_absent = false;
1126         unsigned int status;
1127         int ret;
1128
1129         if (!info)
1130                 return IRQ_NONE;
1131
1132         dev = &info->client->dev;
1133
1134         if (irq != info->client->irq) {
1135                 dev_err(dev, "Interrupt is not for RT9455 charger\n");
1136                 return IRQ_NONE;
1137         }
1138
1139         ret = regmap_field_read(info->regmap_fields[F_STAT], &status);
1140         if (ret) {
1141                 dev_err(dev, "Failed to read STAT bits\n");
1142                 return IRQ_HANDLED;
1143         }
1144         dev_dbg(dev, "Charger status is %d\n", status);
1145
1146         /*
1147          * Each function that processes an IRQ register receives as output
1148          * parameter alert_userspace pointer. alert_userspace is set to true
1149          * in such a function only if an interrupt has occurred in the
1150          * respective interrupt register. This way, it is avoided the following
1151          * case: interrupt occurs only in IRQ1 register,
1152          * rt9455_irq_handler_check_irq1_register() function sets to true
1153          * alert_userspace, but rt9455_irq_handler_check_irq2_register()
1154          * and rt9455_irq_handler_check_irq3_register() functions set to false
1155          * alert_userspace and power_supply_changed() is never called.
1156          */
1157         ret = rt9455_irq_handler_check_irq1_register(info, &is_battery_absent,
1158                                                      &alert_userspace);
1159         if (ret) {
1160                 dev_err(dev, "Failed to handle IRQ1 register\n");
1161                 return IRQ_HANDLED;
1162         }
1163
1164         ret = rt9455_irq_handler_check_irq2_register(info, is_battery_absent,
1165                                                      &alert_userspace);
1166         if (ret) {
1167                 dev_err(dev, "Failed to handle IRQ2 register\n");
1168                 return IRQ_HANDLED;
1169         }
1170
1171         ret = rt9455_irq_handler_check_irq3_register(info, &alert_userspace);
1172         if (ret) {
1173                 dev_err(dev, "Failed to handle IRQ3 register\n");
1174                 return IRQ_HANDLED;
1175         }
1176
1177         if (alert_userspace) {
1178                 /*
1179                  * Sometimes, an interrupt occurs while rt9455_probe() function
1180                  * is executing and power_supply_register() is not yet called.
1181                  * Do not call power_supply_charged() in this case.
1182                  */
1183                 if (info->charger)
1184                         power_supply_changed(info->charger);
1185         }
1186
1187         return IRQ_HANDLED;
1188 }
1189
1190 static int rt9455_discover_charger(struct rt9455_info *info, u32 *ichrg,
1191                                    u32 *ieoc_percentage,
1192                                    u32 *mivr, u32 *iaicr)
1193 {
1194         struct device *dev = &info->client->dev;
1195         int ret;
1196
1197         if (!dev->of_node && !ACPI_HANDLE(dev)) {
1198                 dev_err(dev, "No support for either device tree or ACPI\n");
1199                 return -EINVAL;
1200         }
1201         /*
1202          * ICHRG, IEOC_PERCENTAGE, VOREG and boost output voltage are mandatory
1203          * parameters.
1204          */
1205         ret = device_property_read_u32(dev, "richtek,output-charge-current",
1206                                        ichrg);
1207         if (ret) {
1208                 dev_err(dev, "Error: missing \"output-charge-current\" property\n");
1209                 return ret;
1210         }
1211
1212         ret = device_property_read_u32(dev, "richtek,end-of-charge-percentage",
1213                                        ieoc_percentage);
1214         if (ret) {
1215                 dev_err(dev, "Error: missing \"end-of-charge-percentage\" property\n");
1216                 return ret;
1217         }
1218
1219         ret = device_property_read_u32(dev,
1220                                        "richtek,battery-regulation-voltage",
1221                                        &info->voreg);
1222         if (ret) {
1223                 dev_err(dev, "Error: missing \"battery-regulation-voltage\" property\n");
1224                 return ret;
1225         }
1226
1227         ret = device_property_read_u32(dev, "richtek,boost-output-voltage",
1228                                        &info->boost_voltage);
1229         if (ret) {
1230                 dev_err(dev, "Error: missing \"boost-output-voltage\" property\n");
1231                 return ret;
1232         }
1233
1234         /*
1235          * MIVR and IAICR are optional parameters. Do not return error if one of
1236          * them is not present in ACPI table or device tree specification.
1237          */
1238         device_property_read_u32(dev, "richtek,min-input-voltage-regulation",
1239                                  mivr);
1240         device_property_read_u32(dev, "richtek,avg-input-current-regulation",
1241                                  iaicr);
1242
1243         return 0;
1244 }
1245
1246 #if IS_ENABLED(CONFIG_USB_PHY)
1247 static int rt9455_usb_event_none(struct rt9455_info *info,
1248                                  u8 opa_mode, u8 iaicr)
1249 {
1250         struct device *dev = &info->client->dev;
1251         int ret;
1252
1253         if (opa_mode == RT9455_BOOST_MODE) {
1254                 ret = rt9455_set_voreg_before_charge_mode(info);
1255                 if (ret) {
1256                         dev_err(dev, "Failed to set VOREG before entering charge mode\n");
1257                         return ret;
1258                 }
1259                 /*
1260                  * If the charger is in boost mode, and it has received
1261                  * USB_EVENT_NONE, this means the consumer device powered by the
1262                  * charger is not connected anymore.
1263                  * In this case, the charger goes into charge mode.
1264                  */
1265                 dev_dbg(dev, "USB_EVENT_NONE received, therefore the charger goes into charge mode\n");
1266                 ret = regmap_field_write(info->regmap_fields[F_OPA_MODE],
1267                                          RT9455_CHARGE_MODE);
1268                 if (ret) {
1269                         dev_err(dev, "Failed to set charger in charge mode\n");
1270                         return NOTIFY_DONE;
1271                 }
1272         }
1273
1274         dev_dbg(dev, "USB_EVENT_NONE received, therefore IAICR is set to its minimum value\n");
1275         if (iaicr != RT9455_IAICR_100MA) {
1276                 ret = regmap_field_write(info->regmap_fields[F_IAICR],
1277                                          RT9455_IAICR_100MA);
1278                 if (ret) {
1279                         dev_err(dev, "Failed to set IAICR value\n");
1280                         return NOTIFY_DONE;
1281                 }
1282         }
1283
1284         return NOTIFY_OK;
1285 }
1286
1287 static int rt9455_usb_event_vbus(struct rt9455_info *info,
1288                                  u8 opa_mode, u8 iaicr)
1289 {
1290         struct device *dev = &info->client->dev;
1291         int ret;
1292
1293         if (opa_mode == RT9455_BOOST_MODE) {
1294                 ret = rt9455_set_voreg_before_charge_mode(info);
1295                 if (ret) {
1296                         dev_err(dev, "Failed to set VOREG before entering charge mode\n");
1297                         return ret;
1298                 }
1299                 /*
1300                  * If the charger is in boost mode, and it has received
1301                  * USB_EVENT_VBUS, this means the consumer device powered by the
1302                  * charger is not connected anymore.
1303                  * In this case, the charger goes into charge mode.
1304                  */
1305                 dev_dbg(dev, "USB_EVENT_VBUS received, therefore the charger goes into charge mode\n");
1306                 ret = regmap_field_write(info->regmap_fields[F_OPA_MODE],
1307                                          RT9455_CHARGE_MODE);
1308                 if (ret) {
1309                         dev_err(dev, "Failed to set charger in charge mode\n");
1310                         return NOTIFY_DONE;
1311                 }
1312         }
1313
1314         dev_dbg(dev, "USB_EVENT_VBUS received, therefore IAICR is set to 500 mA\n");
1315         if (iaicr != RT9455_IAICR_500MA) {
1316                 ret = regmap_field_write(info->regmap_fields[F_IAICR],
1317                                          RT9455_IAICR_500MA);
1318                 if (ret) {
1319                         dev_err(dev, "Failed to set IAICR value\n");
1320                         return NOTIFY_DONE;
1321                 }
1322         }
1323
1324         return NOTIFY_OK;
1325 }
1326
1327 static int rt9455_usb_event_id(struct rt9455_info *info,
1328                                u8 opa_mode, u8 iaicr)
1329 {
1330         struct device *dev = &info->client->dev;
1331         int ret;
1332
1333         if (opa_mode == RT9455_CHARGE_MODE) {
1334                 ret = rt9455_set_boost_voltage_before_boost_mode(info);
1335                 if (ret) {
1336                         dev_err(dev, "Failed to set boost output voltage before entering boost mode\n");
1337                         return ret;
1338                 }
1339                 /*
1340                  * If the charger is in charge mode, and it has received
1341                  * USB_EVENT_ID, this means a consumer device is connected and
1342                  * it should be powered by the charger.
1343                  * In this case, the charger goes into boost mode.
1344                  */
1345                 dev_dbg(dev, "USB_EVENT_ID received, therefore the charger goes into boost mode\n");
1346                 ret = regmap_field_write(info->regmap_fields[F_OPA_MODE],
1347                                          RT9455_BOOST_MODE);
1348                 if (ret) {
1349                         dev_err(dev, "Failed to set charger in boost mode\n");
1350                         return NOTIFY_DONE;
1351                 }
1352         }
1353
1354         dev_dbg(dev, "USB_EVENT_ID received, therefore IAICR is set to its minimum value\n");
1355         if (iaicr != RT9455_IAICR_100MA) {
1356                 ret = regmap_field_write(info->regmap_fields[F_IAICR],
1357                                          RT9455_IAICR_100MA);
1358                 if (ret) {
1359                         dev_err(dev, "Failed to set IAICR value\n");
1360                         return NOTIFY_DONE;
1361                 }
1362         }
1363
1364         return NOTIFY_OK;
1365 }
1366
1367 static int rt9455_usb_event_charger(struct rt9455_info *info,
1368                                     u8 opa_mode, u8 iaicr)
1369 {
1370         struct device *dev = &info->client->dev;
1371         int ret;
1372
1373         if (opa_mode == RT9455_BOOST_MODE) {
1374                 ret = rt9455_set_voreg_before_charge_mode(info);
1375                 if (ret) {
1376                         dev_err(dev, "Failed to set VOREG before entering charge mode\n");
1377                         return ret;
1378                 }
1379                 /*
1380                  * If the charger is in boost mode, and it has received
1381                  * USB_EVENT_CHARGER, this means the consumer device powered by
1382                  * the charger is not connected anymore.
1383                  * In this case, the charger goes into charge mode.
1384                  */
1385                 dev_dbg(dev, "USB_EVENT_CHARGER received, therefore the charger goes into charge mode\n");
1386                 ret = regmap_field_write(info->regmap_fields[F_OPA_MODE],
1387                                          RT9455_CHARGE_MODE);
1388                 if (ret) {
1389                         dev_err(dev, "Failed to set charger in charge mode\n");
1390                         return NOTIFY_DONE;
1391                 }
1392         }
1393
1394         dev_dbg(dev, "USB_EVENT_CHARGER received, therefore IAICR is set to no current limit\n");
1395         if (iaicr != RT9455_IAICR_NO_LIMIT) {
1396                 ret = regmap_field_write(info->regmap_fields[F_IAICR],
1397                                          RT9455_IAICR_NO_LIMIT);
1398                 if (ret) {
1399                         dev_err(dev, "Failed to set IAICR value\n");
1400                         return NOTIFY_DONE;
1401                 }
1402         }
1403
1404         return NOTIFY_OK;
1405 }
1406
1407 static int rt9455_usb_event(struct notifier_block *nb,
1408                             unsigned long event, void *power)
1409 {
1410         struct rt9455_info *info = container_of(nb, struct rt9455_info, nb);
1411         struct device *dev = &info->client->dev;
1412         unsigned int opa_mode, iaicr;
1413         int ret;
1414
1415         /*
1416          * Determine whether the charger is in charge mode
1417          * or in boost mode.
1418          */
1419         ret = regmap_field_read(info->regmap_fields[F_OPA_MODE],
1420                                 &opa_mode);
1421         if (ret) {
1422                 dev_err(dev, "Failed to read OPA_MODE value\n");
1423                 return NOTIFY_DONE;
1424         }
1425
1426         ret = regmap_field_read(info->regmap_fields[F_IAICR],
1427                                 &iaicr);
1428         if (ret) {
1429                 dev_err(dev, "Failed to read IAICR value\n");
1430                 return NOTIFY_DONE;
1431         }
1432
1433         dev_dbg(dev, "Received USB event %lu\n", event);
1434         switch (event) {
1435         case USB_EVENT_NONE:
1436                 return rt9455_usb_event_none(info, opa_mode, iaicr);
1437         case USB_EVENT_VBUS:
1438                 return rt9455_usb_event_vbus(info, opa_mode, iaicr);
1439         case USB_EVENT_ID:
1440                 return rt9455_usb_event_id(info, opa_mode, iaicr);
1441         case USB_EVENT_CHARGER:
1442                 return rt9455_usb_event_charger(info, opa_mode, iaicr);
1443         default:
1444                 dev_err(dev, "Unknown USB event\n");
1445         }
1446         return NOTIFY_DONE;
1447 }
1448 #endif
1449
1450 static void rt9455_pwr_rdy_work_callback(struct work_struct *work)
1451 {
1452         struct rt9455_info *info = container_of(work, struct rt9455_info,
1453                                                 pwr_rdy_work.work);
1454         struct device *dev = &info->client->dev;
1455         unsigned int pwr_rdy;
1456         int ret;
1457
1458         ret = regmap_field_read(info->regmap_fields[F_PWR_RDY], &pwr_rdy);
1459         if (ret) {
1460                 dev_err(dev, "Failed to read PWR_RDY bit\n");
1461                 return;
1462         }
1463         switch (pwr_rdy) {
1464         case RT9455_PWR_FAULT:
1465                 dev_dbg(dev, "Charger disconnected from power source\n");
1466                 cancel_delayed_work_sync(&info->max_charging_time_work);
1467                 break;
1468         case RT9455_PWR_GOOD:
1469                 dev_dbg(dev, "Charger connected to power source\n");
1470                 ret = regmap_field_write(info->regmap_fields[F_CHG_EN],
1471                                          RT9455_CHARGE_ENABLE);
1472                 if (ret) {
1473                         dev_err(dev, "Failed to enable charging\n");
1474                         return;
1475                 }
1476                 queue_delayed_work(system_power_efficient_wq,
1477                                    &info->max_charging_time_work,
1478                                    RT9455_MAX_CHARGING_TIME * HZ);
1479                 break;
1480         }
1481 }
1482
1483 static void rt9455_max_charging_time_work_callback(struct work_struct *work)
1484 {
1485         struct rt9455_info *info = container_of(work, struct rt9455_info,
1486                                                 max_charging_time_work.work);
1487         struct device *dev = &info->client->dev;
1488         int ret;
1489
1490         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");
1491         ret = regmap_field_write(info->regmap_fields[F_CHG_EN],
1492                                  RT9455_CHARGE_DISABLE);
1493         if (ret)
1494                 dev_err(dev, "Failed to disable charging\n");
1495 }
1496
1497 static void rt9455_batt_presence_work_callback(struct work_struct *work)
1498 {
1499         struct rt9455_info *info = container_of(work, struct rt9455_info,
1500                                                 batt_presence_work.work);
1501         struct device *dev = &info->client->dev;
1502         unsigned int irq1, mask1;
1503         int ret;
1504
1505         ret = regmap_read(info->regmap, RT9455_REG_IRQ1, &irq1);
1506         if (ret) {
1507                 dev_err(dev, "Failed to read IRQ1 register\n");
1508                 return;
1509         }
1510
1511         /*
1512          * If the battery is still absent, batt_presence_work is rescheduled.
1513          * Otherwise, max_charging_time is scheduled.
1514          */
1515         if (irq1 & GET_MASK(F_BATAB)) {
1516                 queue_delayed_work(system_power_efficient_wq,
1517                                    &info->batt_presence_work,
1518                                    RT9455_BATT_PRESENCE_DELAY * HZ);
1519         } else {
1520                 queue_delayed_work(system_power_efficient_wq,
1521                                    &info->max_charging_time_work,
1522                                    RT9455_MAX_CHARGING_TIME * HZ);
1523
1524                 ret = regmap_read(info->regmap, RT9455_REG_MASK1, &mask1);
1525                 if (ret) {
1526                         dev_err(dev, "Failed to read MASK1 register\n");
1527                         return;
1528                 }
1529
1530                 if (mask1 & GET_MASK(F_BATABM)) {
1531                         ret = regmap_field_write(info->regmap_fields[F_BATABM],
1532                                                  0x00);
1533                         if (ret)
1534                                 dev_err(dev, "Failed to unmask BATAB interrupt\n");
1535                 }
1536         }
1537 }
1538
1539 static const struct power_supply_desc rt9455_charger_desc = {
1540         .name                   = RT9455_DRIVER_NAME,
1541         .type                   = POWER_SUPPLY_TYPE_USB,
1542         .properties             = rt9455_charger_properties,
1543         .num_properties         = ARRAY_SIZE(rt9455_charger_properties),
1544         .get_property           = rt9455_charger_get_property,
1545 };
1546
1547 static bool rt9455_is_writeable_reg(struct device *dev, unsigned int reg)
1548 {
1549         switch (reg) {
1550         case RT9455_REG_DEV_ID:
1551         case RT9455_REG_IRQ1:
1552         case RT9455_REG_IRQ2:
1553         case RT9455_REG_IRQ3:
1554                 return false;
1555         default:
1556                 return true;
1557         }
1558 }
1559
1560 static bool rt9455_is_volatile_reg(struct device *dev, unsigned int reg)
1561 {
1562         switch (reg) {
1563         case RT9455_REG_DEV_ID:
1564         case RT9455_REG_CTRL5:
1565         case RT9455_REG_CTRL6:
1566                 return false;
1567         default:
1568                 return true;
1569         }
1570 }
1571
1572 static const struct regmap_config rt9455_regmap_config = {
1573         .reg_bits       = 8,
1574         .val_bits       = 8,
1575         .writeable_reg  = rt9455_is_writeable_reg,
1576         .volatile_reg   = rt9455_is_volatile_reg,
1577         .max_register   = RT9455_REG_MASK3,
1578         .cache_type     = REGCACHE_RBTREE,
1579 };
1580
1581 static int rt9455_probe(struct i2c_client *client,
1582                         const struct i2c_device_id *id)
1583 {
1584         struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
1585         struct device *dev = &client->dev;
1586         struct rt9455_info *info;
1587         struct power_supply_config rt9455_charger_config = {};
1588         /*
1589          * Mandatory device-specific data values. Also, VOREG and boost output
1590          * voltage are mandatory values, but they are stored in rt9455_info
1591          * structure.
1592          */
1593         u32 ichrg, ieoc_percentage;
1594         /* Optional device-specific data values. */
1595         u32 mivr = -1, iaicr = -1;
1596         int i, ret;
1597
1598         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1599                 dev_err(dev, "No support for SMBUS_BYTE_DATA\n");
1600                 return -ENODEV;
1601         }
1602         info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL);
1603         if (!info)
1604                 return -ENOMEM;
1605
1606         info->client = client;
1607         i2c_set_clientdata(client, info);
1608
1609         info->regmap = devm_regmap_init_i2c(client,
1610                                             &rt9455_regmap_config);
1611         if (IS_ERR(info->regmap)) {
1612                 dev_err(dev, "Failed to initialize register map\n");
1613                 return -EINVAL;
1614         }
1615
1616         for (i = 0; i < F_MAX_FIELDS; i++) {
1617                 info->regmap_fields[i] =
1618                         devm_regmap_field_alloc(dev, info->regmap,
1619                                                 rt9455_reg_fields[i]);
1620                 if (IS_ERR(info->regmap_fields[i])) {
1621                         dev_err(dev,
1622                                 "Failed to allocate regmap field = %d\n", i);
1623                         return PTR_ERR(info->regmap_fields[i]);
1624                 }
1625         }
1626
1627         ret = rt9455_discover_charger(info, &ichrg, &ieoc_percentage,
1628                                       &mivr, &iaicr);
1629         if (ret) {
1630                 dev_err(dev, "Failed to discover charger\n");
1631                 return ret;
1632         }
1633
1634 #if IS_ENABLED(CONFIG_USB_PHY)
1635         info->usb_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2);
1636         if (IS_ERR(info->usb_phy)) {
1637                 dev_err(dev, "Failed to get USB transceiver\n");
1638         } else {
1639                 info->nb.notifier_call = rt9455_usb_event;
1640                 ret = usb_register_notifier(info->usb_phy, &info->nb);
1641                 if (ret) {
1642                         dev_err(dev, "Failed to register USB notifier\n");
1643                         /*
1644                          * If usb_register_notifier() fails, set notifier_call
1645                          * to NULL, to avoid calling usb_unregister_notifier().
1646                          */
1647                         info->nb.notifier_call = NULL;
1648                 }
1649         }
1650 #endif
1651
1652         INIT_DEFERRABLE_WORK(&info->pwr_rdy_work, rt9455_pwr_rdy_work_callback);
1653         INIT_DEFERRABLE_WORK(&info->max_charging_time_work,
1654                              rt9455_max_charging_time_work_callback);
1655         INIT_DEFERRABLE_WORK(&info->batt_presence_work,
1656                              rt9455_batt_presence_work_callback);
1657
1658         rt9455_charger_config.of_node           = dev->of_node;
1659         rt9455_charger_config.drv_data          = info;
1660         rt9455_charger_config.supplied_to       = rt9455_charger_supplied_to;
1661         rt9455_charger_config.num_supplicants   =
1662                                         ARRAY_SIZE(rt9455_charger_supplied_to);
1663         ret = devm_request_threaded_irq(dev, client->irq, NULL,
1664                                         rt9455_irq_handler_thread,
1665                                         IRQF_TRIGGER_LOW | IRQF_ONESHOT,
1666                                         RT9455_DRIVER_NAME, info);
1667         if (ret) {
1668                 dev_err(dev, "Failed to register IRQ handler\n");
1669                 goto put_usb_notifier;
1670         }
1671
1672         ret = rt9455_hw_init(info, ichrg, ieoc_percentage, mivr, iaicr);
1673         if (ret) {
1674                 dev_err(dev, "Failed to set charger to its default values\n");
1675                 goto put_usb_notifier;
1676         }
1677
1678         info->charger = devm_power_supply_register(dev, &rt9455_charger_desc,
1679                                                    &rt9455_charger_config);
1680         if (IS_ERR(info->charger)) {
1681                 dev_err(dev, "Failed to register charger\n");
1682                 ret = PTR_ERR(info->charger);
1683                 goto put_usb_notifier;
1684         }
1685
1686         return 0;
1687
1688 put_usb_notifier:
1689 #if IS_ENABLED(CONFIG_USB_PHY)
1690         if (info->nb.notifier_call)  {
1691                 usb_unregister_notifier(info->usb_phy, &info->nb);
1692                 info->nb.notifier_call = NULL;
1693         }
1694 #endif
1695         return ret;
1696 }
1697
1698 static int rt9455_remove(struct i2c_client *client)
1699 {
1700         int ret;
1701         struct rt9455_info *info = i2c_get_clientdata(client);
1702
1703         ret = rt9455_register_reset(info);
1704         if (ret)
1705                 dev_err(&info->client->dev, "Failed to set charger to its default values\n");
1706
1707 #if IS_ENABLED(CONFIG_USB_PHY)
1708         if (info->nb.notifier_call)
1709                 usb_unregister_notifier(info->usb_phy, &info->nb);
1710 #endif
1711
1712         cancel_delayed_work_sync(&info->pwr_rdy_work);
1713         cancel_delayed_work_sync(&info->max_charging_time_work);
1714         cancel_delayed_work_sync(&info->batt_presence_work);
1715
1716         return ret;
1717 }
1718
1719 static const struct i2c_device_id rt9455_i2c_id_table[] = {
1720         { RT9455_DRIVER_NAME, 0 },
1721         { },
1722 };
1723 MODULE_DEVICE_TABLE(i2c, rt9455_i2c_id_table);
1724
1725 static const struct of_device_id rt9455_of_match[] = {
1726         { .compatible = "richtek,rt9455", },
1727         { },
1728 };
1729 MODULE_DEVICE_TABLE(of, rt9455_of_match);
1730
1731 static const struct acpi_device_id rt9455_i2c_acpi_match[] = {
1732         { "RT945500", 0 },
1733         { }
1734 };
1735 MODULE_DEVICE_TABLE(acpi, rt9455_i2c_acpi_match);
1736
1737 static struct i2c_driver rt9455_driver = {
1738         .probe          = rt9455_probe,
1739         .remove         = rt9455_remove,
1740         .id_table       = rt9455_i2c_id_table,
1741         .driver = {
1742                 .name           = RT9455_DRIVER_NAME,
1743                 .of_match_table = of_match_ptr(rt9455_of_match),
1744                 .acpi_match_table = ACPI_PTR(rt9455_i2c_acpi_match),
1745         },
1746 };
1747 module_i2c_driver(rt9455_driver);
1748
1749 MODULE_LICENSE("GPL");
1750 MODULE_AUTHOR("Anda-Maria Nicolae <anda-maria.nicolae@intel.com>");
1751 MODULE_ALIAS("i2c:rt9455-charger");
1752 MODULE_DESCRIPTION("Richtek RT9455 Charger Driver");