1 // SPDX-License-Identifier: GPL-2.0+
2 //
3 // extcon-max14577.c - MAX14577/77836 extcon driver to support MUIC
4 //
5 // Copyright (C) 2013,2014 Samsung Electronics
6 // Chanwoo Choi <cw00.choi@samsung.com>
7 // Krzysztof Kozlowski <krzk@kernel.org>
8 
9 #include <linux/devm-helpers.h>
10 #include <linux/kernel.h>
11 #include <linux/module.h>
12 #include <linux/i2c.h>
13 #include <linux/interrupt.h>
14 #include <linux/platform_device.h>
15 #include <linux/mfd/max14577.h>
16 #include <linux/mfd/max14577-private.h>
17 #include <linux/extcon-provider.h>
18 
19 #define	DELAY_MS_DEFAULT		17000		/* unit: millisecond */
20 
21 enum max14577_muic_adc_debounce_time {
22 	ADC_DEBOUNCE_TIME_5MS = 0,
23 	ADC_DEBOUNCE_TIME_10MS,
24 	ADC_DEBOUNCE_TIME_25MS,
25 	ADC_DEBOUNCE_TIME_38_62MS,
26 };
27 
28 enum max14577_muic_status {
29 	MAX14577_MUIC_STATUS1 = 0,
30 	MAX14577_MUIC_STATUS2 = 1,
31 	MAX14577_MUIC_STATUS_END,
32 };
33 
34 /**
35  * struct max14577_muic_irq
36  * @irq: the index of irq list of MUIC device.
37  * @name: the name of irq.
38  * @virq: the virtual irq to use irq domain
39  */
40 struct max14577_muic_irq {
41 	unsigned int irq;
42 	const char *name;
43 	unsigned int virq;
44 };
45 
46 static struct max14577_muic_irq max14577_muic_irqs[] = {
47 	{ MAX14577_IRQ_INT1_ADC,	"muic-ADC" },
48 	{ MAX14577_IRQ_INT1_ADCLOW,	"muic-ADCLOW" },
49 	{ MAX14577_IRQ_INT1_ADCERR,	"muic-ADCError" },
50 	{ MAX14577_IRQ_INT2_CHGTYP,	"muic-CHGTYP" },
51 	{ MAX14577_IRQ_INT2_CHGDETRUN,	"muic-CHGDETRUN" },
52 	{ MAX14577_IRQ_INT2_DCDTMR,	"muic-DCDTMR" },
53 	{ MAX14577_IRQ_INT2_DBCHG,	"muic-DBCHG" },
54 	{ MAX14577_IRQ_INT2_VBVOLT,	"muic-VBVOLT" },
55 };
56 
57 static struct max14577_muic_irq max77836_muic_irqs[] = {
58 	{ MAX14577_IRQ_INT1_ADC,	"muic-ADC" },
59 	{ MAX14577_IRQ_INT1_ADCLOW,	"muic-ADCLOW" },
60 	{ MAX14577_IRQ_INT1_ADCERR,	"muic-ADCError" },
61 	{ MAX77836_IRQ_INT1_ADC1K,	"muic-ADC1K" },
62 	{ MAX14577_IRQ_INT2_CHGTYP,	"muic-CHGTYP" },
63 	{ MAX14577_IRQ_INT2_CHGDETRUN,	"muic-CHGDETRUN" },
64 	{ MAX14577_IRQ_INT2_DCDTMR,	"muic-DCDTMR" },
65 	{ MAX14577_IRQ_INT2_DBCHG,	"muic-DBCHG" },
66 	{ MAX14577_IRQ_INT2_VBVOLT,	"muic-VBVOLT" },
67 	{ MAX77836_IRQ_INT2_VIDRM,	"muic-VIDRM" },
68 };
69 
70 struct max14577_muic_info {
71 	struct device *dev;
72 	struct max14577 *max14577;
73 	struct extcon_dev *edev;
74 	int prev_cable_type;
75 	int prev_chg_type;
76 	u8 status[MAX14577_MUIC_STATUS_END];
77 
78 	struct max14577_muic_irq *muic_irqs;
79 	unsigned int muic_irqs_num;
80 	bool irq_adc;
81 	bool irq_chg;
82 	struct work_struct irq_work;
83 	struct mutex mutex;
84 
85 	/*
86 	 * Use delayed workqueue to detect cable state and then
87 	 * notify cable state to notifiee/platform through uevent.
88 	 * After completing the booting of platform, the extcon provider
89 	 * driver should notify cable state to upper layer.
90 	 */
91 	struct delayed_work wq_detcable;
92 
93 	/*
94 	 * Default usb/uart path whether UART/USB or AUX_UART/AUX_USB
95 	 * h/w path of COMP2/COMN1 on CONTROL1 register.
96 	 */
97 	int path_usb;
98 	int path_uart;
99 };
100 
101 enum max14577_muic_cable_group {
102 	MAX14577_CABLE_GROUP_ADC = 0,
103 	MAX14577_CABLE_GROUP_CHG,
104 };
105 
106 /* Define supported accessory type */
107 enum max14577_muic_acc_type {
108 	MAX14577_MUIC_ADC_GROUND = 0x0,
109 	MAX14577_MUIC_ADC_SEND_END_BUTTON,
110 	MAX14577_MUIC_ADC_REMOTE_S1_BUTTON,
111 	MAX14577_MUIC_ADC_REMOTE_S2_BUTTON,
112 	MAX14577_MUIC_ADC_REMOTE_S3_BUTTON,
113 	MAX14577_MUIC_ADC_REMOTE_S4_BUTTON,
114 	MAX14577_MUIC_ADC_REMOTE_S5_BUTTON,
115 	MAX14577_MUIC_ADC_REMOTE_S6_BUTTON,
116 	MAX14577_MUIC_ADC_REMOTE_S7_BUTTON,
117 	MAX14577_MUIC_ADC_REMOTE_S8_BUTTON,
118 	MAX14577_MUIC_ADC_REMOTE_S9_BUTTON,
119 	MAX14577_MUIC_ADC_REMOTE_S10_BUTTON,
120 	MAX14577_MUIC_ADC_REMOTE_S11_BUTTON,
121 	MAX14577_MUIC_ADC_REMOTE_S12_BUTTON,
122 	MAX14577_MUIC_ADC_RESERVED_ACC_1,
123 	MAX14577_MUIC_ADC_RESERVED_ACC_2,
124 	MAX14577_MUIC_ADC_RESERVED_ACC_3,
125 	MAX14577_MUIC_ADC_RESERVED_ACC_4,
126 	MAX14577_MUIC_ADC_RESERVED_ACC_5,
127 	MAX14577_MUIC_ADC_AUDIO_DEVICE_TYPE2,
128 	MAX14577_MUIC_ADC_PHONE_POWERED_DEV,
129 	MAX14577_MUIC_ADC_TTY_CONVERTER,
130 	MAX14577_MUIC_ADC_UART_CABLE,
131 	MAX14577_MUIC_ADC_CEA936A_TYPE1_CHG,
132 	MAX14577_MUIC_ADC_FACTORY_MODE_USB_OFF,
133 	MAX14577_MUIC_ADC_FACTORY_MODE_USB_ON,
134 	MAX14577_MUIC_ADC_AV_CABLE_NOLOAD,
135 	MAX14577_MUIC_ADC_CEA936A_TYPE2_CHG,
136 	MAX14577_MUIC_ADC_FACTORY_MODE_UART_OFF,
137 	MAX14577_MUIC_ADC_FACTORY_MODE_UART_ON,
138 	MAX14577_MUIC_ADC_AUDIO_DEVICE_TYPE1, /* with Remote and Simple Ctrl */
139 	MAX14577_MUIC_ADC_OPEN,
140 };
141 
142 static const unsigned int max14577_extcon_cable[] = {
143 	EXTCON_USB,
144 	EXTCON_CHG_USB_SDP,
145 	EXTCON_CHG_USB_DCP,
146 	EXTCON_CHG_USB_FAST,
147 	EXTCON_CHG_USB_SLOW,
148 	EXTCON_CHG_USB_CDP,
149 	EXTCON_JIG,
150 	EXTCON_NONE,
151 };
152 
153 /*
154  * max14577_muic_set_debounce_time - Set the debounce time of ADC
155  * @info: the instance including private data of max14577 MUIC
156  * @time: the debounce time of ADC
157  */
158 static int max14577_muic_set_debounce_time(struct max14577_muic_info *info,
159 		enum max14577_muic_adc_debounce_time time)
160 {
161 	u8 ret;
162 
163 	switch (time) {
164 	case ADC_DEBOUNCE_TIME_5MS:
165 	case ADC_DEBOUNCE_TIME_10MS:
166 	case ADC_DEBOUNCE_TIME_25MS:
167 	case ADC_DEBOUNCE_TIME_38_62MS:
168 		ret = max14577_update_reg(info->max14577->regmap,
169 					  MAX14577_MUIC_REG_CONTROL3,
170 					  CTRL3_ADCDBSET_MASK,
171 					  time << CTRL3_ADCDBSET_SHIFT);
172 		if (ret) {
173 			dev_err(info->dev, "failed to set ADC debounce time\n");
174 			return ret;
175 		}
176 		break;
177 	default:
178 		dev_err(info->dev, "invalid ADC debounce time\n");
179 		return -EINVAL;
180 	}
181 
182 	return 0;
183 };
184 
185 /*
186  * max14577_muic_set_path - Set hardware line according to attached cable
187  * @info: the instance including private data of max14577 MUIC
188  * @value: the path according to attached cable
189  * @attached: the state of cable (true:attached, false:detached)
190  *
191  * The max14577 MUIC device share outside H/W line among a varity of cables
192  * so, this function set internal path of H/W line according to the type of
193  * attached cable.
194  */
195 static int max14577_muic_set_path(struct max14577_muic_info *info,
196 		u8 val, bool attached)
197 {
198 	u8 ctrl1, ctrl2 = 0;
199 	int ret;
200 
201 	/* Set open state to path before changing hw path */
202 	ret = max14577_update_reg(info->max14577->regmap,
203 				MAX14577_MUIC_REG_CONTROL1,
204 				CLEAR_IDBEN_MICEN_MASK, CTRL1_SW_OPEN);
205 	if (ret < 0) {
206 		dev_err(info->dev, "failed to update MUIC register\n");
207 		return ret;
208 	}
209 
210 	if (attached)
211 		ctrl1 = val;
212 	else
213 		ctrl1 = CTRL1_SW_OPEN;
214 
215 	ret = max14577_update_reg(info->max14577->regmap,
216 				MAX14577_MUIC_REG_CONTROL1,
217 				CLEAR_IDBEN_MICEN_MASK, ctrl1);
218 	if (ret < 0) {
219 		dev_err(info->dev, "failed to update MUIC register\n");
220 		return ret;
221 	}
222 
223 	if (attached)
224 		ctrl2 |= CTRL2_CPEN_MASK;	/* LowPwr=0, CPEn=1 */
225 	else
226 		ctrl2 |= CTRL2_LOWPWR_MASK;	/* LowPwr=1, CPEn=0 */
227 
228 	ret = max14577_update_reg(info->max14577->regmap,
229 			MAX14577_REG_CONTROL2,
230 			CTRL2_LOWPWR_MASK | CTRL2_CPEN_MASK, ctrl2);
231 	if (ret < 0) {
232 		dev_err(info->dev, "failed to update MUIC register\n");
233 		return ret;
234 	}
235 
236 	dev_dbg(info->dev,
237 		"CONTROL1 : 0x%02x, CONTROL2 : 0x%02x, state : %s\n",
238 		ctrl1, ctrl2, attached ? "attached" : "detached");
239 
240 	return 0;
241 }
242 
243 /*
244  * max14577_muic_get_cable_type - Return cable type and check cable state
245  * @info: the instance including private data of max14577 MUIC
246  * @group: the path according to attached cable
247  * @attached: store cable state and return
248  *
249  * This function check the cable state either attached or detached,
250  * and then divide precise type of cable according to cable group.
251  *	- max14577_CABLE_GROUP_ADC
252  *	- max14577_CABLE_GROUP_CHG
253  */
254 static int max14577_muic_get_cable_type(struct max14577_muic_info *info,
255 		enum max14577_muic_cable_group group, bool *attached)
256 {
257 	int cable_type = 0;
258 	int adc;
259 	int chg_type;
260 
261 	switch (group) {
262 	case MAX14577_CABLE_GROUP_ADC:
263 		/*
264 		 * Read ADC value to check cable type and decide cable state
265 		 * according to cable type
266 		 */
267 		adc = info->status[MAX14577_MUIC_STATUS1] & STATUS1_ADC_MASK;
268 		adc >>= STATUS1_ADC_SHIFT;
269 
270 		/*
271 		 * Check current cable state/cable type and store cable type
272 		 * (info->prev_cable_type) for handling cable when cable is
273 		 * detached.
274 		 */
275 		if (adc == MAX14577_MUIC_ADC_OPEN) {
276 			*attached = false;
277 
278 			cable_type = info->prev_cable_type;
279 			info->prev_cable_type = MAX14577_MUIC_ADC_OPEN;
280 		} else {
281 			*attached = true;
282 
283 			cable_type = info->prev_cable_type = adc;
284 		}
285 		break;
286 	case MAX14577_CABLE_GROUP_CHG:
287 		/*
288 		 * Read charger type to check cable type and decide cable state
289 		 * according to type of charger cable.
290 		 */
291 		chg_type = info->status[MAX14577_MUIC_STATUS2] &
292 			STATUS2_CHGTYP_MASK;
293 		chg_type >>= STATUS2_CHGTYP_SHIFT;
294 
295 		if (chg_type == MAX14577_CHARGER_TYPE_NONE) {
296 			*attached = false;
297 
298 			cable_type = info->prev_chg_type;
299 			info->prev_chg_type = MAX14577_CHARGER_TYPE_NONE;
300 		} else {
301 			*attached = true;
302 
303 			/*
304 			 * Check current cable state/cable type and store cable
305 			 * type(info->prev_chg_type) for handling cable when
306 			 * charger cable is detached.
307 			 */
308 			cable_type = info->prev_chg_type = chg_type;
309 		}
310 
311 		break;
312 	default:
313 		dev_err(info->dev, "Unknown cable group (%d)\n", group);
314 		cable_type = -EINVAL;
315 		break;
316 	}
317 
318 	return cable_type;
319 }
320 
321 static int max14577_muic_jig_handler(struct max14577_muic_info *info,
322 		int cable_type, bool attached)
323 {
324 	int ret = 0;
325 	u8 path = CTRL1_SW_OPEN;
326 
327 	dev_dbg(info->dev,
328 		"external connector is %s (adc:0x%02x)\n",
329 		attached ? "attached" : "detached", cable_type);
330 
331 	switch (cable_type) {
332 	case MAX14577_MUIC_ADC_FACTORY_MODE_USB_OFF:	/* ADC_JIG_USB_OFF */
333 	case MAX14577_MUIC_ADC_FACTORY_MODE_USB_ON:	/* ADC_JIG_USB_ON */
334 		/* PATH:AP_USB */
335 		path = CTRL1_SW_USB;
336 		break;
337 	case MAX14577_MUIC_ADC_FACTORY_MODE_UART_OFF:	/* ADC_JIG_UART_OFF */
338 		/* PATH:AP_UART */
339 		path = CTRL1_SW_UART;
340 		break;
341 	default:
342 		dev_err(info->dev, "failed to detect %s jig cable\n",
343 			attached ? "attached" : "detached");
344 		return -EINVAL;
345 	}
346 
347 	ret = max14577_muic_set_path(info, path, attached);
348 	if (ret < 0)
349 		return ret;
350 
351 	extcon_set_state_sync(info->edev, EXTCON_JIG, attached);
352 
353 	return 0;
354 }
355 
356 static int max14577_muic_adc_handler(struct max14577_muic_info *info)
357 {
358 	int cable_type;
359 	bool attached;
360 	int ret = 0;
361 
362 	/* Check accessory state which is either detached or attached */
363 	cable_type = max14577_muic_get_cable_type(info,
364 				MAX14577_CABLE_GROUP_ADC, &attached);
365 
366 	dev_dbg(info->dev,
367 		"external connector is %s (adc:0x%02x, prev_adc:0x%x)\n",
368 		attached ? "attached" : "detached", cable_type,
369 		info->prev_cable_type);
370 
371 	switch (cable_type) {
372 	case MAX14577_MUIC_ADC_FACTORY_MODE_USB_OFF:
373 	case MAX14577_MUIC_ADC_FACTORY_MODE_USB_ON:
374 	case MAX14577_MUIC_ADC_FACTORY_MODE_UART_OFF:
375 		/* JIG */
376 		ret = max14577_muic_jig_handler(info, cable_type, attached);
377 		if (ret < 0)
378 			return ret;
379 		break;
380 	case MAX14577_MUIC_ADC_GROUND:
381 	case MAX14577_MUIC_ADC_SEND_END_BUTTON:
382 	case MAX14577_MUIC_ADC_REMOTE_S1_BUTTON:
383 	case MAX14577_MUIC_ADC_REMOTE_S2_BUTTON:
384 	case MAX14577_MUIC_ADC_REMOTE_S3_BUTTON:
385 	case MAX14577_MUIC_ADC_REMOTE_S4_BUTTON:
386 	case MAX14577_MUIC_ADC_REMOTE_S5_BUTTON:
387 	case MAX14577_MUIC_ADC_REMOTE_S6_BUTTON:
388 	case MAX14577_MUIC_ADC_REMOTE_S7_BUTTON:
389 	case MAX14577_MUIC_ADC_REMOTE_S8_BUTTON:
390 	case MAX14577_MUIC_ADC_REMOTE_S9_BUTTON:
391 	case MAX14577_MUIC_ADC_REMOTE_S10_BUTTON:
392 	case MAX14577_MUIC_ADC_REMOTE_S11_BUTTON:
393 	case MAX14577_MUIC_ADC_REMOTE_S12_BUTTON:
394 	case MAX14577_MUIC_ADC_RESERVED_ACC_1:
395 	case MAX14577_MUIC_ADC_RESERVED_ACC_2:
396 	case MAX14577_MUIC_ADC_RESERVED_ACC_3:
397 	case MAX14577_MUIC_ADC_RESERVED_ACC_4:
398 	case MAX14577_MUIC_ADC_RESERVED_ACC_5:
399 	case MAX14577_MUIC_ADC_AUDIO_DEVICE_TYPE2:
400 	case MAX14577_MUIC_ADC_PHONE_POWERED_DEV:
401 	case MAX14577_MUIC_ADC_TTY_CONVERTER:
402 	case MAX14577_MUIC_ADC_UART_CABLE:
403 	case MAX14577_MUIC_ADC_CEA936A_TYPE1_CHG:
404 	case MAX14577_MUIC_ADC_AV_CABLE_NOLOAD:
405 	case MAX14577_MUIC_ADC_CEA936A_TYPE2_CHG:
406 	case MAX14577_MUIC_ADC_FACTORY_MODE_UART_ON:
407 	case MAX14577_MUIC_ADC_AUDIO_DEVICE_TYPE1:
408 		/*
409 		 * This accessory isn't used in general case if it is specially
410 		 * needed to detect additional accessory, should implement
411 		 * proper operation when this accessory is attached/detached.
412 		 */
413 		dev_info(info->dev,
414 			"accessory is %s but it isn't used (adc:0x%x)\n",
415 			attached ? "attached" : "detached", cable_type);
416 		return -EAGAIN;
417 	default:
418 		dev_err(info->dev,
419 			"failed to detect %s accessory (adc:0x%x)\n",
420 			attached ? "attached" : "detached", cable_type);
421 		return -EINVAL;
422 	}
423 
424 	return 0;
425 }
426 
427 static int max14577_muic_chg_handler(struct max14577_muic_info *info)
428 {
429 	int chg_type;
430 	bool attached;
431 	int ret = 0;
432 
433 	chg_type = max14577_muic_get_cable_type(info,
434 				MAX14577_CABLE_GROUP_CHG, &attached);
435 
436 	dev_dbg(info->dev,
437 		"external connector is %s(chg_type:0x%x, prev_chg_type:0x%x)\n",
438 			attached ? "attached" : "detached",
439 			chg_type, info->prev_chg_type);
440 
441 	switch (chg_type) {
442 	case MAX14577_CHARGER_TYPE_USB:
443 		/* PATH:AP_USB */
444 		ret = max14577_muic_set_path(info, info->path_usb, attached);
445 		if (ret < 0)
446 			return ret;
447 
448 		extcon_set_state_sync(info->edev, EXTCON_USB, attached);
449 		extcon_set_state_sync(info->edev, EXTCON_CHG_USB_SDP,
450 					attached);
451 		break;
452 	case MAX14577_CHARGER_TYPE_DEDICATED_CHG:
453 		extcon_set_state_sync(info->edev, EXTCON_CHG_USB_DCP,
454 					attached);
455 		break;
456 	case MAX14577_CHARGER_TYPE_DOWNSTREAM_PORT:
457 		extcon_set_state_sync(info->edev, EXTCON_CHG_USB_CDP,
458 					attached);
459 		break;
460 	case MAX14577_CHARGER_TYPE_SPECIAL_500MA:
461 		extcon_set_state_sync(info->edev, EXTCON_CHG_USB_SLOW,
462 					attached);
463 		break;
464 	case MAX14577_CHARGER_TYPE_SPECIAL_1A:
465 		extcon_set_state_sync(info->edev, EXTCON_CHG_USB_FAST,
466 					attached);
467 		break;
468 	case MAX14577_CHARGER_TYPE_NONE:
469 	case MAX14577_CHARGER_TYPE_DEAD_BATTERY:
470 		break;
471 	default:
472 		dev_err(info->dev,
473 			"failed to detect %s accessory (chg_type:0x%x)\n",
474 			attached ? "attached" : "detached", chg_type);
475 		return -EINVAL;
476 	}
477 
478 	return 0;
479 }
480 
481 static void max14577_muic_irq_work(struct work_struct *work)
482 {
483 	struct max14577_muic_info *info = container_of(work,
484 			struct max14577_muic_info, irq_work);
485 	int ret = 0;
486 
487 	if (!info->edev)
488 		return;
489 
490 	mutex_lock(&info->mutex);
491 
492 	ret = max14577_bulk_read(info->max14577->regmap,
493 			MAX14577_MUIC_REG_STATUS1, info->status, 2);
494 	if (ret) {
495 		dev_err(info->dev, "failed to read MUIC register\n");
496 		mutex_unlock(&info->mutex);
497 		return;
498 	}
499 
500 	if (info->irq_adc) {
501 		ret = max14577_muic_adc_handler(info);
502 		info->irq_adc = false;
503 	}
504 	if (info->irq_chg) {
505 		ret = max14577_muic_chg_handler(info);
506 		info->irq_chg = false;
507 	}
508 
509 	if (ret < 0)
510 		dev_err(info->dev, "failed to handle MUIC interrupt\n");
511 
512 	mutex_unlock(&info->mutex);
513 }
514 
515 /*
516  * Sets irq_adc or irq_chg in max14577_muic_info and returns 1.
517  * Returns 0 if irq_type does not match registered IRQ for this device type.
518  */
519 static int max14577_parse_irq(struct max14577_muic_info *info, int irq_type)
520 {
521 	switch (irq_type) {
522 	case MAX14577_IRQ_INT1_ADC:
523 	case MAX14577_IRQ_INT1_ADCLOW:
524 	case MAX14577_IRQ_INT1_ADCERR:
525 		/*
526 		 * Handle all of accessory except for
527 		 * type of charger accessory.
528 		 */
529 		info->irq_adc = true;
530 		return 1;
531 	case MAX14577_IRQ_INT2_CHGTYP:
532 	case MAX14577_IRQ_INT2_CHGDETRUN:
533 	case MAX14577_IRQ_INT2_DCDTMR:
534 	case MAX14577_IRQ_INT2_DBCHG:
535 	case MAX14577_IRQ_INT2_VBVOLT:
536 		/* Handle charger accessory */
537 		info->irq_chg = true;
538 		return 1;
539 	default:
540 		return 0;
541 	}
542 }
543 
544 /*
545  * Sets irq_adc or irq_chg in max14577_muic_info and returns 1.
546  * Returns 0 if irq_type does not match registered IRQ for this device type.
547  */
548 static int max77836_parse_irq(struct max14577_muic_info *info, int irq_type)
549 {
550 	/* First check common max14577 interrupts */
551 	if (max14577_parse_irq(info, irq_type))
552 		return 1;
553 
554 	switch (irq_type) {
555 	case MAX77836_IRQ_INT1_ADC1K:
556 		info->irq_adc = true;
557 		return 1;
558 	case MAX77836_IRQ_INT2_VIDRM:
559 		/* Handle charger accessory */
560 		info->irq_chg = true;
561 		return 1;
562 	default:
563 		return 0;
564 	}
565 }
566 
567 static irqreturn_t max14577_muic_irq_handler(int irq, void *data)
568 {
569 	struct max14577_muic_info *info = data;
570 	int i, irq_type = -1;
571 	bool irq_parsed;
572 
573 	/*
574 	 * We may be called multiple times for different nested IRQ-s.
575 	 * Including changes in INT1_ADC and INT2_CGHTYP at once.
576 	 * However we only need to know whether it was ADC, charger
577 	 * or both interrupts so decode IRQ and turn on proper flags.
578 	 */
579 	for (i = 0; i < info->muic_irqs_num; i++)
580 		if (irq == info->muic_irqs[i].virq)
581 			irq_type = info->muic_irqs[i].irq;
582 
583 	switch (info->max14577->dev_type) {
584 	case MAXIM_DEVICE_TYPE_MAX77836:
585 		irq_parsed = max77836_parse_irq(info, irq_type);
586 		break;
587 	case MAXIM_DEVICE_TYPE_MAX14577:
588 	default:
589 		irq_parsed = max14577_parse_irq(info, irq_type);
590 		break;
591 	}
592 
593 	if (!irq_parsed) {
594 		dev_err(info->dev, "muic interrupt: irq %d occurred, skipped\n",
595 				irq_type);
596 		return IRQ_HANDLED;
597 	}
598 	schedule_work(&info->irq_work);
599 
600 	return IRQ_HANDLED;
601 }
602 
603 static int max14577_muic_detect_accessory(struct max14577_muic_info *info)
604 {
605 	int ret = 0;
606 	int adc;
607 	int chg_type;
608 	bool attached;
609 
610 	mutex_lock(&info->mutex);
611 
612 	/* Read STATUSx register to detect accessory */
613 	ret = max14577_bulk_read(info->max14577->regmap,
614 			MAX14577_MUIC_REG_STATUS1, info->status, 2);
615 	if (ret) {
616 		dev_err(info->dev, "failed to read MUIC register\n");
617 		mutex_unlock(&info->mutex);
618 		return ret;
619 	}
620 
621 	adc = max14577_muic_get_cable_type(info, MAX14577_CABLE_GROUP_ADC,
622 					&attached);
623 	if (attached && adc != MAX14577_MUIC_ADC_OPEN) {
624 		ret = max14577_muic_adc_handler(info);
625 		if (ret < 0) {
626 			dev_err(info->dev, "Cannot detect accessory\n");
627 			mutex_unlock(&info->mutex);
628 			return ret;
629 		}
630 	}
631 
632 	chg_type = max14577_muic_get_cable_type(info, MAX14577_CABLE_GROUP_CHG,
633 					&attached);
634 	if (attached && chg_type != MAX14577_CHARGER_TYPE_NONE) {
635 		ret = max14577_muic_chg_handler(info);
636 		if (ret < 0) {
637 			dev_err(info->dev, "Cannot detect charger accessory\n");
638 			mutex_unlock(&info->mutex);
639 			return ret;
640 		}
641 	}
642 
643 	mutex_unlock(&info->mutex);
644 
645 	return 0;
646 }
647 
648 static void max14577_muic_detect_cable_wq(struct work_struct *work)
649 {
650 	struct max14577_muic_info *info = container_of(to_delayed_work(work),
651 				struct max14577_muic_info, wq_detcable);
652 
653 	max14577_muic_detect_accessory(info);
654 }
655 
656 static int max14577_muic_probe(struct platform_device *pdev)
657 {
658 	struct max14577 *max14577 = dev_get_drvdata(pdev->dev.parent);
659 	struct max14577_muic_info *info;
660 	int delay_jiffies;
661 	int cable_type;
662 	bool attached;
663 	int ret;
664 	int i;
665 	u8 id;
666 
667 	info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
668 	if (!info)
669 		return -ENOMEM;
670 
671 	info->dev = &pdev->dev;
672 	info->max14577 = max14577;
673 
674 	platform_set_drvdata(pdev, info);
675 	mutex_init(&info->mutex);
676 
677 	ret = devm_work_autocancel(&pdev->dev, &info->irq_work,
678 				   max14577_muic_irq_work);
679 	if (ret)
680 		return ret;
681 
682 	switch (max14577->dev_type) {
683 	case MAXIM_DEVICE_TYPE_MAX77836:
684 		info->muic_irqs = max77836_muic_irqs;
685 		info->muic_irqs_num = ARRAY_SIZE(max77836_muic_irqs);
686 		break;
687 	case MAXIM_DEVICE_TYPE_MAX14577:
688 	default:
689 		info->muic_irqs = max14577_muic_irqs;
690 		info->muic_irqs_num = ARRAY_SIZE(max14577_muic_irqs);
691 	}
692 
693 	/* Support irq domain for max14577 MUIC device */
694 	for (i = 0; i < info->muic_irqs_num; i++) {
695 		struct max14577_muic_irq *muic_irq = &info->muic_irqs[i];
696 		int virq = 0;
697 
698 		virq = regmap_irq_get_virq(max14577->irq_data, muic_irq->irq);
699 		if (virq <= 0)
700 			return -EINVAL;
701 		muic_irq->virq = virq;
702 
703 		ret = devm_request_threaded_irq(&pdev->dev, virq, NULL,
704 				max14577_muic_irq_handler,
705 				IRQF_NO_SUSPEND,
706 				muic_irq->name, info);
707 		if (ret) {
708 			dev_err(&pdev->dev,
709 				"failed: irq request (IRQ: %d, error :%d)\n",
710 				muic_irq->irq, ret);
711 			return ret;
712 		}
713 	}
714 
715 	/* Initialize extcon device */
716 	info->edev = devm_extcon_dev_allocate(&pdev->dev,
717 					      max14577_extcon_cable);
718 	if (IS_ERR(info->edev)) {
719 		dev_err(&pdev->dev, "failed to allocate memory for extcon\n");
720 		return PTR_ERR(info->edev);
721 	}
722 
723 	ret = devm_extcon_dev_register(&pdev->dev, info->edev);
724 	if (ret) {
725 		dev_err(&pdev->dev, "failed to register extcon device\n");
726 		return ret;
727 	}
728 
729 	/* Default h/w line path */
730 	info->path_usb = CTRL1_SW_USB;
731 	info->path_uart = CTRL1_SW_UART;
732 	delay_jiffies = msecs_to_jiffies(DELAY_MS_DEFAULT);
733 
734 	/* Set initial path for UART when JIG is connected to get serial logs */
735 	ret = max14577_bulk_read(info->max14577->regmap,
736 			MAX14577_MUIC_REG_STATUS1, info->status, 2);
737 	if (ret) {
738 		dev_err(info->dev, "Cannot read STATUS registers\n");
739 		return ret;
740 	}
741 	cable_type = max14577_muic_get_cable_type(info, MAX14577_CABLE_GROUP_ADC,
742 					 &attached);
743 	if (attached && cable_type == MAX14577_MUIC_ADC_FACTORY_MODE_UART_OFF)
744 		max14577_muic_set_path(info, info->path_uart, true);
745 
746 	/* Check revision number of MUIC device*/
747 	ret = max14577_read_reg(info->max14577->regmap,
748 			MAX14577_REG_DEVICEID, &id);
749 	if (ret < 0) {
750 		dev_err(&pdev->dev, "failed to read revision number\n");
751 		return ret;
752 	}
753 	dev_info(info->dev, "device ID : 0x%x\n", id);
754 
755 	/* Set ADC debounce time */
756 	max14577_muic_set_debounce_time(info, ADC_DEBOUNCE_TIME_25MS);
757 
758 	/*
759 	 * Detect accessory after completing the initialization of platform
760 	 *
761 	 * - Use delayed workqueue to detect cable state and then
762 	 * notify cable state to notifiee/platform through uevent.
763 	 * After completing the booting of platform, the extcon provider
764 	 * driver should notify cable state to upper layer.
765 	 */
766 	INIT_DELAYED_WORK(&info->wq_detcable, max14577_muic_detect_cable_wq);
767 	queue_delayed_work(system_power_efficient_wq, &info->wq_detcable,
768 			delay_jiffies);
769 
770 	return ret;
771 }
772 
773 static const struct platform_device_id max14577_muic_id[] = {
774 	{ "max14577-muic", MAXIM_DEVICE_TYPE_MAX14577, },
775 	{ "max77836-muic", MAXIM_DEVICE_TYPE_MAX77836, },
776 	{ }
777 };
778 MODULE_DEVICE_TABLE(platform, max14577_muic_id);
779 
780 static const struct of_device_id of_max14577_muic_dt_match[] = {
781 	{ .compatible = "maxim,max14577-muic",
782 	  .data = (void *)MAXIM_DEVICE_TYPE_MAX14577, },
783 	{ .compatible = "maxim,max77836-muic",
784 	  .data = (void *)MAXIM_DEVICE_TYPE_MAX77836, },
785 	{ },
786 };
787 MODULE_DEVICE_TABLE(of, of_max14577_muic_dt_match);
788 
789 static struct platform_driver max14577_muic_driver = {
790 	.driver		= {
791 		.name	= "max14577-muic",
792 		.of_match_table = of_max14577_muic_dt_match,
793 	},
794 	.probe		= max14577_muic_probe,
795 	.id_table	= max14577_muic_id,
796 };
797 
798 module_platform_driver(max14577_muic_driver);
799 
800 MODULE_DESCRIPTION("Maxim 14577/77836 Extcon driver");
801 MODULE_AUTHOR("Chanwoo Choi <cw00.choi@samsung.com>, Krzysztof Kozlowski <krzk@kernel.org>");
802 MODULE_LICENSE("GPL");
803 MODULE_ALIAS("platform:extcon-max14577");
804