1 // SPDX-License-Identifier: GPL-2.0-only
2 //
3 // Copyright (C) 2025 Richtek Technology Corp.
4 //
5 // Authors: ChiYuan Huang <cy_huang@richtek.com>
6
7 #include <linux/atomic.h>
8 #include <linux/cleanup.h>
9 #include <linux/i2c.h>
10 #include <linux/kernel.h>
11 #include <linux/linear_range.h>
12 #include <linux/interrupt.h>
13 #include <linux/mod_devicetable.h>
14 #include <linux/module.h>
15 #include <linux/mutex.h>
16 #include <linux/power_supply.h>
17 #include <linux/property.h>
18 #include <linux/regmap.h>
19 #include <linux/sysfs.h>
20 #include <linux/util_macros.h>
21
22 #define RT9756_REG_INTFLAG1 0x0B
23 #define RT9756_REG_INTFLAG2 0x0D
24 #define RT9756_REG_INTFLAG3 0x0F
25 #define RT9756_REG_ADCCTL 0x11
26 #define RT9756_REG_VBUSADC 0x12
27 #define RT9756_REG_BC12FLAG 0x45
28 #define RT9756_REG_INTFLAG4 0x49
29
30 /* Flag1 */
31 #define RT9756_EVT_BUSOVP BIT(3)
32 #define RT9756_EVT_BUSOCP BIT(2)
33 #define RT9756_EVT_BUSUCP BIT(0)
34 /* Flag2 */
35 #define RT9756_EVT_BATOVP BIT(7)
36 #define RT9756_EVT_BATOCP BIT(6)
37 #define RT9756_EVT_TDIEOTP BIT(3)
38 #define RT9756_EVT_VBUSLOW_ERR BIT(2)
39 #define RT9756_EVT_VAC_INSERT BIT(0)
40 /* Flag3 */
41 #define RT9756_EVT_WDT BIT(5)
42 #define RT9756_EVT_VAC_UVLO BIT(4)
43 /* ADCCTL */
44 #define RT9756_ADCEN_MASK BIT(7)
45 #define RT9756_ADCONCE_MASK BIT(6)
46 /* Bc12_flag */
47 #define RT9756_EVT_BC12_DONE BIT(3)
48 /* Flag4 */
49 #define RT9756_EVT_OUTOVP BIT(0)
50
51 #define RICHTEK_DEVID 7
52 #define RT9756_REVID 0
53 #define RT9756A_REVID 1
54 #define RT9757_REVID 2
55 #define RT9757A_REVID 3
56 #define RT9756_ADC_CONVTIME 1200
57 #define RT9756_ADC_MAXWAIT 16000
58
59 enum rt9756_model {
60 MODEL_RT9756 = 0,
61 MODEL_RT9757,
62 MODEL_RT9770,
63 MODEL_MAX
64 };
65
66 enum rt9756_adc_chan {
67 ADC_VBUS = 0,
68 ADC_IBUS,
69 ADC_VBAT,
70 ADC_IBAT,
71 ADC_TDIE,
72 ADC_MAX_CHANNEL
73 };
74
75 enum rt9756_usb_type {
76 USB_NO_VBUS = 0,
77 USB_SDP = 2,
78 USB_NSTD,
79 USB_DCP,
80 USB_CDP,
81 MAX_USB_TYPE
82 };
83
84 enum rt9756_fields {
85 F_VBATOVP = 0,
86 F_VBATOVP_EN,
87 F_IBATOCP,
88 F_IBATOCP_EN,
89 F_VBUSOVP,
90 F_VBUSOVP_EN,
91 F_IBUSOCP,
92 F_IBUSOCP_EN,
93 F_SWITCHING,
94 F_REG_RST,
95 F_CHG_EN,
96 F_OP_MODE,
97 F_WDT_DIS,
98 F_WDT_TMR,
99 F_DEV_ID,
100 F_BC12_EN,
101 F_USB_STATE,
102 F_VBUS_STATE,
103 F_IBAT_RSEN,
104 F_REVISION,
105 F_MAX_FIELD
106 };
107
108 enum rt9756_ranges {
109 R_VBATOVP = 0,
110 R_IBATOCP,
111 R_VBUSOVP,
112 R_IBUSOCP,
113 R_MAX_RANGE
114 };
115
116 static const struct reg_field rt9756_chg_fields[F_MAX_FIELD] = {
117 [F_VBATOVP] = REG_FIELD(0x08, 0, 4),
118 [F_VBATOVP_EN] = REG_FIELD(0x08, 7, 7),
119 [F_IBATOCP] = REG_FIELD(0x09, 0, 5),
120 [F_IBATOCP_EN] = REG_FIELD(0x09, 7, 7),
121 [F_VBUSOVP] = REG_FIELD(0x06, 0, 5),
122 [F_VBUSOVP_EN] = REG_FIELD(0x06, 7, 7),
123 [F_IBUSOCP] = REG_FIELD(0x07, 0, 4),
124 [F_IBUSOCP_EN] = REG_FIELD(0x07, 5, 5),
125 [F_SWITCHING] = REG_FIELD(0x5c, 7, 7),
126 [F_REG_RST] = REG_FIELD(0x00, 7, 7),
127 [F_CHG_EN] = REG_FIELD(0x00, 6, 6),
128 [F_OP_MODE] = REG_FIELD(0x00, 5, 5),
129 [F_WDT_DIS] = REG_FIELD(0x00, 3, 3),
130 [F_WDT_TMR] = REG_FIELD(0x00, 0, 2),
131 [F_DEV_ID] = REG_FIELD(0x03, 0, 3),
132 [F_BC12_EN] = REG_FIELD(0x44, 7, 7),
133 [F_USB_STATE] = REG_FIELD(0x46, 5, 7),
134 [F_VBUS_STATE] = REG_FIELD(0x4c, 0, 0),
135 [F_IBAT_RSEN] = REG_FIELD(0x5e, 0, 1),
136 [F_REVISION] = REG_FIELD(0x62, 0, 1),
137 };
138
139 static const struct reg_field rt9770_chg_fields[F_MAX_FIELD] = {
140 [F_VBATOVP] = REG_FIELD(0x08, 0, 4),
141 [F_VBATOVP_EN] = REG_FIELD(0x08, 7, 7),
142 [F_IBATOCP] = REG_FIELD(0x09, 0, 5),
143 [F_IBATOCP_EN] = REG_FIELD(0x09, 7, 7),
144 [F_VBUSOVP] = REG_FIELD(0x06, 0, 5),
145 [F_VBUSOVP_EN] = REG_FIELD(0x06, 7, 7),
146 [F_IBUSOCP] = REG_FIELD(0x07, 0, 4),
147 [F_IBUSOCP_EN] = REG_FIELD(0x07, 5, 5),
148 [F_SWITCHING] = REG_FIELD(0x5c, 7, 7),
149 [F_REG_RST] = REG_FIELD(0x00, 7, 7),
150 [F_CHG_EN] = REG_FIELD(0x00, 6, 6),
151 [F_OP_MODE] = REG_FIELD(0x00, 5, 5),
152 [F_WDT_DIS] = REG_FIELD(0x00, 3, 3),
153 [F_WDT_TMR] = REG_FIELD(0x00, 0, 2),
154 [F_DEV_ID] = REG_FIELD(0x60, 0, 3),
155 [F_BC12_EN] = REG_FIELD(0x03, 7, 7),
156 [F_USB_STATE] = REG_FIELD(0x02, 5, 7),
157 [F_VBUS_STATE] = REG_FIELD(0x4c, 0, 0),
158 [F_IBAT_RSEN] = REG_FIELD(0x5e, 0, 1),
159 [F_REVISION] = REG_FIELD(0x62, 3, 7),
160 };
161
162 /* All converted to microvolt or microamp */
163 static const struct linear_range rt9756_chg_ranges[R_MAX_RANGE] = {
164 LINEAR_RANGE_IDX(R_VBATOVP, 4200000, 0, 31, 25000),
165 LINEAR_RANGE_IDX(R_IBATOCP, 2000000, 0, 63, 100000),
166 LINEAR_RANGE_IDX(R_VBUSOVP, 3000000, 0, 63, 50000),
167 LINEAR_RANGE_IDX(R_IBUSOCP, 1000000, 0, 31, 250000),
168 };
169
170 struct charger_event {
171 unsigned int flag1;
172 unsigned int flag2;
173 unsigned int flag3;
174 unsigned int flag4;
175 };
176
177 struct rt9756_data {
178 struct device *dev;
179 struct regmap *regmap;
180 struct regmap_field *rm_fields[F_MAX_FIELD];
181 struct power_supply *psy;
182 struct power_supply *bat_psy;
183 struct mutex adc_lock;
184 struct power_supply_desc psy_desc;
185 struct power_supply_desc bat_psy_desc;
186 struct charger_event chg_evt;
187 unsigned int rg_resistor;
188 unsigned int real_resistor;
189 enum rt9756_model model;
190 atomic_t usb_type;
191 };
192
193 struct rt975x_dev_data {
194 const struct regmap_config *regmap_config;
195 const struct reg_field *reg_fields;
196 const struct reg_sequence *init_regs;
197 size_t num_init_regs;
198 int (*check_device_model)(struct rt9756_data *data);
199 };
200
rt9756_get_value_field_range(struct rt9756_data * data,enum rt9756_fields en_field,enum rt9756_fields field,enum rt9756_ranges rsel,int * val)201 static int rt9756_get_value_field_range(struct rt9756_data *data, enum rt9756_fields en_field,
202 enum rt9756_fields field, enum rt9756_ranges rsel, int *val)
203 {
204 const struct linear_range *range = rt9756_chg_ranges + rsel;
205 unsigned int enable, selector, value;
206 int ret;
207
208 ret = regmap_field_read(data->rm_fields[en_field], &enable);
209 if (ret)
210 return ret;
211
212 if (!enable) {
213 *val = 0;
214 return 0;
215 }
216
217 ret = regmap_field_read(data->rm_fields[field], &selector);
218 if (ret)
219 return ret;
220
221 ret = linear_range_get_value(range, selector, &value);
222 if (ret)
223 return ret;
224
225 *val = (int)value;
226
227 return 0;
228 }
229
rt9756_set_value_field_range(struct rt9756_data * data,enum rt9756_fields en_field,enum rt9756_fields field,enum rt9756_ranges rsel,int val)230 static int rt9756_set_value_field_range(struct rt9756_data *data, enum rt9756_fields en_field,
231 enum rt9756_fields field, enum rt9756_ranges rsel, int val)
232 {
233 const struct linear_range *range = rt9756_chg_ranges + rsel;
234 unsigned int selector, value;
235 int ret;
236
237 if (!val)
238 return regmap_field_write(data->rm_fields[en_field], 0);
239
240 value = (unsigned int)val;
241 linear_range_get_selector_within(range, value, &selector);
242 ret = regmap_field_write(data->rm_fields[field], selector);
243 if (ret)
244 return ret;
245
246 return regmap_field_write(data->rm_fields[en_field], 1);
247 }
248
rt9756_get_adc(struct rt9756_data * data,enum rt9756_adc_chan chan,int * val)249 static int rt9756_get_adc(struct rt9756_data *data, enum rt9756_adc_chan chan,
250 int *val)
251 {
252 struct regmap *regmap = data->regmap;
253 unsigned int reg_addr = RT9756_REG_VBUSADC + chan * 2;
254 unsigned int mask = RT9756_ADCEN_MASK | RT9756_ADCONCE_MASK;
255 unsigned int shift = 0, adc_cntl;
256 __be16 raws;
257 int scale, offset = 0, ret;
258
259 guard(mutex)(&data->adc_lock);
260
261 ret = regmap_update_bits(regmap, RT9756_REG_ADCCTL, mask, mask);
262 if (ret)
263 return ret;
264
265 ret = regmap_read_poll_timeout(regmap, RT9756_REG_ADCCTL, adc_cntl,
266 !(adc_cntl & RT9756_ADCEN_MASK),
267 RT9756_ADC_CONVTIME, RT9756_ADC_MAXWAIT);
268 if (ret && ret != -ETIMEDOUT)
269 return ret;
270
271 ret = regmap_raw_read(regmap, reg_addr, &raws, sizeof(raws));
272 if (ret)
273 return ret;
274
275 /*
276 * TDIE LSB 1'c, others LSB 1000uV or 1000uA.
277 * Rsense ratio is needed for IBAT channel
278 */
279 if (chan == ADC_TDIE) {
280 scale = 10;
281 shift = 8;
282 offset = -40;
283 } else if (chan == ADC_IBAT)
284 scale = 1000 * data->rg_resistor / data->real_resistor;
285 else
286 scale = 1000;
287
288 *val = ((be16_to_cpu(raws) >> shift) + offset) * scale;
289
290 return regmap_update_bits(regmap, RT9756_REG_ADCCTL, mask, 0);
291 }
292
rt9756_get_switching_state(struct rt9756_data * data,int * status)293 static int rt9756_get_switching_state(struct rt9756_data *data, int *status)
294 {
295 unsigned int switching_state;
296 int ret;
297
298 ret = regmap_field_read(data->rm_fields[F_SWITCHING], &switching_state);
299 if (ret)
300 return ret;
301
302 if (switching_state)
303 *status = POWER_SUPPLY_STATUS_CHARGING;
304 else
305 *status = POWER_SUPPLY_STATUS_NOT_CHARGING;
306
307 return 0;
308 }
309
rt9756_get_charger_health(struct rt9756_data * data)310 static int rt9756_get_charger_health(struct rt9756_data *data)
311 {
312 struct charger_event *evt = &data->chg_evt;
313
314 if (evt->flag2 & RT9756_EVT_VBUSLOW_ERR)
315 return POWER_SUPPLY_HEALTH_UNDERVOLTAGE;
316
317 if (evt->flag1 & RT9756_EVT_BUSOVP || evt->flag2 & RT9756_EVT_BATOVP ||
318 evt->flag4 & RT9756_EVT_OUTOVP)
319 return POWER_SUPPLY_HEALTH_OVERVOLTAGE;
320
321 if (evt->flag1 & RT9756_EVT_BUSOCP || evt->flag2 & RT9756_EVT_BATOCP)
322 return POWER_SUPPLY_HEALTH_OVERCURRENT;
323
324 if (evt->flag1 & RT9756_EVT_BUSUCP)
325 return POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
326
327 if (evt->flag2 & RT9756_EVT_TDIEOTP)
328 return POWER_SUPPLY_HEALTH_OVERHEAT;
329
330 if (evt->flag3 & RT9756_EVT_WDT)
331 return POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE;
332
333 return POWER_SUPPLY_HEALTH_GOOD;
334 }
335
rt9756_get_charger_online(struct rt9756_data * data,int * val)336 static int rt9756_get_charger_online(struct rt9756_data *data, int *val)
337 {
338 unsigned int online;
339 int ret;
340
341 ret = regmap_field_read(data->rm_fields[F_VBUS_STATE], &online);
342 if (ret)
343 return ret;
344
345 *val = !!online;
346 return 0;
347 }
348
rt9756_get_vbus_ovp(struct rt9756_data * data,int * val)349 static int rt9756_get_vbus_ovp(struct rt9756_data *data, int *val)
350 {
351 unsigned int opmode;
352 int ovpval, ret;
353
354 /* operating mode -> 0 bypass, 1 div2 */
355 ret = regmap_field_read(data->rm_fields[F_OP_MODE], &opmode);
356 if (ret)
357 return ret;
358
359 ret = rt9756_get_value_field_range(data, F_VBUSOVP_EN, F_VBUSOVP, R_VBUSOVP, &ovpval);
360 if (ret)
361 return ret;
362
363 *val = opmode ? ovpval * 2 : ovpval;
364 return 0;
365 }
366
rt9756_set_vbus_ovp(struct rt9756_data * data,int val)367 static int rt9756_set_vbus_ovp(struct rt9756_data *data, int val)
368 {
369 unsigned int opmode;
370 int ret;
371
372 /* operating mode -> 0 bypass, 1 div2 */
373 ret = regmap_field_read(data->rm_fields[F_OP_MODE], &opmode);
374 if (ret)
375 return ret;
376
377 return rt9756_set_value_field_range(data, F_VBUSOVP_EN, F_VBUSOVP, R_VBUSOVP,
378 opmode ? val / 2 : val);
379 }
380
381 static const char * const rt9756_manufacturer = "Richtek Technology Corp.";
382 static const char * const rt9756_model[MODEL_MAX] = { "RT9756", "RT9757", "RT9770" };
383
rt9756_psy_get_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)384 static int rt9756_psy_get_property(struct power_supply *psy,
385 enum power_supply_property psp,
386 union power_supply_propval *val)
387 {
388 struct rt9756_data *data = power_supply_get_drvdata(psy);
389 int *pval = &val->intval;
390
391 switch (psp) {
392 case POWER_SUPPLY_PROP_STATUS:
393 return rt9756_get_switching_state(data, pval);
394 case POWER_SUPPLY_PROP_HEALTH:
395 *pval = rt9756_get_charger_health(data);
396 return 0;
397 case POWER_SUPPLY_PROP_ONLINE:
398 return rt9756_get_charger_online(data, pval);
399 case POWER_SUPPLY_PROP_VOLTAGE_MAX:
400 return rt9756_get_vbus_ovp(data, pval);
401 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
402 return rt9756_get_adc(data, ADC_VBUS, pval);
403 case POWER_SUPPLY_PROP_CURRENT_MAX:
404 return rt9756_get_value_field_range(data, F_IBUSOCP_EN, F_IBUSOCP, R_IBUSOCP, pval);
405 case POWER_SUPPLY_PROP_CURRENT_NOW:
406 return rt9756_get_adc(data, ADC_IBUS, pval);
407 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
408 return rt9756_get_value_field_range(data, F_VBATOVP_EN, F_VBATOVP, R_VBATOVP, pval);
409 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
410 return rt9756_get_value_field_range(data, F_IBATOCP_EN, F_IBATOCP, R_IBATOCP, pval);
411 case POWER_SUPPLY_PROP_TEMP:
412 return rt9756_get_adc(data, ADC_TDIE, pval);
413 case POWER_SUPPLY_PROP_USB_TYPE:
414 *pval = atomic_read(&data->usb_type);
415 return 0;
416 case POWER_SUPPLY_PROP_MODEL_NAME:
417 val->strval = rt9756_model[data->model];
418 return 0;
419 case POWER_SUPPLY_PROP_MANUFACTURER:
420 val->strval = rt9756_manufacturer;
421 return 0;
422 default:
423 return -ENODATA;
424 }
425 }
426
rt9756_psy_set_property(struct power_supply * psy,enum power_supply_property psp,const union power_supply_propval * val)427 static int rt9756_psy_set_property(struct power_supply *psy,
428 enum power_supply_property psp,
429 const union power_supply_propval *val)
430 {
431 struct rt9756_data *data = power_supply_get_drvdata(psy);
432 int intval = val->intval;
433
434 switch (psp) {
435 case POWER_SUPPLY_PROP_STATUS:
436 memset(&data->chg_evt, 0, sizeof(data->chg_evt));
437 return regmap_field_write(data->rm_fields[F_CHG_EN], !!intval);
438 case POWER_SUPPLY_PROP_VOLTAGE_MAX:
439 return rt9756_set_vbus_ovp(data, intval);
440 case POWER_SUPPLY_PROP_CURRENT_MAX:
441 return rt9756_set_value_field_range(data, F_IBUSOCP_EN, F_IBUSOCP, R_IBUSOCP,
442 intval);
443 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
444 return rt9756_set_value_field_range(data, F_VBATOVP_EN, F_VBATOVP, R_VBATOVP,
445 intval);
446 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
447 return rt9756_set_value_field_range(data, F_IBATOCP_EN, F_IBATOCP, R_IBATOCP,
448 intval);
449 case POWER_SUPPLY_PROP_USB_TYPE:
450 return regmap_field_write(data->rm_fields[F_BC12_EN], !!intval);
451 default:
452 return -EINVAL;
453 }
454 }
455
456 static const enum power_supply_property rt9756_psy_properties[] = {
457 POWER_SUPPLY_PROP_STATUS,
458 POWER_SUPPLY_PROP_ONLINE,
459 POWER_SUPPLY_PROP_HEALTH,
460 POWER_SUPPLY_PROP_ONLINE,
461 POWER_SUPPLY_PROP_VOLTAGE_MAX,
462 POWER_SUPPLY_PROP_VOLTAGE_NOW,
463 POWER_SUPPLY_PROP_CURRENT_MAX,
464 POWER_SUPPLY_PROP_CURRENT_NOW,
465 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
466 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
467 POWER_SUPPLY_PROP_TEMP,
468 POWER_SUPPLY_PROP_USB_TYPE,
469 POWER_SUPPLY_PROP_MODEL_NAME,
470 POWER_SUPPLY_PROP_MANUFACTURER,
471 };
472
rt9756_bat_psy_get_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)473 static int rt9756_bat_psy_get_property(struct power_supply *psy,
474 enum power_supply_property psp,
475 union power_supply_propval *val)
476 {
477 struct rt9756_data *data = power_supply_get_drvdata(psy);
478 int *pval = &val->intval;
479
480 switch (psp) {
481 case POWER_SUPPLY_PROP_TECHNOLOGY:
482 *pval = POWER_SUPPLY_TECHNOLOGY_LION;
483 return 0;
484 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
485 return rt9756_get_adc(data, ADC_VBAT, pval);
486 case POWER_SUPPLY_PROP_CURRENT_NOW:
487 return rt9756_get_adc(data, ADC_IBAT, pval);
488 default:
489 return -ENODATA;
490 }
491 }
492
493 static const enum power_supply_property rt9756_bat_psy_properties[] = {
494 POWER_SUPPLY_PROP_TECHNOLOGY,
495 POWER_SUPPLY_PROP_VOLTAGE_NOW,
496 POWER_SUPPLY_PROP_CURRENT_NOW,
497 };
498
rt9756_psy_property_is_writeable(struct power_supply * psy,enum power_supply_property psp)499 static int rt9756_psy_property_is_writeable(struct power_supply *psy,
500 enum power_supply_property psp)
501 {
502 switch (psp) {
503 case POWER_SUPPLY_PROP_STATUS:
504 case POWER_SUPPLY_PROP_ONLINE:
505 case POWER_SUPPLY_PROP_VOLTAGE_MAX:
506 case POWER_SUPPLY_PROP_CURRENT_MAX:
507 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
508 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
509 case POWER_SUPPLY_PROP_USB_TYPE:
510 return 1;
511 default:
512 return 0;
513 }
514 }
515
516 static const unsigned int rt9756_wdt_millisecond[] = {
517 500, 1000, 5000, 30000, 40000, 80000, 128000, 255000
518 };
519
watchdog_timer_show(struct device * dev,struct device_attribute * attr,char * buf)520 static ssize_t watchdog_timer_show(struct device *dev,
521 struct device_attribute *attr, char *buf)
522 {
523 struct power_supply *psy = to_power_supply(dev);
524 struct rt9756_data *data = power_supply_get_drvdata(psy);
525 unsigned int wdt_tmr_now = 0, wdt_sel, wdt_dis;
526 int ret;
527
528 ret = regmap_field_read(data->rm_fields[F_WDT_DIS], &wdt_dis);
529 if (ret)
530 return ret;
531
532 if (!wdt_dis) {
533 ret = regmap_field_read(data->rm_fields[F_WDT_TMR], &wdt_sel);
534 if (ret)
535 return ret;
536
537 wdt_tmr_now = rt9756_wdt_millisecond[wdt_sel];
538 }
539
540 return sysfs_emit(buf, "%d\n", wdt_tmr_now);
541 }
542
watchdog_timer_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)543 static ssize_t watchdog_timer_store(struct device *dev,
544 struct device_attribute *attr,
545 const char *buf, size_t count)
546 {
547 struct power_supply *psy = to_power_supply(dev);
548 struct rt9756_data *data = power_supply_get_drvdata(psy);
549 unsigned int wdt_set, wdt_sel;
550 int ret;
551
552 ret = kstrtouint(buf, 10, &wdt_set);
553 if (ret)
554 return ret;
555
556 ret = regmap_field_write(data->rm_fields[F_WDT_DIS], 1);
557 if (ret)
558 return ret;
559
560 wdt_sel = find_closest(wdt_set, rt9756_wdt_millisecond,
561 ARRAY_SIZE(rt9756_wdt_millisecond));
562
563 ret = regmap_field_write(data->rm_fields[F_WDT_TMR], wdt_sel);
564 if (ret)
565 return ret;
566
567 if (wdt_set) {
568 ret = regmap_field_write(data->rm_fields[F_WDT_DIS], 0);
569 if (ret)
570 return ret;
571 }
572
573 return count;
574 }
575
576 static const char * const rt9756_opmode_str[] = { "bypass", "div2" };
577
operation_mode_show(struct device * dev,struct device_attribute * attr,char * buf)578 static ssize_t operation_mode_show(struct device *dev,
579 struct device_attribute *attr, char *buf)
580 {
581 struct power_supply *psy = to_power_supply(dev);
582 struct rt9756_data *data = power_supply_get_drvdata(psy);
583 unsigned int opmode;
584 int ret;
585
586 ret = regmap_field_read(data->rm_fields[F_OP_MODE], &opmode);
587 if (ret)
588 return ret;
589
590 return sysfs_emit(buf, "%s\n", rt9756_opmode_str[opmode]);
591 }
592
operation_mode_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)593 static ssize_t operation_mode_store(struct device *dev,
594 struct device_attribute *attr,
595 const char *buf, size_t count)
596 {
597 struct power_supply *psy = to_power_supply(dev);
598 struct rt9756_data *data = power_supply_get_drvdata(psy);
599 int index, ret;
600
601 index = sysfs_match_string(rt9756_opmode_str, buf);
602 if (index < 0)
603 return index;
604
605 ret = regmap_field_write(data->rm_fields[F_OP_MODE], index);
606
607 return ret ?: count;
608 }
609
610 static DEVICE_ATTR_RW(watchdog_timer);
611 static DEVICE_ATTR_RW(operation_mode);
612
613 static struct attribute *rt9756_sysfs_attrs[] = {
614 &dev_attr_watchdog_timer.attr,
615 &dev_attr_operation_mode.attr,
616 NULL
617 };
618 ATTRIBUTE_GROUPS(rt9756_sysfs);
619
rt9756_register_psy(struct rt9756_data * data)620 static int rt9756_register_psy(struct rt9756_data *data)
621 {
622 struct power_supply_desc *desc = &data->psy_desc;
623 struct power_supply_desc *bat_desc = &data->bat_psy_desc;
624 struct power_supply_config cfg = {}, bat_cfg = {};
625 struct device *dev = data->dev;
626 char *psy_name, *bat_psy_name, **supplied_to;
627
628 bat_cfg.drv_data = data;
629 bat_cfg.fwnode = dev_fwnode(dev);
630
631 bat_psy_name = devm_kasprintf(dev, GFP_KERNEL, "rt9756-%s-battery", dev_name(dev));
632 if (!bat_psy_name)
633 return -ENOMEM;
634
635 bat_desc->name = bat_psy_name;
636 bat_desc->type = POWER_SUPPLY_TYPE_BATTERY;
637 bat_desc->properties = rt9756_bat_psy_properties;
638 bat_desc->num_properties = ARRAY_SIZE(rt9756_bat_psy_properties);
639 bat_desc->get_property = rt9756_bat_psy_get_property;
640
641 data->bat_psy = devm_power_supply_register(dev, bat_desc, &bat_cfg);
642 if (IS_ERR(data->bat_psy))
643 return dev_err_probe(dev, PTR_ERR(data->bat_psy), "Failed to register battery\n");
644
645 supplied_to = devm_kzalloc(dev, sizeof(*supplied_to), GFP_KERNEL);
646 if (!supplied_to)
647 return -ENOMEM;
648
649 /* Link charger psy to battery psy */
650 supplied_to[0] = bat_psy_name;
651
652 cfg.drv_data = data;
653 cfg.fwnode = dev_fwnode(dev);
654 cfg.attr_grp = rt9756_sysfs_groups;
655 cfg.supplied_to = supplied_to;
656 cfg.num_supplicants = 1;
657
658 psy_name = devm_kasprintf(dev, GFP_KERNEL, "rt9756-%s", dev_name(dev));
659 if (!psy_name)
660 return -ENOMEM;
661
662 desc->name = psy_name;
663 desc->type = POWER_SUPPLY_TYPE_USB;
664 desc->usb_types = BIT(POWER_SUPPLY_USB_TYPE_UNKNOWN) | BIT(POWER_SUPPLY_USB_TYPE_SDP) |
665 BIT(POWER_SUPPLY_USB_TYPE_DCP) | BIT(POWER_SUPPLY_USB_TYPE_CDP);
666 desc->properties = rt9756_psy_properties;
667 desc->num_properties = ARRAY_SIZE(rt9756_psy_properties);
668 desc->property_is_writeable = rt9756_psy_property_is_writeable;
669 desc->get_property = rt9756_psy_get_property;
670 desc->set_property = rt9756_psy_set_property;
671
672 data->psy = devm_power_supply_register(dev, desc, &cfg);
673
674 return PTR_ERR_OR_ZERO(data->psy);
675 }
676
rt9756_get_usb_type(struct rt9756_data * data)677 static int rt9756_get_usb_type(struct rt9756_data *data)
678 {
679 unsigned int type;
680 int report_type, ret;
681
682 ret = regmap_field_read(data->rm_fields[F_USB_STATE], &type);
683 if (ret)
684 return ret;
685
686 switch (type) {
687 case USB_SDP:
688 case USB_NSTD:
689 report_type = POWER_SUPPLY_USB_TYPE_SDP;
690 break;
691 case USB_DCP:
692 report_type = POWER_SUPPLY_USB_TYPE_DCP;
693 break;
694 case USB_CDP:
695 report_type = POWER_SUPPLY_USB_TYPE_CDP;
696 break;
697 case USB_NO_VBUS:
698 default:
699 report_type = POWER_SUPPLY_USB_TYPE_UNKNOWN;
700 break;
701 }
702
703 atomic_set(&data->usb_type, report_type);
704 return 0;
705 }
706
rt9756_irq_handler(int irq,void * devid)707 static irqreturn_t rt9756_irq_handler(int irq, void *devid)
708 {
709 struct rt9756_data *data = devid;
710 struct regmap *regmap = data->regmap;
711 struct charger_event *evt = &data->chg_evt;
712 unsigned int bc12_flag = 0;
713 int ret;
714
715 ret = regmap_read(regmap, RT9756_REG_INTFLAG1, &evt->flag1);
716 if (ret)
717 return IRQ_NONE;
718
719 ret = regmap_read(regmap, RT9756_REG_INTFLAG2, &evt->flag2);
720 if (ret)
721 return IRQ_NONE;
722
723 ret = regmap_read(regmap, RT9756_REG_INTFLAG3, &evt->flag3);
724 if (ret)
725 return IRQ_NONE;
726
727 if (data->model != MODEL_RT9770) {
728 ret = regmap_read(regmap, RT9756_REG_INTFLAG4, &evt->flag4);
729 if (ret)
730 return IRQ_NONE;
731
732 ret = regmap_read(regmap, RT9756_REG_BC12FLAG, &bc12_flag);
733 if (ret)
734 return IRQ_NONE;
735 }
736
737 dev_dbg(data->dev, "events: 0x%02x,%02x,%02x,%02x,%02x\n", evt->flag1, evt->flag2,
738 evt->flag3, evt->flag4, bc12_flag);
739
740 if (evt->flag2 & RT9756_EVT_VAC_INSERT) {
741 ret = regmap_field_write(data->rm_fields[F_BC12_EN], 1);
742 if (ret)
743 return IRQ_NONE;
744 }
745
746 if (evt->flag3 & RT9756_EVT_VAC_UVLO)
747 atomic_set(&data->usb_type, POWER_SUPPLY_USB_TYPE_UNKNOWN);
748
749 if (bc12_flag & RT9756_EVT_BC12_DONE) {
750 ret = rt9756_get_usb_type(data);
751 if (ret)
752 return IRQ_NONE;
753 }
754
755 power_supply_changed(data->psy);
756
757 return IRQ_HANDLED;
758 }
759
rt9756_config_batsense_resistor(struct rt9756_data * data)760 static int rt9756_config_batsense_resistor(struct rt9756_data *data)
761 {
762 unsigned int shunt_resistor_uohms = 2000, rsense_sel;
763
764 device_property_read_u32(data->dev, "shunt-resistor-micro-ohms", &shunt_resistor_uohms);
765
766 if (!shunt_resistor_uohms || shunt_resistor_uohms > 5000)
767 return -EINVAL;
768
769 data->real_resistor = shunt_resistor_uohms;
770
771 /* Always choose the larger or equal one to prevent false ocp alarm */
772 if (shunt_resistor_uohms <= 1000) {
773 rsense_sel = 0;
774 data->rg_resistor = 1000;
775 } else if (shunt_resistor_uohms <= 2000) {
776 rsense_sel = 1;
777 data->rg_resistor = 2000;
778 } else {
779 rsense_sel = 2;
780 data->rg_resistor = 5000;
781 }
782
783 return regmap_field_write(data->rm_fields[F_IBAT_RSEN], rsense_sel);
784 }
785
786 static const struct reg_sequence rt9756_init_regs[] = {
787 REG_SEQ(0x00, 0x80, 1000), /* REG_RESET */
788 REG_SEQ0(0x04, 0x13), /* VACOVP/OVPGATE 12V */
789 REG_SEQ0(0x00, 0x28), /* WDT_DIS = 1 */
790 REG_SEQ0(0x0c, 0x02), /* MASK FLAG1 */
791 REG_SEQ0(0x0e, 0x06), /* MASK FLAG2 */
792 REG_SEQ0(0x10, 0xca), /* MASK FLAG3 */
793 REG_SEQ0(0x44, 0xa0), /* BC12_EN */
794 REG_SEQ0(0x47, 0x07), /* MASK BC12FLAG */
795 REG_SEQ0(0x4a, 0xfe), /* MASK FLAG4 */
796 REG_SEQ0(0x5c, 0x40), /* MASK CON_SWITCHING */
797 REG_SEQ0(0x63, 0x01), /* MASK VDDA_UVLO */
798 };
799
800 static const struct reg_sequence rt9770_init_regs[] = {
801 REG_SEQ(0x00, 0x80, 1000), /* REG_RESET */
802 REG_SEQ0(0x04, 0x13), /* VACOVP/OVPGATE 12V */
803 REG_SEQ0(0x00, 0x28), /* WDT_DIS = 1 */
804 REG_SEQ0(0x0c, 0x02), /* MASK FLAG1 */
805 REG_SEQ0(0x0e, 0x06), /* MASK FLAG2 */
806 REG_SEQ0(0x10, 0xca), /* MASK FLAG3 */
807 REG_SEQ0(0x5c, 0x40), /* MASK CON_SWITCHING */
808 REG_SEQ0(0x63, 0x01), /* MASK VDDA_UVLO */
809 };
810
811 static const struct regmap_config rt9756_regmap_config = {
812 .name = "rt9756",
813 .reg_bits = 16,
814 .val_bits = 8,
815 .max_register = 0x1ff,
816 };
817
818 static const struct regmap_config rt9770_regmap_config = {
819 .name = "rt9770",
820 .reg_bits = 8,
821 .val_bits = 8,
822 .max_register = 0xff,
823 };
824
rt9756_check_device_model(struct rt9756_data * data)825 static int rt9756_check_device_model(struct rt9756_data *data)
826 {
827 struct device *dev = data->dev;
828 unsigned int revid;
829 int ret;
830
831 ret = regmap_field_read(data->rm_fields[F_REVISION], &revid);
832 if (ret)
833 return dev_err_probe(dev, ret, "Failed to read revid\n");
834
835 if (revid == RT9757_REVID || revid == RT9757A_REVID)
836 data->model = MODEL_RT9757;
837 else if (revid == RT9756_REVID || revid == RT9756A_REVID)
838 data->model = MODEL_RT9756;
839 else
840 return dev_err_probe(dev, -EINVAL, "Unknown revision %d\n", revid);
841
842 return 0;
843 }
844
rt9770_check_device_model(struct rt9756_data * data)845 static int rt9770_check_device_model(struct rt9756_data *data)
846 {
847 data->model = MODEL_RT9770;
848 return 0;
849 }
850
rt9756_probe(struct i2c_client * i2c)851 static int rt9756_probe(struct i2c_client *i2c)
852 {
853 const struct rt975x_dev_data *dev_data;
854 struct device *dev = &i2c->dev;
855 struct rt9756_data *data;
856 struct regmap *regmap;
857 unsigned int devid;
858 int ret;
859
860 dev_data = device_get_match_data(dev);
861 if (!dev_data)
862 return dev_err_probe(dev, -EINVAL, "No device data found\n");
863
864 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
865 if (!data)
866 return -ENOMEM;
867
868 data->dev = dev;
869 mutex_init(&data->adc_lock);
870 atomic_set(&data->usb_type, POWER_SUPPLY_USB_TYPE_UNKNOWN);
871 i2c_set_clientdata(i2c, data);
872
873 regmap = devm_regmap_init_i2c(i2c, dev_data->regmap_config);
874 if (IS_ERR(regmap))
875 return dev_err_probe(dev, PTR_ERR(regmap), "Failed to init regmap\n");
876
877 data->regmap = regmap;
878
879 ret = devm_regmap_field_bulk_alloc(dev, regmap, data->rm_fields, dev_data->reg_fields,
880 F_MAX_FIELD);
881 if (ret)
882 return dev_err_probe(dev, ret, "Failed to alloc regmap fields\n");
883
884 /* Richtek Device ID check */
885 ret = regmap_field_read(data->rm_fields[F_DEV_ID], &devid);
886 if (ret)
887 return dev_err_probe(dev, ret, "Failed to read devid\n");
888
889 if (devid != RICHTEK_DEVID)
890 return dev_err_probe(dev, -ENODEV, "Incorrect VID 0x%02x\n", devid);
891
892 /* Get specific model */
893 ret = dev_data->check_device_model(data);
894 if (ret)
895 return ret;
896
897 ret = regmap_register_patch(regmap, dev_data->init_regs, dev_data->num_init_regs);
898 if (ret)
899 return dev_err_probe(dev, ret, "Failed to init registers\n");
900
901 ret = rt9756_config_batsense_resistor(data);
902 if (ret)
903 return dev_err_probe(dev, ret, "Failed to config batsense resistor\n");
904
905 ret = rt9756_register_psy(data);
906 if (ret)
907 return dev_err_probe(dev, ret, "Failed to init power supply\n");
908
909 return devm_request_threaded_irq(dev, i2c->irq, NULL, rt9756_irq_handler, IRQF_ONESHOT,
910 dev_name(dev), data);
911 }
912
rt9756_shutdown(struct i2c_client * i2c)913 static void rt9756_shutdown(struct i2c_client *i2c)
914 {
915 struct rt9756_data *data = i2c_get_clientdata(i2c);
916
917 regmap_field_write(data->rm_fields[F_REG_RST], 1);
918 }
919
920 static const struct rt975x_dev_data rt9756_dev_data = {
921 .regmap_config = &rt9756_regmap_config,
922 .reg_fields = rt9756_chg_fields,
923 .init_regs = rt9756_init_regs,
924 .num_init_regs = ARRAY_SIZE(rt9756_init_regs),
925 .check_device_model = rt9756_check_device_model,
926 };
927
928 static const struct rt975x_dev_data rt9770_dev_data = {
929 .regmap_config = &rt9770_regmap_config,
930 .reg_fields = rt9770_chg_fields,
931 .init_regs = rt9770_init_regs,
932 .num_init_regs = ARRAY_SIZE(rt9770_init_regs),
933 .check_device_model = rt9770_check_device_model,
934 };
935
936 static const struct of_device_id rt9756_device_match_table[] = {
937 { .compatible = "richtek,rt9756", .data = &rt9756_dev_data },
938 { .compatible = "richtek,rt9770", .data = &rt9770_dev_data },
939 {}
940 };
941 MODULE_DEVICE_TABLE(of, rt9756_device_match_table);
942
943 static struct i2c_driver rt9756_charger_driver = {
944 .driver = {
945 .name = "rt9756",
946 .of_match_table = rt9756_device_match_table,
947 },
948 .probe = rt9756_probe,
949 .shutdown = rt9756_shutdown,
950 };
951 module_i2c_driver(rt9756_charger_driver);
952
953 MODULE_DESCRIPTION("Richtek RT9756 charger driver");
954 MODULE_AUTHOR("ChiYuan Huang <cy_huang@richtek.com>");
955 MODULE_LICENSE("GPL");
956