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
59enum rt9756_model {
60 MODEL_RT9756 = 0,
61 MODEL_RT9757,
62 MODEL_RT9770,
63 MODEL_MAX
64};
65
66enum 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
75enum 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
84enum 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
108enum rt9756_ranges {
109 R_VBATOVP = 0,
110 R_IBATOCP,
111 R_VBUSOVP,
112 R_IBUSOCP,
113 R_MAX_RANGE
114};
115
116static 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
139static 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 */
163static 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
170struct charger_event {
171 unsigned int flag1;
172 unsigned int flag2;
173 unsigned int flag3;
174 unsigned int flag4;
175};
176
177struct 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
193struct 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
201static 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(field: data->rm_fields[en_field], val: &enable);
209 if (ret)
210 return ret;
211
212 if (!enable) {
213 *val = 0;
214 return 0;
215 }
216
217 ret = regmap_field_read(field: data->rm_fields[field], val: &selector);
218 if (ret)
219 return ret;
220
221 ret = linear_range_get_value(r: range, selector, val: &value);
222 if (ret)
223 return ret;
224
225 *val = (int)value;
226
227 return 0;
228}
229
230static 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(field: data->rm_fields[en_field], val: 0);
239
240 value = (unsigned int)val;
241 linear_range_get_selector_within(r: range, val: value, selector: &selector);
242 ret = regmap_field_write(field: data->rm_fields[field], val: selector);
243 if (ret)
244 return ret;
245
246 return regmap_field_write(field: data->rm_fields[en_field], val: 1);
247}
248
249static 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)(T: &data->adc_lock);
260
261 ret = regmap_update_bits(map: regmap, RT9756_REG_ADCCTL, mask, val: 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(map: regmap, reg: reg_addr, val: &raws, val_len: 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(map: regmap, RT9756_REG_ADCCTL, mask, val: 0);
291}
292
293static 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(field: data->rm_fields[F_SWITCHING], val: &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
310static 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
336static 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(field: data->rm_fields[F_VBUS_STATE], val: &online);
342 if (ret)
343 return ret;
344
345 *val = !!online;
346 return 0;
347}
348
349static 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(field: data->rm_fields[F_OP_MODE], val: &opmode);
356 if (ret)
357 return ret;
358
359 ret = rt9756_get_value_field_range(data, en_field: F_VBUSOVP_EN, field: F_VBUSOVP, rsel: R_VBUSOVP, val: &ovpval);
360 if (ret)
361 return ret;
362
363 *val = opmode ? ovpval * 2 : ovpval;
364 return 0;
365}
366
367static 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(field: data->rm_fields[F_OP_MODE], val: &opmode);
374 if (ret)
375 return ret;
376
377 return rt9756_set_value_field_range(data, en_field: F_VBUSOVP_EN, field: F_VBUSOVP, rsel: R_VBUSOVP,
378 val: opmode ? val / 2 : val);
379}
380
381static const char * const rt9756_manufacturer = "Richtek Technology Corp.";
382static const char * const rt9756_model[MODEL_MAX] = { "RT9756", "RT9757", "RT9770" };
383
384static 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, status: 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, val: pval);
399 case POWER_SUPPLY_PROP_VOLTAGE_MAX:
400 return rt9756_get_vbus_ovp(data, val: pval);
401 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
402 return rt9756_get_adc(data, chan: ADC_VBUS, val: pval);
403 case POWER_SUPPLY_PROP_CURRENT_MAX:
404 return rt9756_get_value_field_range(data, en_field: F_IBUSOCP_EN, field: F_IBUSOCP, rsel: R_IBUSOCP, val: pval);
405 case POWER_SUPPLY_PROP_CURRENT_NOW:
406 return rt9756_get_adc(data, chan: ADC_IBUS, val: pval);
407 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
408 return rt9756_get_value_field_range(data, en_field: F_VBATOVP_EN, field: F_VBATOVP, rsel: R_VBATOVP, val: pval);
409 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
410 return rt9756_get_value_field_range(data, en_field: F_IBATOCP_EN, field: F_IBATOCP, rsel: R_IBATOCP, val: pval);
411 case POWER_SUPPLY_PROP_TEMP:
412 return rt9756_get_adc(data, chan: ADC_TDIE, val: pval);
413 case POWER_SUPPLY_PROP_USB_TYPE:
414 *pval = atomic_read(v: &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
427static 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(field: data->rm_fields[F_CHG_EN], val: !!intval);
438 case POWER_SUPPLY_PROP_VOLTAGE_MAX:
439 return rt9756_set_vbus_ovp(data, val: intval);
440 case POWER_SUPPLY_PROP_CURRENT_MAX:
441 return rt9756_set_value_field_range(data, en_field: F_IBUSOCP_EN, field: F_IBUSOCP, rsel: R_IBUSOCP,
442 val: intval);
443 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
444 return rt9756_set_value_field_range(data, en_field: F_VBATOVP_EN, field: F_VBATOVP, rsel: R_VBATOVP,
445 val: intval);
446 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
447 return rt9756_set_value_field_range(data, en_field: F_IBATOCP_EN, field: F_IBATOCP, rsel: R_IBATOCP,
448 val: intval);
449 case POWER_SUPPLY_PROP_USB_TYPE:
450 return regmap_field_write(field: data->rm_fields[F_BC12_EN], val: !!intval);
451 default:
452 return -EINVAL;
453 }
454}
455
456static 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
473static 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, chan: ADC_VBAT, val: pval);
486 case POWER_SUPPLY_PROP_CURRENT_NOW:
487 return rt9756_get_adc(data, chan: ADC_IBAT, val: pval);
488 default:
489 return -ENODATA;
490 }
491}
492
493static 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
499static 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
516static const unsigned int rt9756_wdt_millisecond[] = {
517 500, 1000, 5000, 30000, 40000, 80000, 128000, 255000
518};
519
520static 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(field: data->rm_fields[F_WDT_DIS], val: &wdt_dis);
529 if (ret)
530 return ret;
531
532 if (!wdt_dis) {
533 ret = regmap_field_read(field: data->rm_fields[F_WDT_TMR], val: &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, fmt: "%d\n", wdt_tmr_now);
541}
542
543static 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(s: buf, base: 10, res: &wdt_set);
553 if (ret)
554 return ret;
555
556 ret = regmap_field_write(field: data->rm_fields[F_WDT_DIS], val: 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(field: data->rm_fields[F_WDT_TMR], val: wdt_sel);
564 if (ret)
565 return ret;
566
567 if (wdt_set) {
568 ret = regmap_field_write(field: data->rm_fields[F_WDT_DIS], val: 0);
569 if (ret)
570 return ret;
571 }
572
573 return count;
574}
575
576static const char * const rt9756_opmode_str[] = { "bypass", "div2" };
577
578static 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(field: data->rm_fields[F_OP_MODE], val: &opmode);
587 if (ret)
588 return ret;
589
590 return sysfs_emit(buf, fmt: "%s\n", rt9756_opmode_str[opmode]);
591}
592
593static 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(field: data->rm_fields[F_OP_MODE], val: index);
606
607 return ret ?: count;
608}
609
610static DEVICE_ATTR_RW(watchdog_timer);
611static DEVICE_ATTR_RW(operation_mode);
612
613static struct attribute *rt9756_sysfs_attrs[] = {
614 &dev_attr_watchdog_timer.attr,
615 &dev_attr_operation_mode.attr,
616 NULL
617};
618ATTRIBUTE_GROUPS(rt9756_sysfs);
619
620static 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, fmt: "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(parent: dev, desc: bat_desc, cfg: &bat_cfg);
642 if (IS_ERR(ptr: data->bat_psy))
643 return dev_err_probe(dev, err: PTR_ERR(ptr: data->bat_psy), fmt: "Failed to register battery\n");
644
645 supplied_to = devm_kzalloc(dev, size: 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, fmt: "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(parent: dev, desc, cfg: &cfg);
673
674 return PTR_ERR_OR_ZERO(ptr: data->psy);
675}
676
677static 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(field: data->rm_fields[F_USB_STATE], val: &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(v: &data->usb_type, i: report_type);
704 return 0;
705}
706
707static 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(map: regmap, RT9756_REG_INTFLAG1, val: &evt->flag1);
716 if (ret)
717 return IRQ_NONE;
718
719 ret = regmap_read(map: regmap, RT9756_REG_INTFLAG2, val: &evt->flag2);
720 if (ret)
721 return IRQ_NONE;
722
723 ret = regmap_read(map: regmap, RT9756_REG_INTFLAG3, val: &evt->flag3);
724 if (ret)
725 return IRQ_NONE;
726
727 if (data->model != MODEL_RT9770) {
728 ret = regmap_read(map: regmap, RT9756_REG_INTFLAG4, val: &evt->flag4);
729 if (ret)
730 return IRQ_NONE;
731
732 ret = regmap_read(map: regmap, RT9756_REG_BC12FLAG, val: &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(field: data->rm_fields[F_BC12_EN], val: 1);
742 if (ret)
743 return IRQ_NONE;
744 }
745
746 if (evt->flag3 & RT9756_EVT_VAC_UVLO)
747 atomic_set(v: &data->usb_type, i: 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(psy: data->psy);
756
757 return IRQ_HANDLED;
758}
759
760static 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(dev: data->dev, propname: "shunt-resistor-micro-ohms", val: &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(field: data->rm_fields[F_IBAT_RSEN], val: rsense_sel);
784}
785
786static 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
800static 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
811static const struct regmap_config rt9756_regmap_config = {
812 .name = "rt9756",
813 .reg_bits = 16,
814 .val_bits = 8,
815 .max_register = 0x1ff,
816};
817
818static const struct regmap_config rt9770_regmap_config = {
819 .name = "rt9770",
820 .reg_bits = 8,
821 .val_bits = 8,
822 .max_register = 0xff,
823};
824
825static 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(field: data->rm_fields[F_REVISION], val: &revid);
832 if (ret)
833 return dev_err_probe(dev, err: ret, fmt: "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, err: -EINVAL, fmt: "Unknown revision %d\n", revid);
841
842 return 0;
843}
844
845static int rt9770_check_device_model(struct rt9756_data *data)
846{
847 data->model = MODEL_RT9770;
848 return 0;
849}
850
851static 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, err: -EINVAL, fmt: "No device data found\n");
863
864 data = devm_kzalloc(dev, size: sizeof(*data), GFP_KERNEL);
865 if (!data)
866 return -ENOMEM;
867
868 data->dev = dev;
869 mutex_init(&data->adc_lock);
870 atomic_set(v: &data->usb_type, i: POWER_SUPPLY_USB_TYPE_UNKNOWN);
871 i2c_set_clientdata(client: i2c, data);
872
873 regmap = devm_regmap_init_i2c(i2c, dev_data->regmap_config);
874 if (IS_ERR(ptr: regmap))
875 return dev_err_probe(dev, err: PTR_ERR(ptr: regmap), fmt: "Failed to init regmap\n");
876
877 data->regmap = regmap;
878
879 ret = devm_regmap_field_bulk_alloc(dev, regmap, field: data->rm_fields, reg_field: dev_data->reg_fields,
880 num_fields: F_MAX_FIELD);
881 if (ret)
882 return dev_err_probe(dev, err: ret, fmt: "Failed to alloc regmap fields\n");
883
884 /* Richtek Device ID check */
885 ret = regmap_field_read(field: data->rm_fields[F_DEV_ID], val: &devid);
886 if (ret)
887 return dev_err_probe(dev, err: ret, fmt: "Failed to read devid\n");
888
889 if (devid != RICHTEK_DEVID)
890 return dev_err_probe(dev, err: -ENODEV, fmt: "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(map: regmap, regs: dev_data->init_regs, num_regs: dev_data->num_init_regs);
898 if (ret)
899 return dev_err_probe(dev, err: ret, fmt: "Failed to init registers\n");
900
901 ret = rt9756_config_batsense_resistor(data);
902 if (ret)
903 return dev_err_probe(dev, err: ret, fmt: "Failed to config batsense resistor\n");
904
905 ret = rt9756_register_psy(data);
906 if (ret)
907 return dev_err_probe(dev, err: ret, fmt: "Failed to init power supply\n");
908
909 return devm_request_threaded_irq(dev, irq: i2c->irq, NULL, thread_fn: rt9756_irq_handler, IRQF_ONESHOT,
910 devname: dev_name(dev), dev_id: data);
911}
912
913static void rt9756_shutdown(struct i2c_client *i2c)
914{
915 struct rt9756_data *data = i2c_get_clientdata(client: i2c);
916
917 regmap_field_write(field: data->rm_fields[F_REG_RST], val: 1);
918}
919
920static 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
928static 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
936static 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};
941MODULE_DEVICE_TABLE(of, rt9756_device_match_table);
942
943static 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};
951module_i2c_driver(rt9756_charger_driver);
952
953MODULE_DESCRIPTION("Richtek RT9756 charger driver");
954MODULE_AUTHOR("ChiYuan Huang <cy_huang@richtek.com>");
955MODULE_LICENSE("GPL");
956

source code of linux/drivers/power/supply/rt9756.c