drivers/power/supply/rt9455_charger.c

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