rt9756.c

  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(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
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(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
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)(&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
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(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
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(data->rm_fields[F_VBUS_STATE], &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(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
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(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
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, 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
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(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
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, 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
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(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
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(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
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(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
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(data->rm_fields[F_OP_MODE], 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, "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
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(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
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(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
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(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
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(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
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, -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
913static 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
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");