2 * Driver for Richtek RT9455WSC battery charger.
4 * Copyright (C) 2015 Intel Corporation
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.
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.
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>
29 #define RT9455_MANUFACTURER "Richtek"
30 #define RT9455_MODEL_NAME "RT9455"
31 #define RT9455_DRIVER_NAME "rt9455-charger"
33 #define RT9455_IRQ_NAME "interrupt"
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 */
39 #define RT9455_CHARGE_MODE 0x00
40 #define RT9455_BOOST_MODE 0x01
42 #define RT9455_FAULT 0x03
44 #define RT9455_IAICR_100MA 0x00
45 #define RT9455_IAICR_500MA 0x01
46 #define RT9455_IAICR_NO_LIMIT 0x03
48 #define RT9455_CHARGE_DISABLE 0x00
49 #define RT9455_CHARGE_ENABLE 0x01
51 #define RT9455_PWR_FAULT 0x00
52 #define RT9455_PWR_GOOD 0x01
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 */
70 F_STAT, F_BOOST, F_PWR_RDY, F_OTG_PIN_POLARITY, /* CTRL1 reg fields */
72 F_IAICR, F_TE_SHDN_EN, F_HIGHER_OCP, F_TE, F_IAICR_INT, F_HIZ,
73 F_OPA_MODE, /* CTRL2 reg fields */
75 F_VOREG, F_OTG_PL, F_OTG_EN, /* CTRL3 reg fields */
77 F_VENDOR_ID, F_CHIP_REV, /* DEV_ID reg fields */
79 F_RST, /* CTRL4 reg fields */
81 F_TMR_EN, F_MIVR, F_IPREC, F_IEOC_PERCENTAGE, /* CTRL5 reg fields*/
83 F_IAICR_SEL, F_ICHRG, F_VPREC, /* CTRL6 reg fields */
85 F_BATD_EN, F_CHG_EN, F_VMREG, /* CTRL7 reg fields */
87 F_TSDI, F_VINOVPI, F_BATAB, /* IRQ1 reg fields */
89 F_CHRVPI, F_CHBATOVI, F_CHTERMI, F_CHRCHGI, F_CH32MI, F_CHTREGI,
90 F_CHMIVRI, /* IRQ2 reg fields */
92 F_BSTBUSOVI, F_BSTOLI, F_BSTLOWVI, F_BST32SI, /* IRQ3 reg fields */
94 F_TSDM, F_VINOVPIM, F_BATABM, /* MASK1 reg fields */
96 F_CHRVPIM, F_CHBATOVIM, F_CHTERMIM, F_CHRCHGIM, F_CH32MIM, F_CHTREGIM,
97 F_CHMIVRIM, /* MASK2 reg fields */
99 F_BSTVINOVIM, F_BSTOLIM, F_BSTLOWVIM, F_BST32SIM, /* MASK3 reg fields */
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),
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),
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),
122 [F_VENDOR_ID] = REG_FIELD(RT9455_REG_DEV_ID, 4, 7),
123 [F_CHIP_REV] = REG_FIELD(RT9455_REG_DEV_ID, 0, 3),
125 [F_RST] = REG_FIELD(RT9455_REG_CTRL4, 7, 7),
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),
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),
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),
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),
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),
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),
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),
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),
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),
175 #define GET_MASK(fid) (BIT(rt9455_reg_fields[fid].msb + 1) - \
176 BIT(rt9455_reg_fields[fid].lsb))
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.
184 /* REG06[6:4] (ICHRG) in uAh */
185 static const int rt9455_ichrg_values[] = {
186 500000, 650000, 800000, 950000, 1100000, 1250000, 1400000, 1550000
190 * When the charger is in charge mode, REG02[7:2] represent battery regulation
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
206 * When the charger is in boost mode, REG02[7:2] represent boost output
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,
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
227 /* REG05[5:4] (IEOC_PERCENTAGE) */
228 static const int rt9455_ieoc_percentage_values[] = {
232 /* REG05[1:0] (MIVR) in uV */
233 static const int rt9455_mivr_values[] = {
234 4000000, 4250000, 4500000, 5000000
237 /* REG05[1:0] (IAICR) in uA */
238 static const int rt9455_iaicr_values[] = {
239 100000, 500000, 1000000, 2000000
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;
251 struct delayed_work pwr_rdy_work;
252 struct delayed_work max_charging_time_work;
253 struct delayed_work batt_presence_work;
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.
263 static unsigned int rt9455_find_idx(const int tbl[], int tbl_size, int v)
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.
273 for (i = 0; i < tbl_size - 1; i++)
277 return (tbl_size - 1);
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)
287 ret = regmap_field_read(info->regmap_fields[field], &v);
291 v = (v >= tbl_size) ? (tbl_size - 1) : v;
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)
301 unsigned int idx = rt9455_find_idx(tbl, tbl_size, val);
303 return regmap_field_write(info->regmap_fields[field], idx);
306 static int rt9455_register_reset(struct rt9455_info *info)
308 struct device *dev = &info->client->dev;
310 int ret, limit = 100;
312 ret = regmap_field_write(info->regmap_fields[F_RST], 0x01);
314 dev_err(dev, "Failed to set RST bit\n");
319 * To make sure that reset operation has finished, loop until RST bit
323 ret = regmap_field_read(info->regmap_fields[F_RST], &v);
325 dev_err(dev, "Failed to read RST bit\n");
332 usleep_range(10, 100);
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,
357 static char *rt9455_charger_supplied_to[] = {
361 static int rt9455_charger_get_status(struct rt9455_info *info,
362 union power_supply_propval *val)
364 unsigned int v, pwr_rdy;
367 ret = regmap_field_read(info->regmap_fields[F_PWR_RDY],
370 dev_err(&info->client->dev, "Failed to read PWR_RDY bit\n");
375 * If PWR_RDY bit is unset, the battery is discharging. Otherwise,
376 * STAT bits value must be checked.
379 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
383 ret = regmap_field_read(info->regmap_fields[F_STAT], &v);
385 dev_err(&info->client->dev, "Failed to read STAT bits\n");
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
399 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
402 val->intval = POWER_SUPPLY_STATUS_CHARGING;
405 val->intval = POWER_SUPPLY_STATUS_FULL;
408 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
413 static int rt9455_charger_get_health(struct rt9455_info *info,
414 union power_supply_propval *val)
416 struct device *dev = &info->client->dev;
420 val->intval = POWER_SUPPLY_HEALTH_GOOD;
422 ret = regmap_read(info->regmap, RT9455_REG_IRQ1, &v);
424 dev_err(dev, "Failed to read IRQ1 register\n");
428 if (v & GET_MASK(F_TSDI)) {
429 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
432 if (v & GET_MASK(F_VINOVPI)) {
433 val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
436 if (v & GET_MASK(F_BATAB)) {
437 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
441 ret = regmap_read(info->regmap, RT9455_REG_IRQ2, &v);
443 dev_err(dev, "Failed to read IRQ2 register\n");
447 if (v & GET_MASK(F_CHBATOVI)) {
448 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
451 if (v & GET_MASK(F_CH32MI)) {
452 val->intval = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
456 ret = regmap_read(info->regmap, RT9455_REG_IRQ3, &v);
458 dev_err(dev, "Failed to read IRQ3 register\n");
462 if (v & GET_MASK(F_BSTBUSOVI)) {
463 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
466 if (v & GET_MASK(F_BSTOLI)) {
467 val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
470 if (v & GET_MASK(F_BSTLOWVI)) {
471 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
474 if (v & GET_MASK(F_BST32SI)) {
475 val->intval = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
479 ret = regmap_field_read(info->regmap_fields[F_STAT], &v);
481 dev_err(dev, "Failed to read STAT bits\n");
485 if (v == RT9455_FAULT) {
486 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
493 static int rt9455_charger_get_battery_presence(struct rt9455_info *info,
494 union power_supply_propval *val)
499 ret = regmap_field_read(info->regmap_fields[F_BATAB], &v);
501 dev_err(&info->client->dev, "Failed to read BATAB bit\n");
506 * Since BATAB is 1 when battery is NOT present and 0 otherwise,
507 * !BATAB is returned.
514 static int rt9455_charger_get_online(struct rt9455_info *info,
515 union power_supply_propval *val)
520 ret = regmap_field_read(info->regmap_fields[F_PWR_RDY], &v);
522 dev_err(&info->client->dev, "Failed to read PWR_RDY bit\n");
526 val->intval = (int)v;
531 static int rt9455_charger_get_current(struct rt9455_info *info,
532 union power_supply_propval *val)
537 ret = rt9455_get_field_val(info, F_ICHRG,
539 ARRAY_SIZE(rt9455_ichrg_values),
542 dev_err(&info->client->dev, "Failed to read ICHRG value\n");
551 static int rt9455_charger_get_current_max(struct rt9455_info *info,
552 union power_supply_propval *val)
554 int idx = ARRAY_SIZE(rt9455_ichrg_values) - 1;
556 val->intval = rt9455_ichrg_values[idx];
561 static int rt9455_charger_get_voltage(struct rt9455_info *info,
562 union power_supply_propval *val)
567 ret = rt9455_get_field_val(info, F_VOREG,
569 ARRAY_SIZE(rt9455_voreg_values),
572 dev_err(&info->client->dev, "Failed to read VOREG value\n");
576 val->intval = voltage;
581 static int rt9455_charger_get_voltage_max(struct rt9455_info *info,
582 union power_supply_propval *val)
584 int idx = ARRAY_SIZE(rt9455_vmreg_values) - 1;
586 val->intval = rt9455_vmreg_values[idx];
591 static int rt9455_charger_get_term_current(struct rt9455_info *info,
592 union power_supply_propval *val)
594 struct device *dev = &info->client->dev;
595 int ichrg, ieoc_percentage, ret;
597 ret = rt9455_get_field_val(info, F_ICHRG,
599 ARRAY_SIZE(rt9455_ichrg_values),
602 dev_err(dev, "Failed to read ICHRG value\n");
606 ret = rt9455_get_field_val(info, F_IEOC_PERCENTAGE,
607 rt9455_ieoc_percentage_values,
608 ARRAY_SIZE(rt9455_ieoc_percentage_values),
611 dev_err(dev, "Failed to read IEOC value\n");
615 val->intval = ichrg * ieoc_percentage / 100;
620 static int rt9455_charger_get_property(struct power_supply *psy,
621 enum power_supply_property psp,
622 union power_supply_propval *val)
624 struct rt9455_info *info = power_supply_get_drvdata(psy);
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;
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;
651 case POWER_SUPPLY_PROP_MANUFACTURER:
652 val->strval = RT9455_MANUFACTURER;
659 static int rt9455_hw_init(struct rt9455_info *info, u32 ichrg,
663 struct device *dev = &info->client->dev;
666 ret = rt9455_register_reset(info);
668 dev_err(dev, "Power On Reset failed\n");
672 /* Set TE bit in order to enable end of charge detection */
673 ret = regmap_field_write(info->regmap_fields[F_TE], 1);
675 dev_err(dev, "Failed to set TE bit\n");
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);
682 dev_err(dev, "Failed to set TE_SHDN_EN bit\n");
687 * Set BATD_EN bit in order to enable battery detection
688 * when charging is done
690 ret = regmap_field_write(info->regmap_fields[F_BATD_EN], 1);
692 dev_err(dev, "Failed to set BATD_EN bit\n");
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
707 ret = regmap_field_write(info->regmap_fields[F_TMR_EN], 0x00);
709 dev_err(dev, "Failed to disable Safety Timer\n");
713 /* Set ICHRG to value retrieved from device-specific data */
714 ret = rt9455_set_field_val(info, F_ICHRG,
716 ARRAY_SIZE(rt9455_ichrg_values), ichrg);
718 dev_err(dev, "Failed to set ICHRG value\n");
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),
728 dev_err(dev, "Failed to set IEOC Percentage value\n");
732 /* Set VOREG to value retrieved from device-specific data */
733 ret = rt9455_set_field_val(info, F_VOREG,
735 ARRAY_SIZE(rt9455_voreg_values),
738 dev_err(dev, "Failed to set VOREG value\n");
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,
746 ARRAY_SIZE(rt9455_vmreg_values),
747 rt9455_vmreg_values[idx]);
749 dev_err(dev, "Failed to set VMREG value\n");
754 * Set MIVR to value retrieved from device-specific data.
755 * If no value is specified, default value for MIVR is 4.5V.
760 ret = rt9455_set_field_val(info, F_MIVR,
762 ARRAY_SIZE(rt9455_mivr_values), mivr);
764 dev_err(dev, "Failed to set MIVR value\n");
769 * Set IAICR to value retrieved from device-specific data.
770 * If no value is specified, default value for IAICR is 500 mA.
775 ret = rt9455_set_field_val(info, F_IAICR,
777 ARRAY_SIZE(rt9455_iaicr_values), iaicr);
779 dev_err(dev, "Failed to set IAICR value\n");
784 * Set IAICR_INT bit so that IAICR value is determined by IAICR bits
785 * and not by OTG pin.
787 ret = regmap_field_write(info->regmap_fields[F_IAICR_INT], 0x01);
789 dev_err(dev, "Failed to set IAICR_INT bit\n");
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.
798 ret = regmap_field_write(info->regmap_fields[F_CHMIVRIM], 0x01);
800 dev_err(dev, "Failed to mask CHMIVRI interrupt\n");
807 #if IS_ENABLED(CONFIG_USB_PHY)
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
816 static int rt9455_set_boost_voltage_before_boost_mode(struct rt9455_info *info)
818 struct device *dev = &info->client->dev;
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);
826 dev_err(dev, "Failed to set boost output voltage value\n");
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
842 static int rt9455_set_voreg_before_charge_mode(struct rt9455_info *info)
844 struct device *dev = &info->client->dev;
847 ret = rt9455_set_field_val(info, F_VOREG,
849 ARRAY_SIZE(rt9455_voreg_values),
852 dev_err(dev, "Failed to set VOREG value\n");
859 static int rt9455_irq_handler_check_irq1_register(struct rt9455_info *info,
860 bool *_is_battery_absent,
861 bool *_alert_userspace)
863 unsigned int irq1, mask1, mask2;
864 struct device *dev = &info->client->dev;
865 bool is_battery_absent = false;
866 bool alert_userspace = false;
869 ret = regmap_read(info->regmap, RT9455_REG_IRQ1, &irq1);
871 dev_err(dev, "Failed to read IRQ1 register\n");
875 ret = regmap_read(info->regmap, RT9455_REG_MASK1, &mask1);
877 dev_err(dev, "Failed to read MASK1 register\n");
881 if (irq1 & GET_MASK(F_TSDI)) {
882 dev_err(dev, "Thermal shutdown fault occurred\n");
883 alert_userspace = true;
886 if (irq1 & GET_MASK(F_VINOVPI)) {
887 dev_err(dev, "Overvoltage input occurred\n");
888 alert_userspace = true;
891 if (irq1 & GET_MASK(F_BATAB)) {
892 dev_err(dev, "Battery absence occurred\n");
893 is_battery_absent = true;
894 alert_userspace = true;
896 if ((mask1 & GET_MASK(F_BATABM)) == 0) {
897 ret = regmap_field_write(info->regmap_fields[F_BATABM],
900 dev_err(dev, "Failed to mask BATAB interrupt\n");
905 ret = regmap_read(info->regmap, RT9455_REG_MASK2, &mask2);
907 dev_err(dev, "Failed to read MASK2 register\n");
911 if (mask2 & GET_MASK(F_CHTERMIM)) {
912 ret = regmap_field_write(
913 info->regmap_fields[F_CHTERMIM], 0x00);
915 dev_err(dev, "Failed to unmask CHTERMI interrupt\n");
920 if (mask2 & GET_MASK(F_CHRCHGIM)) {
921 ret = regmap_field_write(
922 info->regmap_fields[F_CHRCHGIM], 0x00);
924 dev_err(dev, "Failed to unmask CHRCHGI interrupt\n");
930 * When the battery is absent, max_charging_time_work is
931 * cancelled, since no charging is done.
933 cancel_delayed_work_sync(&info->max_charging_time_work);
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.
940 queue_delayed_work(system_power_efficient_wq,
941 &info->batt_presence_work,
942 RT9455_BATT_PRESENCE_DELAY * HZ);
945 *_is_battery_absent = is_battery_absent;
948 *_alert_userspace = alert_userspace;
953 static int rt9455_irq_handler_check_irq2_register(struct rt9455_info *info,
954 bool is_battery_absent,
955 bool *_alert_userspace)
957 unsigned int irq2, mask2;
958 struct device *dev = &info->client->dev;
959 bool alert_userspace = false;
962 ret = regmap_read(info->regmap, RT9455_REG_IRQ2, &irq2);
964 dev_err(dev, "Failed to read IRQ2 register\n");
968 ret = regmap_read(info->regmap, RT9455_REG_MASK2, &mask2);
970 dev_err(dev, "Failed to read MASK2 register\n");
974 if (irq2 & GET_MASK(F_CHRVPI)) {
975 dev_dbg(dev, "Charger fault occurred\n");
976 alert_userspace = true;
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.
985 queue_delayed_work(system_power_efficient_wq,
987 RT9455_PWR_RDY_DELAY * HZ);
989 if (irq2 & GET_MASK(F_CHBATOVI)) {
990 dev_err(dev, "Battery OVP occurred\n");
991 alert_userspace = true;
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);
1000 dev_err(dev, "Failed to mask CHTERMI interrupt\n");
1004 * Update MASK2 value, since CHTERMIM bit is
1007 mask2 = mask2 | GET_MASK(F_CHTERMIM);
1009 cancel_delayed_work_sync(&info->max_charging_time_work);
1010 alert_userspace = true;
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);
1018 dev_err(dev, "Failed to enable charging\n");
1021 if (mask2 & GET_MASK(F_CHTERMIM)) {
1022 ret = regmap_field_write(
1023 info->regmap_fields[F_CHTERMIM], 0x00);
1025 dev_err(dev, "Failed to unmask CHTERMI interrupt\n");
1028 /* Update MASK2 value, since CHTERMIM bit is cleared. */
1029 mask2 = mask2 & ~GET_MASK(F_CHTERMIM);
1031 if (!is_battery_absent) {
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
1038 queue_delayed_work(system_power_efficient_wq,
1039 &info->max_charging_time_work,
1040 RT9455_MAX_CHARGING_TIME * HZ);
1041 alert_userspace = true;
1044 if (irq2 & GET_MASK(F_CH32MI)) {
1045 dev_err(dev, "Charger fault. 32 mins timeout occurred\n");
1046 alert_userspace = true;
1048 if (irq2 & GET_MASK(F_CHTREGI)) {
1050 "Charger warning. Thermal regulation loop active\n");
1051 alert_userspace = true;
1053 if (irq2 & GET_MASK(F_CHMIVRI)) {
1055 "Charger warning. Input voltage MIVR loop active\n");
1058 if (alert_userspace)
1059 *_alert_userspace = alert_userspace;
1064 static int rt9455_irq_handler_check_irq3_register(struct rt9455_info *info,
1065 bool *_alert_userspace)
1067 unsigned int irq3, mask3;
1068 struct device *dev = &info->client->dev;
1069 bool alert_userspace = false;
1072 ret = regmap_read(info->regmap, RT9455_REG_IRQ3, &irq3);
1074 dev_err(dev, "Failed to read IRQ3 register\n");
1078 ret = regmap_read(info->regmap, RT9455_REG_MASK3, &mask3);
1080 dev_err(dev, "Failed to read MASK3 register\n");
1084 if (irq3 & GET_MASK(F_BSTBUSOVI)) {
1085 dev_err(dev, "Boost fault. Overvoltage input occurred\n");
1086 alert_userspace = true;
1088 if (irq3 & GET_MASK(F_BSTOLI)) {
1089 dev_err(dev, "Boost fault. Overload\n");
1090 alert_userspace = true;
1092 if (irq3 & GET_MASK(F_BSTLOWVI)) {
1093 dev_err(dev, "Boost fault. Battery voltage too low\n");
1094 alert_userspace = true;
1096 if (irq3 & GET_MASK(F_BST32SI)) {
1097 dev_err(dev, "Boost fault. 32 seconds timeout occurred.\n");
1098 alert_userspace = true;
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);
1105 dev_err(dev, "Failed to set VOREG before entering charge mode\n");
1108 ret = regmap_field_write(info->regmap_fields[F_OPA_MODE],
1109 RT9455_CHARGE_MODE);
1111 dev_err(dev, "Failed to set charger in charge mode\n");
1114 *_alert_userspace = alert_userspace;
1120 static irqreturn_t rt9455_irq_handler_thread(int irq, void *data)
1122 struct rt9455_info *info = data;
1124 bool alert_userspace = false;
1125 bool is_battery_absent = false;
1126 unsigned int status;
1132 dev = &info->client->dev;
1134 if (irq != info->client->irq) {
1135 dev_err(dev, "Interrupt is not for RT9455 charger\n");
1139 ret = regmap_field_read(info->regmap_fields[F_STAT], &status);
1141 dev_err(dev, "Failed to read STAT bits\n");
1144 dev_dbg(dev, "Charger status is %d\n", status);
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.
1157 ret = rt9455_irq_handler_check_irq1_register(info, &is_battery_absent,
1160 dev_err(dev, "Failed to handle IRQ1 register\n");
1164 ret = rt9455_irq_handler_check_irq2_register(info, is_battery_absent,
1167 dev_err(dev, "Failed to handle IRQ2 register\n");
1171 ret = rt9455_irq_handler_check_irq3_register(info, &alert_userspace);
1173 dev_err(dev, "Failed to handle IRQ3 register\n");
1177 if (alert_userspace) {
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.
1184 power_supply_changed(info->charger);
1190 static int rt9455_discover_charger(struct rt9455_info *info, u32 *ichrg,
1191 u32 *ieoc_percentage,
1192 u32 *mivr, u32 *iaicr)
1194 struct device *dev = &info->client->dev;
1197 if (!dev->of_node && !ACPI_HANDLE(dev)) {
1198 dev_err(dev, "No support for either device tree or ACPI\n");
1202 * ICHRG, IEOC_PERCENTAGE, VOREG and boost output voltage are mandatory
1205 ret = device_property_read_u32(dev, "richtek,output-charge-current",
1208 dev_err(dev, "Error: missing \"output-charge-current\" property\n");
1212 ret = device_property_read_u32(dev, "richtek,end-of-charge-percentage",
1215 dev_err(dev, "Error: missing \"end-of-charge-percentage\" property\n");
1219 ret = device_property_read_u32(dev,
1220 "richtek,battery-regulation-voltage",
1223 dev_err(dev, "Error: missing \"battery-regulation-voltage\" property\n");
1227 ret = device_property_read_u32(dev, "richtek,boost-output-voltage",
1228 &info->boost_voltage);
1230 dev_err(dev, "Error: missing \"boost-output-voltage\" property\n");
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.
1238 device_property_read_u32(dev, "richtek,min-input-voltage-regulation",
1240 device_property_read_u32(dev, "richtek,avg-input-current-regulation",
1246 #if IS_ENABLED(CONFIG_USB_PHY)
1247 static int rt9455_usb_event_none(struct rt9455_info *info,
1248 u8 opa_mode, u8 iaicr)
1250 struct device *dev = &info->client->dev;
1253 if (opa_mode == RT9455_BOOST_MODE) {
1254 ret = rt9455_set_voreg_before_charge_mode(info);
1256 dev_err(dev, "Failed to set VOREG before entering charge mode\n");
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.
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);
1269 dev_err(dev, "Failed to set charger in charge mode\n");
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);
1279 dev_err(dev, "Failed to set IAICR value\n");
1287 static int rt9455_usb_event_vbus(struct rt9455_info *info,
1288 u8 opa_mode, u8 iaicr)
1290 struct device *dev = &info->client->dev;
1293 if (opa_mode == RT9455_BOOST_MODE) {
1294 ret = rt9455_set_voreg_before_charge_mode(info);
1296 dev_err(dev, "Failed to set VOREG before entering charge mode\n");
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.
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);
1309 dev_err(dev, "Failed to set charger in charge mode\n");
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);
1319 dev_err(dev, "Failed to set IAICR value\n");
1327 static int rt9455_usb_event_id(struct rt9455_info *info,
1328 u8 opa_mode, u8 iaicr)
1330 struct device *dev = &info->client->dev;
1333 if (opa_mode == RT9455_CHARGE_MODE) {
1334 ret = rt9455_set_boost_voltage_before_boost_mode(info);
1336 dev_err(dev, "Failed to set boost output voltage before entering boost mode\n");
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.
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],
1349 dev_err(dev, "Failed to set charger in boost mode\n");
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);
1359 dev_err(dev, "Failed to set IAICR value\n");
1367 static int rt9455_usb_event_charger(struct rt9455_info *info,
1368 u8 opa_mode, u8 iaicr)
1370 struct device *dev = &info->client->dev;
1373 if (opa_mode == RT9455_BOOST_MODE) {
1374 ret = rt9455_set_voreg_before_charge_mode(info);
1376 dev_err(dev, "Failed to set VOREG before entering charge mode\n");
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.
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);
1389 dev_err(dev, "Failed to set charger in charge mode\n");
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);
1399 dev_err(dev, "Failed to set IAICR value\n");
1407 static int rt9455_usb_event(struct notifier_block *nb,
1408 unsigned long event, void *power)
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;
1416 * Determine whether the charger is in charge mode
1419 ret = regmap_field_read(info->regmap_fields[F_OPA_MODE],
1422 dev_err(dev, "Failed to read OPA_MODE value\n");
1426 ret = regmap_field_read(info->regmap_fields[F_IAICR],
1429 dev_err(dev, "Failed to read IAICR value\n");
1433 dev_dbg(dev, "Received USB event %lu\n", 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);
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);
1444 dev_err(dev, "Unknown USB event\n");
1450 static void rt9455_pwr_rdy_work_callback(struct work_struct *work)
1452 struct rt9455_info *info = container_of(work, struct rt9455_info,
1454 struct device *dev = &info->client->dev;
1455 unsigned int pwr_rdy;
1458 ret = regmap_field_read(info->regmap_fields[F_PWR_RDY], &pwr_rdy);
1460 dev_err(dev, "Failed to read PWR_RDY bit\n");
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);
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);
1473 dev_err(dev, "Failed to enable charging\n");
1476 queue_delayed_work(system_power_efficient_wq,
1477 &info->max_charging_time_work,
1478 RT9455_MAX_CHARGING_TIME * HZ);
1483 static void rt9455_max_charging_time_work_callback(struct work_struct *work)
1485 struct rt9455_info *info = container_of(work, struct rt9455_info,
1486 max_charging_time_work.work);
1487 struct device *dev = &info->client->dev;
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);
1494 dev_err(dev, "Failed to disable charging\n");
1497 static void rt9455_batt_presence_work_callback(struct work_struct *work)
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;
1505 ret = regmap_read(info->regmap, RT9455_REG_IRQ1, &irq1);
1507 dev_err(dev, "Failed to read IRQ1 register\n");
1512 * If the battery is still absent, batt_presence_work is rescheduled.
1513 * Otherwise, max_charging_time is scheduled.
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);
1520 queue_delayed_work(system_power_efficient_wq,
1521 &info->max_charging_time_work,
1522 RT9455_MAX_CHARGING_TIME * HZ);
1524 ret = regmap_read(info->regmap, RT9455_REG_MASK1, &mask1);
1526 dev_err(dev, "Failed to read MASK1 register\n");
1530 if (mask1 & GET_MASK(F_BATABM)) {
1531 ret = regmap_field_write(info->regmap_fields[F_BATABM],
1534 dev_err(dev, "Failed to unmask BATAB interrupt\n");
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,
1547 static bool rt9455_is_writeable_reg(struct device *dev, unsigned int reg)
1550 case RT9455_REG_DEV_ID:
1551 case RT9455_REG_IRQ1:
1552 case RT9455_REG_IRQ2:
1553 case RT9455_REG_IRQ3:
1560 static bool rt9455_is_volatile_reg(struct device *dev, unsigned int reg)
1563 case RT9455_REG_DEV_ID:
1564 case RT9455_REG_CTRL5:
1565 case RT9455_REG_CTRL6:
1572 static const struct regmap_config rt9455_regmap_config = {
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,
1581 static int rt9455_probe(struct i2c_client *client,
1582 const struct i2c_device_id *id)
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 = {};
1589 * Mandatory device-specific data values. Also, VOREG and boost output
1590 * voltage are mandatory values, but they are stored in rt9455_info
1593 u32 ichrg, ieoc_percentage;
1594 /* Optional device-specific data values. */
1595 u32 mivr = -1, iaicr = -1;
1598 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1599 dev_err(dev, "No support for SMBUS_BYTE_DATA\n");
1602 info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL);
1606 info->client = client;
1607 i2c_set_clientdata(client, info);
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");
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])) {
1622 "Failed to allocate regmap field = %d\n", i);
1623 return PTR_ERR(info->regmap_fields[i]);
1627 ret = rt9455_discover_charger(info, &ichrg, &ieoc_percentage,
1630 dev_err(dev, "Failed to discover charger\n");
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");
1639 info->nb.notifier_call = rt9455_usb_event;
1640 ret = usb_register_notifier(info->usb_phy, &info->nb);
1642 dev_err(dev, "Failed to register USB notifier\n");
1644 * If usb_register_notifier() fails, set notifier_call
1645 * to NULL, to avoid calling usb_unregister_notifier().
1647 info->nb.notifier_call = NULL;
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);
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);
1668 dev_err(dev, "Failed to register IRQ handler\n");
1669 goto put_usb_notifier;
1672 ret = rt9455_hw_init(info, ichrg, ieoc_percentage, mivr, iaicr);
1674 dev_err(dev, "Failed to set charger to its default values\n");
1675 goto put_usb_notifier;
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;
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;
1698 static int rt9455_remove(struct i2c_client *client)
1701 struct rt9455_info *info = i2c_get_clientdata(client);
1703 ret = rt9455_register_reset(info);
1705 dev_err(&info->client->dev, "Failed to set charger to its default values\n");
1707 #if IS_ENABLED(CONFIG_USB_PHY)
1708 if (info->nb.notifier_call)
1709 usb_unregister_notifier(info->usb_phy, &info->nb);
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);
1719 static const struct i2c_device_id rt9455_i2c_id_table[] = {
1720 { RT9455_DRIVER_NAME, 0 },
1723 MODULE_DEVICE_TABLE(i2c, rt9455_i2c_id_table);
1725 static const struct of_device_id rt9455_of_match[] = {
1726 { .compatible = "richtek,rt9455", },
1729 MODULE_DEVICE_TABLE(of, rt9455_of_match);
1731 static const struct acpi_device_id rt9455_i2c_acpi_match[] = {
1735 MODULE_DEVICE_TABLE(acpi, rt9455_i2c_acpi_match);
1737 static struct i2c_driver rt9455_driver = {
1738 .probe = rt9455_probe,
1739 .remove = rt9455_remove,
1740 .id_table = rt9455_i2c_id_table,
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),
1747 module_i2c_driver(rt9455_driver);
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");