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