1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (C) 2022 Richtek Technology Corp.
4 *
5 * Author: ChiYuan Huang <cy_huang@richtek.com>
6 * ChiaEn Wu <chiaen_wu@richtek.com>
7 */
8
9 #include <linux/bits.h>
10 #include <linux/bitfield.h>
11 #include <linux/completion.h>
12 #include <linux/delay.h>
13 #include <linux/gpio/consumer.h>
14 #include <linux/i2c.h>
15 #include <linux/interrupt.h>
16 #include <linux/kernel.h>
17 #include <linux/kstrtox.h>
18 #include <linux/linear_range.h>
19 #include <linux/module.h>
20 #include <linux/mutex.h>
21 #include <linux/of.h>
22 #include <linux/power_supply.h>
23 #include <linux/regmap.h>
24 #include <linux/regulator/driver.h>
25 #include <linux/units.h>
26 #include <linux/sysfs.h>
27
28 #define RT9467_REG_CORE_CTRL0 0x00
29 #define RT9467_REG_CHG_CTRL1 0x01
30 #define RT9467_REG_CHG_CTRL2 0x02
31 #define RT9467_REG_CHG_CTRL3 0x03
32 #define RT9467_REG_CHG_CTRL4 0x04
33 #define RT9467_REG_CHG_CTRL5 0x05
34 #define RT9467_REG_CHG_CTRL6 0x06
35 #define RT9467_REG_CHG_CTRL7 0x07
36 #define RT9467_REG_CHG_CTRL8 0x08
37 #define RT9467_REG_CHG_CTRL9 0x09
38 #define RT9467_REG_CHG_CTRL10 0x0A
39 #define RT9467_REG_CHG_CTRL12 0x0C
40 #define RT9467_REG_CHG_CTRL13 0x0D
41 #define RT9467_REG_CHG_CTRL14 0x0E
42 #define RT9467_REG_CHG_ADC 0x11
43 #define RT9467_REG_CHG_DPDM1 0x12
44 #define RT9467_REG_CHG_DPDM2 0x13
45 #define RT9467_REG_DEVICE_ID 0x40
46 #define RT9467_REG_CHG_STAT 0x42
47 #define RT9467_REG_ADC_DATA_H 0x44
48 #define RT9467_REG_CHG_STATC 0x50
49 #define RT9467_REG_CHG_IRQ1 0x53
50 #define RT9467_REG_CHG_STATC_CTRL 0x60
51 #define RT9467_REG_CHG_IRQ1_CTRL 0x63
52
53 #define RT9467_MASK_PWR_RDY BIT(7)
54 #define RT9467_MASK_MIVR_STAT BIT(6)
55 #define RT9467_MASK_OTG_CSEL GENMASK(2, 0)
56 #define RT9467_MASK_OTG_VSEL GENMASK(7, 2)
57 #define RT9467_MASK_OTG_EN BIT(0)
58 #define RT9467_MASK_ADC_IN_SEL GENMASK(7, 4)
59 #define RT9467_MASK_ADC_START BIT(0)
60
61 #define RT9467_NUM_IRQ_REGS 4
62 #define RT9467_ICHG_MIN_uA 100000
63 #define RT9467_ICHG_MAX_uA 5000000
64 #define RT9467_CV_MAX_uV 4710000
65 #define RT9467_OTG_MIN_uV 4425000
66 #define RT9467_OTG_MAX_uV 5825000
67 #define RT9467_OTG_STEP_uV 25000
68 #define RT9467_NUM_VOTG (RT9467_OTG_MAX_uV - RT9467_OTG_MIN_uV + 1)
69 #define RT9467_AICLVTH_GAP_uV 200000
70 #define RT9467_ADCCONV_TIME_MS 35
71
72 #define RT9466_VID 0x8
73 #define RT9467_VID 0x9
74
75 /* IRQ number */
76 #define RT9467_IRQ_TS_STATC 0
77 #define RT9467_IRQ_CHG_FAULT 1
78 #define RT9467_IRQ_CHG_STATC 2
79 #define RT9467_IRQ_CHG_TMR 3
80 #define RT9467_IRQ_CHG_BATABS 4
81 #define RT9467_IRQ_CHG_ADPBAD 5
82 #define RT9467_IRQ_CHG_RVP 6
83 #define RT9467_IRQ_OTP 7
84
85 #define RT9467_IRQ_CHG_AICLM 8
86 #define RT9467_IRQ_CHG_ICHGM 9
87 #define RT9467_IRQ_WDTMR 11
88 #define RT9467_IRQ_SSFINISH 12
89 #define RT9467_IRQ_CHG_RECHG 13
90 #define RT9467_IRQ_CHG_TERM 14
91 #define RT9467_IRQ_CHG_IEOC 15
92
93 #define RT9467_IRQ_ADC_DONE 16
94 #define RT9467_IRQ_PUMPX_DONE 17
95 #define RT9467_IRQ_BST_BATUV 21
96 #define RT9467_IRQ_BST_MIDOV 22
97 #define RT9467_IRQ_BST_OLP 23
98
99 #define RT9467_IRQ_ATTACH 24
100 #define RT9467_IRQ_DETACH 25
101 #define RT9467_IRQ_HVDCP_DET 29
102 #define RT9467_IRQ_CHGDET 30
103 #define RT9467_IRQ_DCDT 31
104
105 enum rt9467_fields {
106 /* RT9467_REG_CORE_CTRL0 */
107 F_RST = 0,
108 /* RT9467_REG_CHG_CTRL1 */
109 F_HZ, F_OTG_PIN_EN, F_OPA_MODE,
110 /* RT9467_REG_CHG_CTRL2 */
111 F_SHIP_MODE, F_TE, F_IINLMTSEL, F_CFO_EN, F_CHG_EN,
112 /* RT9467_REG_CHG_CTRL3 */
113 F_IAICR, F_ILIM_EN,
114 /* RT9467_REG_CHG_CTRL4 */
115 F_VOREG,
116 /* RT9467_REG_CHG_CTRL6 */
117 F_VMIVR,
118 /* RT9467_REG_CHG_CTRL7 */
119 F_ICHG,
120 /* RT9467_REG_CHG_CTRL8 */
121 F_IPREC,
122 /* RT9467_REG_CHG_CTRL9 */
123 F_IEOC,
124 /* RT9467_REG_CHG_CTRL12 */
125 F_WT_FC,
126 /* RT9467_REG_CHG_CTRL13 */
127 F_OCP,
128 /* RT9467_REG_CHG_CTRL14 */
129 F_AICL_MEAS, F_AICL_VTH,
130 /* RT9467_REG_CHG_DPDM1 */
131 F_USBCHGEN,
132 /* RT9467_REG_CHG_DPDM2 */
133 F_USB_STATUS,
134 /* RT9467_REG_DEVICE_ID */
135 F_VENDOR,
136 /* RT9467_REG_CHG_STAT */
137 F_CHG_STAT,
138 /* RT9467_REG_CHG_STATC */
139 F_PWR_RDY, F_CHG_MIVR,
140 F_MAX_FIELDS
141 };
142
143 static const struct regmap_irq rt9467_irqs[] = {
144 REGMAP_IRQ_REG_LINE(RT9467_IRQ_TS_STATC, 8),
145 REGMAP_IRQ_REG_LINE(RT9467_IRQ_CHG_FAULT, 8),
146 REGMAP_IRQ_REG_LINE(RT9467_IRQ_CHG_STATC, 8),
147 REGMAP_IRQ_REG_LINE(RT9467_IRQ_CHG_TMR, 8),
148 REGMAP_IRQ_REG_LINE(RT9467_IRQ_CHG_BATABS, 8),
149 REGMAP_IRQ_REG_LINE(RT9467_IRQ_CHG_ADPBAD, 8),
150 REGMAP_IRQ_REG_LINE(RT9467_IRQ_CHG_RVP, 8),
151 REGMAP_IRQ_REG_LINE(RT9467_IRQ_OTP, 8),
152 REGMAP_IRQ_REG_LINE(RT9467_IRQ_CHG_AICLM, 8),
153 REGMAP_IRQ_REG_LINE(RT9467_IRQ_CHG_ICHGM, 8),
154 REGMAP_IRQ_REG_LINE(RT9467_IRQ_WDTMR, 8),
155 REGMAP_IRQ_REG_LINE(RT9467_IRQ_SSFINISH, 8),
156 REGMAP_IRQ_REG_LINE(RT9467_IRQ_CHG_RECHG, 8),
157 REGMAP_IRQ_REG_LINE(RT9467_IRQ_CHG_TERM, 8),
158 REGMAP_IRQ_REG_LINE(RT9467_IRQ_CHG_IEOC, 8),
159 REGMAP_IRQ_REG_LINE(RT9467_IRQ_ADC_DONE, 8),
160 REGMAP_IRQ_REG_LINE(RT9467_IRQ_PUMPX_DONE, 8),
161 REGMAP_IRQ_REG_LINE(RT9467_IRQ_BST_BATUV, 8),
162 REGMAP_IRQ_REG_LINE(RT9467_IRQ_BST_MIDOV, 8),
163 REGMAP_IRQ_REG_LINE(RT9467_IRQ_BST_OLP, 8),
164 REGMAP_IRQ_REG_LINE(RT9467_IRQ_ATTACH, 8),
165 REGMAP_IRQ_REG_LINE(RT9467_IRQ_DETACH, 8),
166 REGMAP_IRQ_REG_LINE(RT9467_IRQ_HVDCP_DET, 8),
167 REGMAP_IRQ_REG_LINE(RT9467_IRQ_CHGDET, 8),
168 REGMAP_IRQ_REG_LINE(RT9467_IRQ_DCDT, 8)
169 };
170
171 static const struct regmap_irq_chip rt9467_irq_chip = {
172 .name = "rt9467-irqs",
173 .status_base = RT9467_REG_CHG_IRQ1,
174 .mask_base = RT9467_REG_CHG_IRQ1_CTRL,
175 .num_regs = RT9467_NUM_IRQ_REGS,
176 .irqs = rt9467_irqs,
177 .num_irqs = ARRAY_SIZE(rt9467_irqs),
178 };
179
180 enum rt9467_ranges {
181 RT9467_RANGE_IAICR = 0,
182 RT9467_RANGE_VOREG,
183 RT9467_RANGE_VMIVR,
184 RT9467_RANGE_ICHG,
185 RT9467_RANGE_IPREC,
186 RT9467_RANGE_IEOC,
187 RT9467_RANGE_AICL_VTH,
188 RT9467_RANGES_MAX
189 };
190
191 static const struct linear_range rt9467_ranges[RT9467_RANGES_MAX] = {
192 LINEAR_RANGE_IDX(RT9467_RANGE_IAICR, 100000, 0x0, 0x3F, 50000),
193 LINEAR_RANGE_IDX(RT9467_RANGE_VOREG, 3900000, 0x0, 0x51, 10000),
194 LINEAR_RANGE_IDX(RT9467_RANGE_VMIVR, 3900000, 0x0, 0x5F, 100000),
195 LINEAR_RANGE_IDX(RT9467_RANGE_ICHG, 900000, 0x08, 0x31, 100000),
196 LINEAR_RANGE_IDX(RT9467_RANGE_IPREC, 100000, 0x0, 0x0F, 50000),
197 LINEAR_RANGE_IDX(RT9467_RANGE_IEOC, 100000, 0x0, 0x0F, 50000),
198 LINEAR_RANGE_IDX(RT9467_RANGE_AICL_VTH, 4100000, 0x0, 0x7, 100000),
199 };
200
201 static const struct reg_field rt9467_chg_fields[] = {
202 [F_RST] = REG_FIELD(RT9467_REG_CORE_CTRL0, 7, 7),
203 [F_HZ] = REG_FIELD(RT9467_REG_CHG_CTRL1, 2, 2),
204 [F_OTG_PIN_EN] = REG_FIELD(RT9467_REG_CHG_CTRL1, 1, 1),
205 [F_OPA_MODE] = REG_FIELD(RT9467_REG_CHG_CTRL1, 0, 0),
206 [F_SHIP_MODE] = REG_FIELD(RT9467_REG_CHG_CTRL2, 7, 7),
207 [F_TE] = REG_FIELD(RT9467_REG_CHG_CTRL2, 4, 4),
208 [F_IINLMTSEL] = REG_FIELD(RT9467_REG_CHG_CTRL2, 2, 3),
209 [F_CFO_EN] = REG_FIELD(RT9467_REG_CHG_CTRL2, 1, 1),
210 [F_CHG_EN] = REG_FIELD(RT9467_REG_CHG_CTRL2, 0, 0),
211 [F_IAICR] = REG_FIELD(RT9467_REG_CHG_CTRL3, 2, 7),
212 [F_ILIM_EN] = REG_FIELD(RT9467_REG_CHG_CTRL3, 0, 0),
213 [F_VOREG] = REG_FIELD(RT9467_REG_CHG_CTRL4, 1, 7),
214 [F_VMIVR] = REG_FIELD(RT9467_REG_CHG_CTRL6, 1, 7),
215 [F_ICHG] = REG_FIELD(RT9467_REG_CHG_CTRL7, 2, 7),
216 [F_IPREC] = REG_FIELD(RT9467_REG_CHG_CTRL8, 0, 3),
217 [F_IEOC] = REG_FIELD(RT9467_REG_CHG_CTRL9, 4, 7),
218 [F_WT_FC] = REG_FIELD(RT9467_REG_CHG_CTRL12, 5, 7),
219 [F_OCP] = REG_FIELD(RT9467_REG_CHG_CTRL13, 2, 2),
220 [F_AICL_MEAS] = REG_FIELD(RT9467_REG_CHG_CTRL14, 7, 7),
221 [F_AICL_VTH] = REG_FIELD(RT9467_REG_CHG_CTRL14, 0, 2),
222 [F_USBCHGEN] = REG_FIELD(RT9467_REG_CHG_DPDM1, 7, 7),
223 [F_USB_STATUS] = REG_FIELD(RT9467_REG_CHG_DPDM2, 0, 2),
224 [F_VENDOR] = REG_FIELD(RT9467_REG_DEVICE_ID, 4, 7),
225 [F_CHG_STAT] = REG_FIELD(RT9467_REG_CHG_STAT, 6, 7),
226 [F_PWR_RDY] = REG_FIELD(RT9467_REG_CHG_STATC, 7, 7),
227 [F_CHG_MIVR] = REG_FIELD(RT9467_REG_CHG_STATC, 6, 6),
228 };
229
230 enum {
231 RT9467_STAT_READY = 0,
232 RT9467_STAT_PROGRESS,
233 RT9467_STAT_CHARGE_DONE,
234 RT9467_STAT_FAULT
235 };
236
237 enum rt9467_adc_chan {
238 RT9467_ADC_VBUS_DIV5 = 0,
239 RT9467_ADC_VBUS_DIV2,
240 RT9467_ADC_VSYS,
241 RT9467_ADC_VBAT,
242 RT9467_ADC_TS_BAT,
243 RT9467_ADC_IBUS,
244 RT9467_ADC_IBAT,
245 RT9467_ADC_REGN,
246 RT9467_ADC_TEMP_JC
247 };
248
249 enum rt9467_chg_type {
250 RT9467_CHG_TYPE_NOVBUS = 0,
251 RT9467_CHG_TYPE_UNDER_GOING,
252 RT9467_CHG_TYPE_SDP,
253 RT9467_CHG_TYPE_SDPNSTD,
254 RT9467_CHG_TYPE_DCP,
255 RT9467_CHG_TYPE_CDP,
256 RT9467_CHG_TYPE_MAX
257 };
258
259 enum rt9467_iin_limit_sel {
260 RT9467_IINLMTSEL_3_2A = 0,
261 RT9467_IINLMTSEL_CHG_TYP,
262 RT9467_IINLMTSEL_AICR,
263 RT9467_IINLMTSEL_LOWER_LEVEL, /* lower of above three */
264 };
265
266 struct rt9467_chg_data {
267 struct device *dev;
268 struct regmap *regmap;
269 struct regmap_field *rm_field[F_MAX_FIELDS];
270 struct regmap_irq_chip_data *irq_chip_data;
271 struct power_supply *psy;
272 struct mutex adc_lock;
273 struct mutex attach_lock;
274 struct mutex ichg_ieoc_lock;
275 struct regulator_dev *rdev;
276 struct completion aicl_done;
277 enum power_supply_usb_type psy_usb_type;
278 unsigned int old_stat;
279 unsigned int vid;
280 int ichg_ua;
281 int ieoc_ua;
282 };
283
rt9467_otg_of_parse_cb(struct device_node * of,const struct regulator_desc * desc,struct regulator_config * cfg)284 static int rt9467_otg_of_parse_cb(struct device_node *of,
285 const struct regulator_desc *desc,
286 struct regulator_config *cfg)
287 {
288 struct rt9467_chg_data *data = cfg->driver_data;
289
290 cfg->ena_gpiod = fwnode_gpiod_get_index(of_fwnode_handle(of),
291 "enable", 0, GPIOD_OUT_LOW |
292 GPIOD_FLAGS_BIT_NONEXCLUSIVE,
293 desc->name);
294 if (IS_ERR(cfg->ena_gpiod)) {
295 cfg->ena_gpiod = NULL;
296 return 0;
297 }
298
299 return regmap_field_write(data->rm_field[F_OTG_PIN_EN], 1);
300 }
301
302 static const struct regulator_ops rt9467_otg_regulator_ops = {
303 .enable = regulator_enable_regmap,
304 .disable = regulator_disable_regmap,
305 .is_enabled = regulator_is_enabled_regmap,
306 .list_voltage = regulator_list_voltage_linear,
307 .set_voltage_sel = regulator_set_voltage_sel_regmap,
308 .get_voltage_sel = regulator_get_voltage_sel_regmap,
309 .set_current_limit = regulator_set_current_limit_regmap,
310 .get_current_limit = regulator_get_current_limit_regmap,
311 };
312
313 static const u32 rt9467_otg_microamp[] = {
314 500000, 700000, 1100000, 1300000, 1800000, 2100000, 2400000, 3000000
315 };
316
317 static const struct regulator_desc rt9467_otg_desc = {
318 .name = "rt9476-usb-otg-vbus",
319 .of_match = "usb-otg-vbus-regulator",
320 .of_parse_cb = rt9467_otg_of_parse_cb,
321 .type = REGULATOR_VOLTAGE,
322 .owner = THIS_MODULE,
323 .min_uV = RT9467_OTG_MIN_uV,
324 .uV_step = RT9467_OTG_STEP_uV,
325 .n_voltages = RT9467_NUM_VOTG,
326 .curr_table = rt9467_otg_microamp,
327 .n_current_limits = ARRAY_SIZE(rt9467_otg_microamp),
328 .csel_reg = RT9467_REG_CHG_CTRL10,
329 .csel_mask = RT9467_MASK_OTG_CSEL,
330 .vsel_reg = RT9467_REG_CHG_CTRL5,
331 .vsel_mask = RT9467_MASK_OTG_VSEL,
332 .enable_reg = RT9467_REG_CHG_CTRL1,
333 .enable_mask = RT9467_MASK_OTG_EN,
334 .ops = &rt9467_otg_regulator_ops,
335 };
336
rt9467_register_otg_regulator(struct rt9467_chg_data * data)337 static int rt9467_register_otg_regulator(struct rt9467_chg_data *data)
338 {
339 struct regulator_config cfg = {
340 .dev = data->dev,
341 .regmap = data->regmap,
342 .driver_data = data,
343 };
344
345 data->rdev = devm_regulator_register(data->dev, &rt9467_otg_desc, &cfg);
346 return PTR_ERR_OR_ZERO(data->rdev);
347 }
348
rt9467_get_value_from_ranges(struct rt9467_chg_data * data,enum rt9467_fields field,enum rt9467_ranges rsel,int * value)349 static int rt9467_get_value_from_ranges(struct rt9467_chg_data *data,
350 enum rt9467_fields field,
351 enum rt9467_ranges rsel,
352 int *value)
353 {
354 const struct linear_range *range = rt9467_ranges + rsel;
355 unsigned int sel;
356 int ret;
357
358 ret = regmap_field_read(data->rm_field[field], &sel);
359 if (ret)
360 return ret;
361
362 return linear_range_get_value(range, sel, value);
363 }
364
rt9467_set_value_from_ranges(struct rt9467_chg_data * data,enum rt9467_fields field,enum rt9467_ranges rsel,int value)365 static int rt9467_set_value_from_ranges(struct rt9467_chg_data *data,
366 enum rt9467_fields field,
367 enum rt9467_ranges rsel,
368 int value)
369 {
370 const struct linear_range *range = rt9467_ranges + rsel;
371 unsigned int sel;
372 bool found;
373 int ret;
374
375 if (rsel == RT9467_RANGE_VMIVR) {
376 ret = linear_range_get_selector_high(range, value, &sel, &found);
377 if (ret)
378 sel = range->max_sel;
379 } else {
380 linear_range_get_selector_within(range, value, &sel);
381 }
382
383 return regmap_field_write(data->rm_field[field], sel);
384 }
385
rt9467_get_adc_sel(enum rt9467_adc_chan chan,int * sel)386 static int rt9467_get_adc_sel(enum rt9467_adc_chan chan, int *sel)
387 {
388 switch (chan) {
389 case RT9467_ADC_VBUS_DIV5:
390 case RT9467_ADC_VBUS_DIV2:
391 case RT9467_ADC_VSYS:
392 case RT9467_ADC_VBAT:
393 *sel = chan + 1;
394 return 0;
395 case RT9467_ADC_TS_BAT:
396 *sel = chan + 2;
397 return 0;
398 case RT9467_ADC_IBUS:
399 case RT9467_ADC_IBAT:
400 *sel = chan + 3;
401 return 0;
402 case RT9467_ADC_REGN:
403 case RT9467_ADC_TEMP_JC:
404 *sel = chan + 4;
405 return 0;
406 default:
407 return -EINVAL;
408 }
409 }
410
rt9467_get_adc_raw_data(struct rt9467_chg_data * data,enum rt9467_adc_chan chan,int * val)411 static int rt9467_get_adc_raw_data(struct rt9467_chg_data *data,
412 enum rt9467_adc_chan chan, int *val)
413 {
414 unsigned int adc_stat, reg_val, adc_sel;
415 __be16 chan_raw_data;
416 int ret;
417
418 mutex_lock(&data->adc_lock);
419
420 ret = rt9467_get_adc_sel(chan, &adc_sel);
421 if (ret)
422 goto adc_unlock;
423
424 ret = regmap_write(data->regmap, RT9467_REG_CHG_ADC, 0);
425 if (ret) {
426 dev_err(data->dev, "Failed to clear ADC enable\n");
427 goto adc_unlock;
428 }
429
430 reg_val = RT9467_MASK_ADC_START | FIELD_PREP(RT9467_MASK_ADC_IN_SEL, adc_sel);
431 ret = regmap_write(data->regmap, RT9467_REG_CHG_ADC, reg_val);
432 if (ret)
433 goto adc_unlock;
434
435 /* Minimum wait time for one channel processing */
436 msleep(RT9467_ADCCONV_TIME_MS);
437
438 ret = regmap_read_poll_timeout(data->regmap, RT9467_REG_CHG_ADC,
439 adc_stat,
440 !(adc_stat & RT9467_MASK_ADC_START),
441 MILLI, RT9467_ADCCONV_TIME_MS * MILLI);
442 if (ret) {
443 dev_err(data->dev, "Failed to wait ADC conversion, chan = %d\n", chan);
444 goto adc_unlock;
445 }
446
447 ret = regmap_raw_read(data->regmap, RT9467_REG_ADC_DATA_H,
448 &chan_raw_data, sizeof(chan_raw_data));
449 if (ret)
450 goto adc_unlock;
451
452 *val = be16_to_cpu(chan_raw_data);
453
454 adc_unlock:
455 mutex_unlock(&data->adc_lock);
456 return ret;
457 }
458
rt9467_get_adc(struct rt9467_chg_data * data,enum rt9467_adc_chan chan,int * val)459 static int rt9467_get_adc(struct rt9467_chg_data *data,
460 enum rt9467_adc_chan chan, int *val)
461 {
462 unsigned int aicr_ua, ichg_ua;
463 int ret;
464
465 ret = rt9467_get_adc_raw_data(data, chan, val);
466 if (ret)
467 return ret;
468
469 switch (chan) {
470 case RT9467_ADC_VBUS_DIV5:
471 *val *= 25000;
472 return 0;
473 case RT9467_ADC_VBUS_DIV2:
474 *val *= 10000;
475 return 0;
476 case RT9467_ADC_VBAT:
477 case RT9467_ADC_VSYS:
478 case RT9467_ADC_REGN:
479 *val *= 5000;
480 return 0;
481 case RT9467_ADC_TS_BAT:
482 *val /= 400;
483 return 0;
484 case RT9467_ADC_IBUS:
485 /* UUG MOS turn-on ratio will affect the IBUS adc scale */
486 ret = rt9467_get_value_from_ranges(data, F_IAICR,
487 RT9467_RANGE_IAICR, &aicr_ua);
488 if (ret)
489 return ret;
490
491 *val *= aicr_ua < 400000 ? 29480 : 50000;
492 return 0;
493 case RT9467_ADC_IBAT:
494 /* PP MOS turn-on ratio will affect the ICHG adc scale */
495 ret = rt9467_get_value_from_ranges(data, F_ICHG,
496 RT9467_RANGE_ICHG, &ichg_ua);
497 if (ret)
498 return ret;
499
500 *val *= ichg_ua <= 400000 ? 28500 :
501 ichg_ua <= 800000 ? 31500 : 500000;
502 return 0;
503 case RT9467_ADC_TEMP_JC:
504 *val = ((*val * 2) - 40) * 10;
505 return 0;
506 default:
507 return -EINVAL;
508 }
509 }
510
rt9467_psy_get_status(struct rt9467_chg_data * data,int * state)511 static int rt9467_psy_get_status(struct rt9467_chg_data *data, int *state)
512 {
513 unsigned int status;
514 int ret;
515
516 ret = regmap_field_read(data->rm_field[F_CHG_STAT], &status);
517 if (ret)
518 return ret;
519
520 switch (status) {
521 case RT9467_STAT_READY:
522 *state = POWER_SUPPLY_STATUS_NOT_CHARGING;
523 return 0;
524 case RT9467_STAT_PROGRESS:
525 *state = POWER_SUPPLY_STATUS_CHARGING;
526 return 0;
527 case RT9467_STAT_CHARGE_DONE:
528 *state = POWER_SUPPLY_STATUS_FULL;
529 return 0;
530 default:
531 *state = POWER_SUPPLY_STATUS_UNKNOWN;
532 return 0;
533 }
534 }
535
rt9467_psy_set_ichg(struct rt9467_chg_data * data,int microamp)536 static int rt9467_psy_set_ichg(struct rt9467_chg_data *data, int microamp)
537 {
538 int ret;
539
540 mutex_lock(&data->ichg_ieoc_lock);
541
542 if (microamp < 500000) {
543 dev_err(data->dev, "Minimum value must be 500mA\n");
544 microamp = 500000;
545 }
546
547 ret = rt9467_set_value_from_ranges(data, F_ICHG, RT9467_RANGE_ICHG, microamp);
548 if (ret)
549 goto out;
550
551 ret = rt9467_get_value_from_ranges(data, F_ICHG, RT9467_RANGE_ICHG,
552 &data->ichg_ua);
553 if (ret)
554 goto out;
555
556 out:
557 mutex_unlock(&data->ichg_ieoc_lock);
558 return ret;
559 }
560
rt9467_run_aicl(struct rt9467_chg_data * data)561 static int rt9467_run_aicl(struct rt9467_chg_data *data)
562 {
563 unsigned int statc, aicl_vth;
564 int mivr_vth, aicr_get;
565 int ret = 0;
566
567
568 ret = regmap_read(data->regmap, RT9467_REG_CHG_STATC, &statc);
569 if (ret) {
570 dev_err(data->dev, "Failed to read status\n");
571 return ret;
572 }
573
574 if (!(statc & RT9467_MASK_PWR_RDY) || !(statc & RT9467_MASK_MIVR_STAT)) {
575 dev_info(data->dev, "Condition not matched %d\n", statc);
576 return 0;
577 }
578
579 ret = rt9467_get_value_from_ranges(data, F_VMIVR, RT9467_RANGE_VMIVR,
580 &mivr_vth);
581 if (ret) {
582 dev_err(data->dev, "Failed to get mivr\n");
583 return ret;
584 }
585
586 /* AICL_VTH = MIVR_VTH + 200mV */
587 aicl_vth = mivr_vth + RT9467_AICLVTH_GAP_uV;
588 ret = rt9467_set_value_from_ranges(data, F_AICL_VTH,
589 RT9467_RANGE_AICL_VTH, aicl_vth);
590 if (ret) {
591 dev_err(data->dev, "Failed to set AICL VTH\n");
592 return ret;
593 }
594
595 /* Trigger AICL function */
596 ret = regmap_field_write(data->rm_field[F_AICL_MEAS], 1);
597 if (ret) {
598 dev_err(data->dev, "Failed to set aicl measurement\n");
599 return ret;
600 }
601
602 reinit_completion(&data->aicl_done);
603 ret = wait_for_completion_timeout(&data->aicl_done, msecs_to_jiffies(3500));
604 if (ret == 0)
605 return -ETIMEDOUT;
606
607 ret = rt9467_get_value_from_ranges(data, F_IAICR, RT9467_RANGE_IAICR, &aicr_get);
608 if (ret) {
609 dev_err(data->dev, "Failed to get aicr\n");
610 return ret;
611 }
612
613 dev_info(data->dev, "aicr get = %d uA\n", aicr_get);
614 return 0;
615 }
616
rt9467_psy_set_ieoc(struct rt9467_chg_data * data,int microamp)617 static int rt9467_psy_set_ieoc(struct rt9467_chg_data *data, int microamp)
618 {
619 int ret;
620
621 mutex_lock(&data->ichg_ieoc_lock);
622
623 ret = rt9467_set_value_from_ranges(data, F_IEOC, RT9467_RANGE_IEOC, microamp);
624 if (ret)
625 goto out;
626
627 ret = rt9467_get_value_from_ranges(data, F_IEOC, RT9467_RANGE_IEOC, &data->ieoc_ua);
628 if (ret)
629 goto out;
630
631 out:
632 mutex_unlock(&data->ichg_ieoc_lock);
633 return ret;
634 }
635
636 static const enum power_supply_property rt9467_chg_properties[] = {
637 POWER_SUPPLY_PROP_STATUS,
638 POWER_SUPPLY_PROP_ONLINE,
639 POWER_SUPPLY_PROP_VOLTAGE_NOW,
640 POWER_SUPPLY_PROP_CURRENT_MAX,
641 POWER_SUPPLY_PROP_CURRENT_NOW,
642 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
643 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
644 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
645 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
646 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
647 POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT,
648 POWER_SUPPLY_PROP_USB_TYPE,
649 POWER_SUPPLY_PROP_PRECHARGE_CURRENT,
650 POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT,
651 };
652
rt9467_psy_get_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)653 static int rt9467_psy_get_property(struct power_supply *psy,
654 enum power_supply_property psp,
655 union power_supply_propval *val)
656 {
657 struct rt9467_chg_data *data = power_supply_get_drvdata(psy);
658
659 switch (psp) {
660 case POWER_SUPPLY_PROP_STATUS:
661 return rt9467_psy_get_status(data, &val->intval);
662 case POWER_SUPPLY_PROP_ONLINE:
663 return regmap_field_read(data->rm_field[F_PWR_RDY], &val->intval);
664 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
665 return rt9467_get_adc(data, RT9467_ADC_VBUS_DIV5, &val->intval);
666 case POWER_SUPPLY_PROP_CURRENT_MAX:
667 mutex_lock(&data->attach_lock);
668 if (data->psy_usb_type == POWER_SUPPLY_USB_TYPE_UNKNOWN ||
669 data->psy_usb_type == POWER_SUPPLY_USB_TYPE_SDP)
670 val->intval = 500000;
671 else
672 val->intval = 1500000;
673 mutex_unlock(&data->attach_lock);
674 return 0;
675 case POWER_SUPPLY_PROP_CURRENT_NOW:
676 return rt9467_get_adc(data, RT9467_ADC_IBUS, &val->intval);
677 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
678 mutex_lock(&data->ichg_ieoc_lock);
679 val->intval = data->ichg_ua;
680 mutex_unlock(&data->ichg_ieoc_lock);
681 return 0;
682 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
683 val->intval = RT9467_ICHG_MAX_uA;
684 return 0;
685 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
686 return rt9467_get_value_from_ranges(data, F_VOREG,
687 RT9467_RANGE_VOREG,
688 &val->intval);
689 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
690 val->intval = RT9467_CV_MAX_uV;
691 return 0;
692 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
693 return rt9467_get_value_from_ranges(data, F_IAICR,
694 RT9467_RANGE_IAICR,
695 &val->intval);
696 case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT:
697 return rt9467_get_value_from_ranges(data, F_VMIVR,
698 RT9467_RANGE_VMIVR,
699 &val->intval);
700 case POWER_SUPPLY_PROP_USB_TYPE:
701 mutex_lock(&data->attach_lock);
702 val->intval = data->psy_usb_type;
703 mutex_unlock(&data->attach_lock);
704 return 0;
705 case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
706 return rt9467_get_value_from_ranges(data, F_IPREC,
707 RT9467_RANGE_IPREC,
708 &val->intval);
709 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
710 mutex_lock(&data->ichg_ieoc_lock);
711 val->intval = data->ieoc_ua;
712 mutex_unlock(&data->ichg_ieoc_lock);
713 return 0;
714 default:
715 return -ENODATA;
716 }
717 }
718
rt9467_psy_set_property(struct power_supply * psy,enum power_supply_property psp,const union power_supply_propval * val)719 static int rt9467_psy_set_property(struct power_supply *psy,
720 enum power_supply_property psp,
721 const union power_supply_propval *val)
722 {
723 struct rt9467_chg_data *data = power_supply_get_drvdata(psy);
724
725 switch (psp) {
726 case POWER_SUPPLY_PROP_STATUS:
727 return regmap_field_write(data->rm_field[F_CHG_EN], val->intval);
728 case POWER_SUPPLY_PROP_ONLINE:
729 return regmap_field_write(data->rm_field[F_HZ], val->intval);
730 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
731 return rt9467_psy_set_ichg(data, val->intval);
732 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
733 return rt9467_set_value_from_ranges(data, F_VOREG,
734 RT9467_RANGE_VOREG, val->intval);
735 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
736 if (val->intval == -1)
737 return rt9467_run_aicl(data);
738 else
739 return rt9467_set_value_from_ranges(data, F_IAICR,
740 RT9467_RANGE_IAICR,
741 val->intval);
742 case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT:
743 return rt9467_set_value_from_ranges(data, F_VMIVR,
744 RT9467_RANGE_VMIVR, val->intval);
745 case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
746 return rt9467_set_value_from_ranges(data, F_IPREC,
747 RT9467_RANGE_IPREC, val->intval);
748 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
749 return rt9467_psy_set_ieoc(data, val->intval);
750 default:
751 return -EINVAL;
752 }
753 }
754
rt9467_chg_prop_is_writeable(struct power_supply * psy,enum power_supply_property psp)755 static int rt9467_chg_prop_is_writeable(struct power_supply *psy,
756 enum power_supply_property psp)
757 {
758 switch (psp) {
759 case POWER_SUPPLY_PROP_STATUS:
760 case POWER_SUPPLY_PROP_ONLINE:
761 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
762 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
763 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
764 case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT:
765 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
766 case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
767 return 1;
768 default:
769 return 0;
770 }
771 }
772
773 static const struct power_supply_desc rt9467_chg_psy_desc = {
774 .name = "rt9467-charger",
775 .type = POWER_SUPPLY_TYPE_USB,
776 .usb_types = BIT(POWER_SUPPLY_USB_TYPE_SDP) |
777 BIT(POWER_SUPPLY_USB_TYPE_CDP) |
778 BIT(POWER_SUPPLY_USB_TYPE_DCP) |
779 BIT(POWER_SUPPLY_USB_TYPE_UNKNOWN),
780 .properties = rt9467_chg_properties,
781 .num_properties = ARRAY_SIZE(rt9467_chg_properties),
782 .property_is_writeable = rt9467_chg_prop_is_writeable,
783 .get_property = rt9467_psy_get_property,
784 .set_property = rt9467_psy_set_property,
785 };
786
psy_device_to_chip(struct device * dev)787 static inline struct rt9467_chg_data *psy_device_to_chip(struct device *dev)
788 {
789 return power_supply_get_drvdata(to_power_supply(dev));
790 }
791
sysoff_enable_show(struct device * dev,struct device_attribute * attr,char * buf)792 static ssize_t sysoff_enable_show(struct device *dev,
793 struct device_attribute *attr, char *buf)
794 {
795 struct rt9467_chg_data *data = psy_device_to_chip(dev);
796 unsigned int sysoff_enable;
797 int ret;
798
799 ret = regmap_field_read(data->rm_field[F_SHIP_MODE], &sysoff_enable);
800 if (ret)
801 return ret;
802
803 return sysfs_emit(buf, "%d\n", sysoff_enable);
804 }
805
sysoff_enable_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)806 static ssize_t sysoff_enable_store(struct device *dev,
807 struct device_attribute *attr,
808 const char *buf, size_t count)
809 {
810 struct rt9467_chg_data *data = psy_device_to_chip(dev);
811 unsigned int tmp;
812 int ret;
813
814 ret = kstrtouint(buf, 10, &tmp);
815 if (ret)
816 return ret;
817
818 ret = regmap_field_write(data->rm_field[F_SHIP_MODE], !!tmp);
819 if (ret)
820 return ret;
821
822 return count;
823 }
824
825 static DEVICE_ATTR_RW(sysoff_enable);
826
827 static struct attribute *rt9467_sysfs_attrs[] = {
828 &dev_attr_sysoff_enable.attr,
829 NULL
830 };
831
832 ATTRIBUTE_GROUPS(rt9467_sysfs);
833
rt9467_register_psy(struct rt9467_chg_data * data)834 static int rt9467_register_psy(struct rt9467_chg_data *data)
835 {
836 struct power_supply_config cfg = {
837 .drv_data = data,
838 .fwnode = dev_fwnode(data->dev),
839 .attr_grp = rt9467_sysfs_groups,
840 };
841
842 data->psy = devm_power_supply_register(data->dev, &rt9467_chg_psy_desc,
843 &cfg);
844 return PTR_ERR_OR_ZERO(data->psy);
845 }
846
rt9467_mivr_handler(struct rt9467_chg_data * data)847 static int rt9467_mivr_handler(struct rt9467_chg_data *data)
848 {
849 unsigned int mivr_act;
850 int ret, ibus_ma;
851
852 /*
853 * back-boost workaround
854 * If (mivr_active & ibus < 100mA), toggle cfo bit
855 */
856 ret = regmap_field_read(data->rm_field[F_CHG_MIVR], &mivr_act);
857 if (ret) {
858 dev_err(data->dev, "Failed to read MIVR stat\n");
859 return ret;
860 }
861
862 if (!mivr_act)
863 return 0;
864
865 ret = rt9467_get_adc(data, RT9467_ADC_IBUS, &ibus_ma);
866 if (ret) {
867 dev_err(data->dev, "Failed to get IBUS\n");
868 return ret;
869 }
870
871 if (ibus_ma < 100000) {
872 ret = regmap_field_write(data->rm_field[F_CFO_EN], 0);
873 ret |= regmap_field_write(data->rm_field[F_CFO_EN], 1);
874 if (ret)
875 dev_err(data->dev, "Failed to toggle cfo\n");
876 }
877
878 return ret;
879 }
880
rt9467_statc_handler(int irq,void * priv)881 static irqreturn_t rt9467_statc_handler(int irq, void *priv)
882 {
883 struct rt9467_chg_data *data = priv;
884 unsigned int new_stat, evts = 0;
885 int ret;
886
887 ret = regmap_read(data->regmap, RT9467_REG_CHG_STATC, &new_stat);
888 if (ret) {
889 dev_err(data->dev, "Failed to read chg_statc\n");
890 return IRQ_NONE;
891 }
892
893 evts = data->old_stat ^ new_stat;
894 data->old_stat = new_stat;
895
896 if ((evts & new_stat) & RT9467_MASK_MIVR_STAT) {
897 ret = rt9467_mivr_handler(data);
898 if (ret)
899 dev_err(data->dev, "Failed to handle mivr stat\n");
900 }
901
902 return IRQ_HANDLED;
903 }
904
rt9467_wdt_handler(int irq,void * priv)905 static irqreturn_t rt9467_wdt_handler(int irq, void *priv)
906 {
907 struct rt9467_chg_data *data = priv;
908 unsigned int dev_id;
909 int ret;
910
911 /* Any i2c communication can kick watchdog timer */
912 ret = regmap_read(data->regmap, RT9467_REG_DEVICE_ID, &dev_id);
913 if (ret) {
914 dev_err(data->dev, "Failed to kick wdt (%d)\n", ret);
915 return IRQ_NONE;
916 }
917
918 return IRQ_HANDLED;
919 }
920
rt9467_report_usb_state(struct rt9467_chg_data * data)921 static int rt9467_report_usb_state(struct rt9467_chg_data *data)
922 {
923 unsigned int usb_stat, power_ready;
924 bool psy_changed = true;
925 int ret;
926
927 ret = regmap_field_read(data->rm_field[F_USB_STATUS], &usb_stat);
928 ret |= regmap_field_read(data->rm_field[F_PWR_RDY], &power_ready);
929 if (ret)
930 return ret;
931
932 if (!power_ready)
933 usb_stat = RT9467_CHG_TYPE_NOVBUS;
934
935 mutex_lock(&data->attach_lock);
936
937 switch (usb_stat) {
938 case RT9467_CHG_TYPE_NOVBUS:
939 data->psy_usb_type = POWER_SUPPLY_USB_TYPE_UNKNOWN;
940 break;
941 case RT9467_CHG_TYPE_SDP:
942 data->psy_usb_type = POWER_SUPPLY_USB_TYPE_SDP;
943 break;
944 case RT9467_CHG_TYPE_SDPNSTD:
945 data->psy_usb_type = POWER_SUPPLY_USB_TYPE_DCP;
946 break;
947 case RT9467_CHG_TYPE_DCP:
948 data->psy_usb_type = POWER_SUPPLY_USB_TYPE_DCP;
949 break;
950 case RT9467_CHG_TYPE_CDP:
951 data->psy_usb_type = POWER_SUPPLY_USB_TYPE_CDP;
952 break;
953 case RT9467_CHG_TYPE_UNDER_GOING:
954 default:
955 psy_changed = false;
956 break;
957 }
958
959 mutex_unlock(&data->attach_lock);
960
961 if (psy_changed)
962 power_supply_changed(data->psy);
963
964 return 0;
965 }
966
rt9467_usb_state_handler(int irq,void * priv)967 static irqreturn_t rt9467_usb_state_handler(int irq, void *priv)
968 {
969 struct rt9467_chg_data *data = priv;
970 int ret;
971
972 ret = rt9467_report_usb_state(data);
973 if (ret) {
974 dev_err(data->dev, "Failed to report attach type (%d)\n", ret);
975 return IRQ_NONE;
976 }
977
978 return IRQ_HANDLED;
979 }
980
rt9467_aiclmeas_handler(int irq,void * priv)981 static irqreturn_t rt9467_aiclmeas_handler(int irq, void *priv)
982 {
983 struct rt9467_chg_data *data = priv;
984
985 complete(&data->aicl_done);
986 return IRQ_HANDLED;
987 }
988
989 #define RT9467_IRQ_DESC(_name, _handler_func, _hwirq) \
990 { \
991 .name = #_name, \
992 .handler = rt9467_##_handler_func##_handler, \
993 .hwirq = _hwirq, \
994 }
995
rt9467_request_interrupt(struct rt9467_chg_data * data)996 static int rt9467_request_interrupt(struct rt9467_chg_data *data)
997 {
998 struct device *dev = data->dev;
999 static const struct {
1000 const char *name;
1001 int hwirq;
1002 irq_handler_t handler;
1003 } rt9467_exclusive_irqs[] = {
1004 RT9467_IRQ_DESC(statc, statc, RT9467_IRQ_TS_STATC),
1005 RT9467_IRQ_DESC(wdt, wdt, RT9467_IRQ_WDTMR),
1006 RT9467_IRQ_DESC(attach, usb_state, RT9467_IRQ_ATTACH),
1007 RT9467_IRQ_DESC(detach, usb_state, RT9467_IRQ_DETACH),
1008 RT9467_IRQ_DESC(aiclmeas, aiclmeas, RT9467_IRQ_CHG_AICLM),
1009 }, rt9466_exclusive_irqs[] = {
1010 RT9467_IRQ_DESC(statc, statc, RT9467_IRQ_TS_STATC),
1011 RT9467_IRQ_DESC(wdt, wdt, RT9467_IRQ_WDTMR),
1012 RT9467_IRQ_DESC(aiclmeas, aiclmeas, RT9467_IRQ_CHG_AICLM),
1013 }, *chg_irqs;
1014 int num_chg_irqs, i, virq, ret;
1015
1016 if (data->vid == RT9466_VID) {
1017 chg_irqs = rt9466_exclusive_irqs;
1018 num_chg_irqs = ARRAY_SIZE(rt9466_exclusive_irqs);
1019 } else {
1020 chg_irqs = rt9467_exclusive_irqs;
1021 num_chg_irqs = ARRAY_SIZE(rt9467_exclusive_irqs);
1022 }
1023
1024 for (i = 0; i < num_chg_irqs; i++) {
1025 virq = regmap_irq_get_virq(data->irq_chip_data, chg_irqs[i].hwirq);
1026 if (virq <= 0)
1027 return dev_err_probe(dev, -EINVAL, "Failed to get (%s) irq\n",
1028 chg_irqs[i].name);
1029
1030 ret = devm_request_threaded_irq(dev, virq, NULL, chg_irqs[i].handler,
1031 IRQF_ONESHOT, chg_irqs[i].name, data);
1032 if (ret)
1033 return ret;
1034 }
1035
1036 return 0;
1037 }
1038
rt9467_do_charger_init(struct rt9467_chg_data * data)1039 static int rt9467_do_charger_init(struct rt9467_chg_data *data)
1040 {
1041 struct device *dev = data->dev;
1042 int ret;
1043
1044 ret = regmap_write(data->regmap, RT9467_REG_CHG_ADC, 0);
1045 if (ret)
1046 return dev_err_probe(dev, ret, "Failed to reset ADC\n");
1047
1048 ret = rt9467_get_value_from_ranges(data, F_ICHG, RT9467_RANGE_ICHG,
1049 &data->ichg_ua);
1050 ret |= rt9467_get_value_from_ranges(data, F_IEOC, RT9467_RANGE_IEOC,
1051 &data->ieoc_ua);
1052 if (ret)
1053 return dev_err_probe(dev, ret, "Failed to init ichg/ieoc value\n");
1054
1055 ret = regmap_update_bits(data->regmap, RT9467_REG_CHG_STATC_CTRL,
1056 RT9467_MASK_PWR_RDY | RT9467_MASK_MIVR_STAT, 0);
1057 if (ret)
1058 return dev_err_probe(dev, ret, "Failed to make statc unmask\n");
1059
1060 /* Select IINLMTSEL to use AICR */
1061 ret = regmap_field_write(data->rm_field[F_IINLMTSEL],
1062 RT9467_IINLMTSEL_AICR);
1063 if (ret)
1064 return dev_err_probe(dev, ret, "Failed to set iinlmtsel to AICR\n");
1065
1066 /* Wait for AICR Rampping */
1067 msleep(150);
1068
1069 /* Disable hardware ILIM */
1070 ret = regmap_field_write(data->rm_field[F_ILIM_EN], 0);
1071 if (ret)
1072 return dev_err_probe(dev, ret, "Failed to disable hardware ILIM\n");
1073
1074 /* Set inductor OCP to high level */
1075 ret = regmap_field_write(data->rm_field[F_OCP], 1);
1076 if (ret)
1077 return dev_err_probe(dev, ret, "Failed to set higher inductor OCP level\n");
1078
1079 /* Set charge termination default enable */
1080 ret = regmap_field_write(data->rm_field[F_TE], 1);
1081 if (ret)
1082 return dev_err_probe(dev, ret, "Failed to set TE=1\n");
1083
1084 /* Set 12hrs fast charger timer */
1085 ret = regmap_field_write(data->rm_field[F_WT_FC], 4);
1086 if (ret)
1087 return dev_err_probe(dev, ret, "Failed to set WT_FC\n");
1088
1089 /* Toggle BC12 function */
1090 ret = regmap_field_write(data->rm_field[F_USBCHGEN], 0);
1091 if (ret)
1092 return dev_err_probe(dev, ret, "Failed to disable BC12\n");
1093
1094 return regmap_field_write(data->rm_field[F_USBCHGEN], 1);
1095 }
1096
rt9467_is_accessible_reg(struct device * dev,unsigned int reg)1097 static bool rt9467_is_accessible_reg(struct device *dev, unsigned int reg)
1098 {
1099 switch (reg) {
1100 case 0x00 ... 0x1A:
1101 case 0x20 ... 0x38:
1102 case 0x40 ... 0x49:
1103 case 0x50 ... 0x57:
1104 case 0x60 ... 0x67:
1105 case 0x70 ... 0x79:
1106 case 0x82 ... 0x85:
1107 return true;
1108 default:
1109 return false;
1110 }
1111 }
1112
1113 static const struct regmap_config rt9467_regmap_config = {
1114 .reg_bits = 8,
1115 .val_bits = 8,
1116 .max_register = 0x85,
1117 .writeable_reg = rt9467_is_accessible_reg,
1118 .readable_reg = rt9467_is_accessible_reg,
1119 };
1120
rt9467_check_vendor_info(struct rt9467_chg_data * data)1121 static int rt9467_check_vendor_info(struct rt9467_chg_data *data)
1122 {
1123 unsigned int vid;
1124 int ret;
1125
1126 ret = regmap_field_read(data->rm_field[F_VENDOR], &vid);
1127 if (ret) {
1128 dev_err(data->dev, "Failed to get vid\n");
1129 return ret;
1130 }
1131
1132 if ((vid != RT9466_VID) && (vid != RT9467_VID))
1133 return dev_err_probe(data->dev, -ENODEV,
1134 "VID not correct [0x%02X]\n", vid);
1135
1136 data->vid = vid;
1137 return 0;
1138 }
1139
rt9467_reset_chip(struct rt9467_chg_data * data)1140 static int rt9467_reset_chip(struct rt9467_chg_data *data)
1141 {
1142 int ret;
1143
1144 /* Disable HZ before reset chip */
1145 ret = regmap_field_write(data->rm_field[F_HZ], 0);
1146 if (ret)
1147 return ret;
1148
1149 return regmap_field_write(data->rm_field[F_RST], 1);
1150 }
1151
rt9467_chg_complete_aicl_done(void * data)1152 static void rt9467_chg_complete_aicl_done(void *data)
1153 {
1154 struct completion *aicl_done = data;
1155
1156 complete(aicl_done);
1157 }
1158
rt9467_charger_probe(struct i2c_client * i2c)1159 static int rt9467_charger_probe(struct i2c_client *i2c)
1160 {
1161 struct device *dev = &i2c->dev;
1162 struct rt9467_chg_data *data;
1163 struct gpio_desc *ceb_gpio;
1164 int ret;
1165
1166 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
1167 if (!data)
1168 return -ENOMEM;
1169
1170 data->dev = &i2c->dev;
1171 i2c_set_clientdata(i2c, data);
1172
1173 /* Default pull charge enable gpio to make 'CHG_EN' by SW control only */
1174 ceb_gpio = devm_gpiod_get_optional(dev, "charge-enable", GPIOD_OUT_HIGH);
1175 if (IS_ERR(ceb_gpio))
1176 return dev_err_probe(dev, PTR_ERR(ceb_gpio),
1177 "Failed to config charge enable gpio\n");
1178
1179 data->regmap = devm_regmap_init_i2c(i2c, &rt9467_regmap_config);
1180 if (IS_ERR(data->regmap))
1181 return dev_err_probe(dev, PTR_ERR(data->regmap),
1182 "Failed to init regmap\n");
1183
1184 ret = devm_regmap_field_bulk_alloc(dev, data->regmap,
1185 data->rm_field, rt9467_chg_fields,
1186 ARRAY_SIZE(rt9467_chg_fields));
1187 if (ret)
1188 return dev_err_probe(dev, ret, "Failed to alloc regmap fields\n");
1189
1190 ret = rt9467_check_vendor_info(data);
1191 if (ret)
1192 return dev_err_probe(dev, ret, "Failed to check vendor info");
1193
1194 ret = rt9467_reset_chip(data);
1195 if (ret)
1196 return dev_err_probe(dev, ret, "Failed to reset chip\n");
1197
1198 ret = devm_regmap_add_irq_chip(dev, data->regmap, i2c->irq,
1199 IRQF_TRIGGER_LOW | IRQF_ONESHOT, 0,
1200 &rt9467_irq_chip, &data->irq_chip_data);
1201 if (ret)
1202 return dev_err_probe(dev, ret, "Failed to add irq chip\n");
1203
1204 ret = devm_mutex_init(dev, &data->adc_lock);
1205 if (ret)
1206 return ret;
1207
1208 ret = devm_mutex_init(dev, &data->attach_lock);
1209 if (ret)
1210 return ret;
1211
1212 ret = devm_mutex_init(dev, &data->ichg_ieoc_lock);
1213 if (ret)
1214 return ret;
1215
1216 init_completion(&data->aicl_done);
1217 ret = devm_add_action_or_reset(dev, rt9467_chg_complete_aicl_done,
1218 &data->aicl_done);
1219 if (ret)
1220 return ret;
1221
1222 ret = rt9467_do_charger_init(data);
1223 if (ret)
1224 return ret;
1225
1226 ret = rt9467_register_otg_regulator(data);
1227 if (ret)
1228 return ret;
1229
1230 ret = rt9467_register_psy(data);
1231 if (ret)
1232 return ret;
1233
1234 return rt9467_request_interrupt(data);
1235 }
1236
1237 static const struct of_device_id rt9467_charger_of_match_table[] = {
1238 { .compatible = "richtek,rt9467", },
1239 {}
1240 };
1241 MODULE_DEVICE_TABLE(of, rt9467_charger_of_match_table);
1242
1243 static struct i2c_driver rt9467_charger_driver = {
1244 .driver = {
1245 .name = "rt9467-charger",
1246 .of_match_table = rt9467_charger_of_match_table,
1247 },
1248 .probe = rt9467_charger_probe,
1249 };
1250 module_i2c_driver(rt9467_charger_driver);
1251
1252 MODULE_DESCRIPTION("Richtek RT9467 Charger Driver");
1253 MODULE_AUTHOR("ChiYuan Huang <cy_huang@richtek.com>");
1254 MODULE_AUTHOR("ChiaEn Wu <chiaen_wu@richtek.com>");
1255 MODULE_LICENSE("GPL");
1256