1 /*
2  * extcon-max8997.c - MAX8997 extcon driver to support MAX8997 MUIC
3  *
4  *  Copyright (C) 2012 Samsung Electronics
5  *  Donggeun Kim <dg77.kim@samsung.com>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  */
17 
18 #include <linux/kernel.h>
19 #include <linux/module.h>
20 #include <linux/i2c.h>
21 #include <linux/slab.h>
22 #include <linux/interrupt.h>
23 #include <linux/err.h>
24 #include <linux/platform_device.h>
25 #include <linux/kobject.h>
26 #include <linux/mfd/max8997.h>
27 #include <linux/mfd/max8997-private.h>
28 #include <linux/extcon.h>
29 #include <linux/irqdomain.h>
30 
31 #define	DEV_NAME			"max8997-muic"
32 #define	DELAY_MS_DEFAULT		20000		/* unit: millisecond */
33 
34 enum max8997_muic_adc_debounce_time {
35 	ADC_DEBOUNCE_TIME_0_5MS = 0,	/* 0.5ms */
36 	ADC_DEBOUNCE_TIME_10MS,		/* 10ms */
37 	ADC_DEBOUNCE_TIME_25MS,		/* 25ms */
38 	ADC_DEBOUNCE_TIME_38_62MS,	/* 38.62ms */
39 };
40 
41 struct max8997_muic_irq {
42 	unsigned int irq;
43 	const char *name;
44 	unsigned int virq;
45 };
46 
47 static struct max8997_muic_irq muic_irqs[] = {
48 	{ MAX8997_MUICIRQ_ADCError,	"muic-ADCERROR" },
49 	{ MAX8997_MUICIRQ_ADCLow,	"muic-ADCLOW" },
50 	{ MAX8997_MUICIRQ_ADC,		"muic-ADC" },
51 	{ MAX8997_MUICIRQ_VBVolt,	"muic-VBVOLT" },
52 	{ MAX8997_MUICIRQ_DBChg,	"muic-DBCHG" },
53 	{ MAX8997_MUICIRQ_DCDTmr,	"muic-DCDTMR" },
54 	{ MAX8997_MUICIRQ_ChgDetRun,	"muic-CHGDETRUN" },
55 	{ MAX8997_MUICIRQ_ChgTyp,	"muic-CHGTYP" },
56 	{ MAX8997_MUICIRQ_OVP,		"muic-OVP" },
57 };
58 
59 /* Define supported cable type */
60 enum max8997_muic_acc_type {
61 	MAX8997_MUIC_ADC_GROUND = 0x0,
62 	MAX8997_MUIC_ADC_MHL,			/* MHL*/
63 	MAX8997_MUIC_ADC_REMOTE_S1_BUTTON,
64 	MAX8997_MUIC_ADC_REMOTE_S2_BUTTON,
65 	MAX8997_MUIC_ADC_REMOTE_S3_BUTTON,
66 	MAX8997_MUIC_ADC_REMOTE_S4_BUTTON,
67 	MAX8997_MUIC_ADC_REMOTE_S5_BUTTON,
68 	MAX8997_MUIC_ADC_REMOTE_S6_BUTTON,
69 	MAX8997_MUIC_ADC_REMOTE_S7_BUTTON,
70 	MAX8997_MUIC_ADC_REMOTE_S8_BUTTON,
71 	MAX8997_MUIC_ADC_REMOTE_S9_BUTTON,
72 	MAX8997_MUIC_ADC_REMOTE_S10_BUTTON,
73 	MAX8997_MUIC_ADC_REMOTE_S11_BUTTON,
74 	MAX8997_MUIC_ADC_REMOTE_S12_BUTTON,
75 	MAX8997_MUIC_ADC_RESERVED_ACC_1,
76 	MAX8997_MUIC_ADC_RESERVED_ACC_2,
77 	MAX8997_MUIC_ADC_RESERVED_ACC_3,
78 	MAX8997_MUIC_ADC_RESERVED_ACC_4,
79 	MAX8997_MUIC_ADC_RESERVED_ACC_5,
80 	MAX8997_MUIC_ADC_CEA936_AUDIO,
81 	MAX8997_MUIC_ADC_PHONE_POWERED_DEV,
82 	MAX8997_MUIC_ADC_TTY_CONVERTER,
83 	MAX8997_MUIC_ADC_UART_CABLE,
84 	MAX8997_MUIC_ADC_CEA936A_TYPE1_CHG,
85 	MAX8997_MUIC_ADC_FACTORY_MODE_USB_OFF,	/* JIG-USB-OFF */
86 	MAX8997_MUIC_ADC_FACTORY_MODE_USB_ON,	/* JIG-USB-ON */
87 	MAX8997_MUIC_ADC_AV_CABLE_NOLOAD,	/* DESKDOCK */
88 	MAX8997_MUIC_ADC_CEA936A_TYPE2_CHG,
89 	MAX8997_MUIC_ADC_FACTORY_MODE_UART_OFF,	/* JIG-UART */
90 	MAX8997_MUIC_ADC_FACTORY_MODE_UART_ON,	/* CARDOCK */
91 	MAX8997_MUIC_ADC_AUDIO_MODE_REMOTE,
92 	MAX8997_MUIC_ADC_OPEN,			/* OPEN */
93 };
94 
95 enum max8997_muic_cable_group {
96 	MAX8997_CABLE_GROUP_ADC = 0,
97 	MAX8997_CABLE_GROUP_ADC_GND,
98 	MAX8997_CABLE_GROUP_CHG,
99 	MAX8997_CABLE_GROUP_VBVOLT,
100 };
101 
102 enum max8997_muic_usb_type {
103 	MAX8997_USB_HOST,
104 	MAX8997_USB_DEVICE,
105 };
106 
107 enum max8997_muic_charger_type {
108 	MAX8997_CHARGER_TYPE_NONE = 0,
109 	MAX8997_CHARGER_TYPE_USB,
110 	MAX8997_CHARGER_TYPE_DOWNSTREAM_PORT,
111 	MAX8997_CHARGER_TYPE_DEDICATED_CHG,
112 	MAX8997_CHARGER_TYPE_500MA,
113 	MAX8997_CHARGER_TYPE_1A,
114 	MAX8997_CHARGER_TYPE_DEAD_BATTERY = 7,
115 };
116 
117 struct max8997_muic_info {
118 	struct device *dev;
119 	struct i2c_client *muic;
120 	struct extcon_dev *edev;
121 	int prev_cable_type;
122 	int prev_chg_type;
123 	u8 status[2];
124 
125 	int irq;
126 	struct work_struct irq_work;
127 	struct mutex mutex;
128 
129 	struct max8997_muic_platform_data *muic_pdata;
130 	enum max8997_muic_charger_type pre_charger_type;
131 
132 	/*
133 	 * Use delayed workqueue to detect cable state and then
134 	 * notify cable state to notifiee/platform through uevent.
135 	 * After completing the booting of platform, the extcon provider
136 	 * driver should notify cable state to upper layer.
137 	 */
138 	struct delayed_work wq_detcable;
139 
140 	/*
141 	 * Default usb/uart path whether UART/USB or AUX_UART/AUX_USB
142 	 * h/w path of COMP2/COMN1 on CONTROL1 register.
143 	 */
144 	int path_usb;
145 	int path_uart;
146 };
147 
148 static const unsigned int max8997_extcon_cable[] = {
149 	EXTCON_USB,
150 	EXTCON_USB_HOST,
151 	EXTCON_CHG_USB_SDP,
152 	EXTCON_CHG_USB_DCP,
153 	EXTCON_CHG_USB_FAST,
154 	EXTCON_CHG_USB_SLOW,
155 	EXTCON_CHG_USB_CDP,
156 	EXTCON_DISP_MHL,
157 	EXTCON_DOCK,
158 	EXTCON_JIG,
159 	EXTCON_NONE,
160 };
161 
162 /*
163  * max8997_muic_set_debounce_time - Set the debounce time of ADC
164  * @info: the instance including private data of max8997 MUIC
165  * @time: the debounce time of ADC
166  */
167 static int max8997_muic_set_debounce_time(struct max8997_muic_info *info,
168 		enum max8997_muic_adc_debounce_time time)
169 {
170 	int ret;
171 
172 	switch (time) {
173 	case ADC_DEBOUNCE_TIME_0_5MS:
174 	case ADC_DEBOUNCE_TIME_10MS:
175 	case ADC_DEBOUNCE_TIME_25MS:
176 	case ADC_DEBOUNCE_TIME_38_62MS:
177 		ret = max8997_update_reg(info->muic,
178 					  MAX8997_MUIC_REG_CONTROL3,
179 					  time << CONTROL3_ADCDBSET_SHIFT,
180 					  CONTROL3_ADCDBSET_MASK);
181 		if (ret) {
182 			dev_err(info->dev, "failed to set ADC debounce time\n");
183 			return ret;
184 		}
185 		break;
186 	default:
187 		dev_err(info->dev, "invalid ADC debounce time\n");
188 		return -EINVAL;
189 	}
190 
191 	return 0;
192 };
193 
194 /*
195  * max8997_muic_set_path - Set hardware line according to attached cable
196  * @info: the instance including private data of max8997 MUIC
197  * @value: the path according to attached cable
198  * @attached: the state of cable (true:attached, false:detached)
199  *
200  * The max8997 MUIC device share outside H/W line among a varity of cables,
201  * so this function set internal path of H/W line according to the type of
202  * attached cable.
203  */
204 static int max8997_muic_set_path(struct max8997_muic_info *info,
205 		u8 val, bool attached)
206 {
207 	int ret = 0;
208 	u8 ctrl1, ctrl2 = 0;
209 
210 	if (attached)
211 		ctrl1 = val;
212 	else
213 		ctrl1 = CONTROL1_SW_OPEN;
214 
215 	ret = max8997_update_reg(info->muic,
216 			MAX8997_MUIC_REG_CONTROL1, ctrl1, COMP_SW_MASK);
217 	if (ret < 0) {
218 		dev_err(info->dev, "failed to update MUIC register\n");
219 		return ret;
220 	}
221 
222 	if (attached)
223 		ctrl2 |= CONTROL2_CPEN_MASK;	/* LowPwr=0, CPEn=1 */
224 	else
225 		ctrl2 |= CONTROL2_LOWPWR_MASK;	/* LowPwr=1, CPEn=0 */
226 
227 	ret = max8997_update_reg(info->muic,
228 			MAX8997_MUIC_REG_CONTROL2, ctrl2,
229 			CONTROL2_LOWPWR_MASK | CONTROL2_CPEN_MASK);
230 	if (ret < 0) {
231 		dev_err(info->dev, "failed to update MUIC register\n");
232 		return ret;
233 	}
234 
235 	dev_info(info->dev,
236 		"CONTROL1 : 0x%02x, CONTROL2 : 0x%02x, state : %s\n",
237 		ctrl1, ctrl2, attached ? "attached" : "detached");
238 
239 	return 0;
240 }
241 
242 /*
243  * max8997_muic_get_cable_type - Return cable type and check cable state
244  * @info: the instance including private data of max8997 MUIC
245  * @group: the path according to attached cable
246  * @attached: store cable state and return
247  *
248  * This function check the cable state either attached or detached,
249  * and then divide precise type of cable according to cable group.
250  *	- MAX8997_CABLE_GROUP_ADC
251  *	- MAX8997_CABLE_GROUP_CHG
252  */
253 static int max8997_muic_get_cable_type(struct max8997_muic_info *info,
254 		enum max8997_muic_cable_group group, bool *attached)
255 {
256 	int cable_type = 0;
257 	int adc;
258 	int chg_type;
259 
260 	switch (group) {
261 	case MAX8997_CABLE_GROUP_ADC:
262 		/*
263 		 * Read ADC value to check cable type and decide cable state
264 		 * according to cable type
265 		 */
266 		adc = info->status[0] & STATUS1_ADC_MASK;
267 		adc >>= STATUS1_ADC_SHIFT;
268 
269 		/*
270 		 * Check current cable state/cable type and store cable type
271 		 * (info->prev_cable_type) for handling cable when cable is
272 		 * detached.
273 		 */
274 		if (adc == MAX8997_MUIC_ADC_OPEN) {
275 			*attached = false;
276 
277 			cable_type = info->prev_cable_type;
278 			info->prev_cable_type = MAX8997_MUIC_ADC_OPEN;
279 		} else {
280 			*attached = true;
281 
282 			cable_type = info->prev_cable_type = adc;
283 		}
284 		break;
285 	case MAX8997_CABLE_GROUP_CHG:
286 		/*
287 		 * Read charger type to check cable type and decide cable state
288 		 * according to type of charger cable.
289 		 */
290 		chg_type = info->status[1] & STATUS2_CHGTYP_MASK;
291 		chg_type >>= STATUS2_CHGTYP_SHIFT;
292 
293 		if (chg_type == MAX8997_CHARGER_TYPE_NONE) {
294 			*attached = false;
295 
296 			cable_type = info->prev_chg_type;
297 			info->prev_chg_type = MAX8997_CHARGER_TYPE_NONE;
298 		} else {
299 			*attached = true;
300 
301 			/*
302 			 * Check current cable state/cable type and store cable
303 			 * type(info->prev_chg_type) for handling cable when
304 			 * charger cable is detached.
305 			 */
306 			cable_type = info->prev_chg_type = chg_type;
307 		}
308 
309 		break;
310 	default:
311 		dev_err(info->dev, "Unknown cable group (%d)\n", group);
312 		cable_type = -EINVAL;
313 		break;
314 	}
315 
316 	return cable_type;
317 }
318 
319 static int max8997_muic_handle_usb(struct max8997_muic_info *info,
320 			enum max8997_muic_usb_type usb_type, bool attached)
321 {
322 	int ret = 0;
323 
324 	if (usb_type == MAX8997_USB_HOST) {
325 		ret = max8997_muic_set_path(info, info->path_usb, attached);
326 		if (ret < 0) {
327 			dev_err(info->dev, "failed to update muic register\n");
328 			return ret;
329 		}
330 	}
331 
332 	switch (usb_type) {
333 	case MAX8997_USB_HOST:
334 		extcon_set_cable_state_(info->edev, EXTCON_USB_HOST, attached);
335 		break;
336 	case MAX8997_USB_DEVICE:
337 		extcon_set_cable_state_(info->edev, EXTCON_USB, attached);
338 		extcon_set_cable_state_(info->edev, EXTCON_CHG_USB_SDP,
339 					attached);
340 		break;
341 	default:
342 		dev_err(info->dev, "failed to detect %s usb cable\n",
343 			attached ? "attached" : "detached");
344 		return -EINVAL;
345 	}
346 
347 	return 0;
348 }
349 
350 static int max8997_muic_handle_dock(struct max8997_muic_info *info,
351 			int cable_type, bool attached)
352 {
353 	int ret = 0;
354 
355 	ret = max8997_muic_set_path(info, CONTROL1_SW_AUDIO, attached);
356 	if (ret) {
357 		dev_err(info->dev, "failed to update muic register\n");
358 		return ret;
359 	}
360 
361 	switch (cable_type) {
362 	case MAX8997_MUIC_ADC_AV_CABLE_NOLOAD:
363 	case MAX8997_MUIC_ADC_FACTORY_MODE_UART_ON:
364 		extcon_set_cable_state_(info->edev, EXTCON_DOCK, attached);
365 		break;
366 	default:
367 		dev_err(info->dev, "failed to detect %s dock device\n",
368 			attached ? "attached" : "detached");
369 		return -EINVAL;
370 	}
371 
372 	return 0;
373 }
374 
375 static int max8997_muic_handle_jig_uart(struct max8997_muic_info *info,
376 			bool attached)
377 {
378 	int ret = 0;
379 
380 	/* switch to UART */
381 	ret = max8997_muic_set_path(info, info->path_uart, attached);
382 	if (ret) {
383 		dev_err(info->dev, "failed to update muic register\n");
384 		return ret;
385 	}
386 
387 	extcon_set_cable_state_(info->edev, EXTCON_JIG, attached);
388 
389 	return 0;
390 }
391 
392 static int max8997_muic_adc_handler(struct max8997_muic_info *info)
393 {
394 	int cable_type;
395 	bool attached;
396 	int ret = 0;
397 
398 	/* Check cable state which is either detached or attached */
399 	cable_type = max8997_muic_get_cable_type(info,
400 				MAX8997_CABLE_GROUP_ADC, &attached);
401 
402 	switch (cable_type) {
403 	case MAX8997_MUIC_ADC_GROUND:
404 		ret = max8997_muic_handle_usb(info, MAX8997_USB_HOST, attached);
405 		if (ret < 0)
406 			return ret;
407 		break;
408 	case MAX8997_MUIC_ADC_MHL:
409 		extcon_set_cable_state_(info->edev, EXTCON_DISP_MHL, attached);
410 		break;
411 	case MAX8997_MUIC_ADC_FACTORY_MODE_USB_OFF:
412 	case MAX8997_MUIC_ADC_FACTORY_MODE_USB_ON:
413 		ret = max8997_muic_handle_usb(info,
414 					     MAX8997_USB_DEVICE, attached);
415 		if (ret < 0)
416 			return ret;
417 		break;
418 	case MAX8997_MUIC_ADC_AV_CABLE_NOLOAD:
419 	case MAX8997_MUIC_ADC_FACTORY_MODE_UART_ON:
420 		ret = max8997_muic_handle_dock(info, cable_type, attached);
421 		if (ret < 0)
422 			return ret;
423 		break;
424 	case MAX8997_MUIC_ADC_FACTORY_MODE_UART_OFF:
425 		ret = max8997_muic_handle_jig_uart(info, attached);
426 		break;
427 	case MAX8997_MUIC_ADC_REMOTE_S1_BUTTON:
428 	case MAX8997_MUIC_ADC_REMOTE_S2_BUTTON:
429 	case MAX8997_MUIC_ADC_REMOTE_S3_BUTTON:
430 	case MAX8997_MUIC_ADC_REMOTE_S4_BUTTON:
431 	case MAX8997_MUIC_ADC_REMOTE_S5_BUTTON:
432 	case MAX8997_MUIC_ADC_REMOTE_S6_BUTTON:
433 	case MAX8997_MUIC_ADC_REMOTE_S7_BUTTON:
434 	case MAX8997_MUIC_ADC_REMOTE_S8_BUTTON:
435 	case MAX8997_MUIC_ADC_REMOTE_S9_BUTTON:
436 	case MAX8997_MUIC_ADC_REMOTE_S10_BUTTON:
437 	case MAX8997_MUIC_ADC_REMOTE_S11_BUTTON:
438 	case MAX8997_MUIC_ADC_REMOTE_S12_BUTTON:
439 	case MAX8997_MUIC_ADC_RESERVED_ACC_1:
440 	case MAX8997_MUIC_ADC_RESERVED_ACC_2:
441 	case MAX8997_MUIC_ADC_RESERVED_ACC_3:
442 	case MAX8997_MUIC_ADC_RESERVED_ACC_4:
443 	case MAX8997_MUIC_ADC_RESERVED_ACC_5:
444 	case MAX8997_MUIC_ADC_CEA936_AUDIO:
445 	case MAX8997_MUIC_ADC_PHONE_POWERED_DEV:
446 	case MAX8997_MUIC_ADC_TTY_CONVERTER:
447 	case MAX8997_MUIC_ADC_UART_CABLE:
448 	case MAX8997_MUIC_ADC_CEA936A_TYPE1_CHG:
449 	case MAX8997_MUIC_ADC_CEA936A_TYPE2_CHG:
450 	case MAX8997_MUIC_ADC_AUDIO_MODE_REMOTE:
451 		/*
452 		 * This cable isn't used in general case if it is specially
453 		 * needed to detect additional cable, should implement
454 		 * proper operation when this cable is attached/detached.
455 		 */
456 		dev_info(info->dev,
457 			"cable is %s but it isn't used (type:0x%x)\n",
458 			attached ? "attached" : "detached", cable_type);
459 		return -EAGAIN;
460 	default:
461 		dev_err(info->dev,
462 			"failed to detect %s unknown cable (type:0x%x)\n",
463 			attached ? "attached" : "detached", cable_type);
464 		return -EINVAL;
465 	}
466 
467 	return 0;
468 }
469 
470 static int max8997_muic_chg_handler(struct max8997_muic_info *info)
471 {
472 	int chg_type;
473 	bool attached;
474 	int adc;
475 
476 	chg_type = max8997_muic_get_cable_type(info,
477 				MAX8997_CABLE_GROUP_CHG, &attached);
478 
479 	switch (chg_type) {
480 	case MAX8997_CHARGER_TYPE_NONE:
481 		break;
482 	case MAX8997_CHARGER_TYPE_USB:
483 		adc = info->status[0] & STATUS1_ADC_MASK;
484 		adc >>= STATUS1_ADC_SHIFT;
485 
486 		if ((adc & STATUS1_ADC_MASK) == MAX8997_MUIC_ADC_OPEN) {
487 			max8997_muic_handle_usb(info,
488 					MAX8997_USB_DEVICE, attached);
489 		}
490 		break;
491 	case MAX8997_CHARGER_TYPE_DOWNSTREAM_PORT:
492 		extcon_set_cable_state_(info->edev, EXTCON_CHG_USB_CDP,
493 					attached);
494 		break;
495 	case MAX8997_CHARGER_TYPE_DEDICATED_CHG:
496 		extcon_set_cable_state_(info->edev, EXTCON_CHG_USB_DCP,
497 					attached);
498 		break;
499 	case MAX8997_CHARGER_TYPE_500MA:
500 		extcon_set_cable_state_(info->edev, EXTCON_CHG_USB_SLOW,
501 					attached);
502 		break;
503 	case MAX8997_CHARGER_TYPE_1A:
504 		extcon_set_cable_state_(info->edev, EXTCON_CHG_USB_FAST,
505 					attached);
506 		break;
507 	default:
508 		dev_err(info->dev,
509 			"failed to detect %s unknown chg cable (type:0x%x)\n",
510 			attached ? "attached" : "detached", chg_type);
511 		return -EINVAL;
512 	}
513 
514 	return 0;
515 }
516 
517 static void max8997_muic_irq_work(struct work_struct *work)
518 {
519 	struct max8997_muic_info *info = container_of(work,
520 			struct max8997_muic_info, irq_work);
521 	int irq_type = 0;
522 	int i, ret;
523 
524 	if (!info->edev)
525 		return;
526 
527 	mutex_lock(&info->mutex);
528 
529 	for (i = 0; i < ARRAY_SIZE(muic_irqs); i++)
530 		if (info->irq == muic_irqs[i].virq)
531 			irq_type = muic_irqs[i].irq;
532 
533 	ret = max8997_bulk_read(info->muic, MAX8997_MUIC_REG_STATUS1,
534 				2, info->status);
535 	if (ret) {
536 		dev_err(info->dev, "failed to read muic register\n");
537 		mutex_unlock(&info->mutex);
538 		return;
539 	}
540 
541 	switch (irq_type) {
542 	case MAX8997_MUICIRQ_ADCError:
543 	case MAX8997_MUICIRQ_ADCLow:
544 	case MAX8997_MUICIRQ_ADC:
545 		/* Handle all of cable except for charger cable */
546 		ret = max8997_muic_adc_handler(info);
547 		break;
548 	case MAX8997_MUICIRQ_VBVolt:
549 	case MAX8997_MUICIRQ_DBChg:
550 	case MAX8997_MUICIRQ_DCDTmr:
551 	case MAX8997_MUICIRQ_ChgDetRun:
552 	case MAX8997_MUICIRQ_ChgTyp:
553 		/* Handle charger cable */
554 		ret = max8997_muic_chg_handler(info);
555 		break;
556 	case MAX8997_MUICIRQ_OVP:
557 		break;
558 	default:
559 		dev_info(info->dev, "misc interrupt: irq %d occurred\n",
560 				irq_type);
561 		mutex_unlock(&info->mutex);
562 		return;
563 	}
564 
565 	if (ret < 0)
566 		dev_err(info->dev, "failed to handle MUIC interrupt\n");
567 
568 	mutex_unlock(&info->mutex);
569 }
570 
571 static irqreturn_t max8997_muic_irq_handler(int irq, void *data)
572 {
573 	struct max8997_muic_info *info = data;
574 
575 	dev_dbg(info->dev, "irq:%d\n", irq);
576 	info->irq = irq;
577 
578 	schedule_work(&info->irq_work);
579 
580 	return IRQ_HANDLED;
581 }
582 
583 static int max8997_muic_detect_dev(struct max8997_muic_info *info)
584 {
585 	int ret = 0;
586 	int adc;
587 	int chg_type;
588 	bool attached;
589 
590 	mutex_lock(&info->mutex);
591 
592 	/* Read STATUSx register to detect accessory */
593 	ret = max8997_bulk_read(info->muic,
594 			MAX8997_MUIC_REG_STATUS1, 2, info->status);
595 	if (ret) {
596 		dev_err(info->dev, "failed to read MUIC register\n");
597 		mutex_unlock(&info->mutex);
598 		return ret;
599 	}
600 
601 	adc = max8997_muic_get_cable_type(info, MAX8997_CABLE_GROUP_ADC,
602 					&attached);
603 	if (attached && adc != MAX8997_MUIC_ADC_OPEN) {
604 		ret = max8997_muic_adc_handler(info);
605 		if (ret < 0) {
606 			dev_err(info->dev, "Cannot detect ADC cable\n");
607 			mutex_unlock(&info->mutex);
608 			return ret;
609 		}
610 	}
611 
612 	chg_type = max8997_muic_get_cable_type(info, MAX8997_CABLE_GROUP_CHG,
613 					&attached);
614 	if (attached && chg_type != MAX8997_CHARGER_TYPE_NONE) {
615 		ret = max8997_muic_chg_handler(info);
616 		if (ret < 0) {
617 			dev_err(info->dev, "Cannot detect charger cable\n");
618 			mutex_unlock(&info->mutex);
619 			return ret;
620 		}
621 	}
622 
623 	mutex_unlock(&info->mutex);
624 
625 	return 0;
626 }
627 
628 static void max8997_muic_detect_cable_wq(struct work_struct *work)
629 {
630 	struct max8997_muic_info *info = container_of(to_delayed_work(work),
631 				struct max8997_muic_info, wq_detcable);
632 	int ret;
633 
634 	ret = max8997_muic_detect_dev(info);
635 	if (ret < 0)
636 		dev_err(info->dev, "failed to detect cable type\n");
637 }
638 
639 static int max8997_muic_probe(struct platform_device *pdev)
640 {
641 	struct max8997_dev *max8997 = dev_get_drvdata(pdev->dev.parent);
642 	struct max8997_platform_data *pdata = dev_get_platdata(max8997->dev);
643 	struct max8997_muic_info *info;
644 	int delay_jiffies;
645 	int ret, i;
646 
647 	info = devm_kzalloc(&pdev->dev, sizeof(struct max8997_muic_info),
648 			    GFP_KERNEL);
649 	if (!info)
650 		return -ENOMEM;
651 
652 	info->dev = &pdev->dev;
653 	info->muic = max8997->muic;
654 
655 	platform_set_drvdata(pdev, info);
656 	mutex_init(&info->mutex);
657 
658 	INIT_WORK(&info->irq_work, max8997_muic_irq_work);
659 
660 	for (i = 0; i < ARRAY_SIZE(muic_irqs); i++) {
661 		struct max8997_muic_irq *muic_irq = &muic_irqs[i];
662 		unsigned int virq = 0;
663 
664 		virq = irq_create_mapping(max8997->irq_domain, muic_irq->irq);
665 		if (!virq) {
666 			ret = -EINVAL;
667 			goto err_irq;
668 		}
669 		muic_irq->virq = virq;
670 
671 		ret = request_threaded_irq(virq, NULL,
672 				max8997_muic_irq_handler,
673 				IRQF_NO_SUSPEND,
674 				muic_irq->name, info);
675 		if (ret) {
676 			dev_err(&pdev->dev,
677 				"failed: irq request (IRQ: %d, error :%d)\n",
678 				muic_irq->irq, ret);
679 			goto err_irq;
680 		}
681 	}
682 
683 	/* External connector */
684 	info->edev = devm_extcon_dev_allocate(&pdev->dev, max8997_extcon_cable);
685 	if (IS_ERR(info->edev)) {
686 		dev_err(&pdev->dev, "failed to allocate memory for extcon\n");
687 		ret = -ENOMEM;
688 		goto err_irq;
689 	}
690 
691 	ret = devm_extcon_dev_register(&pdev->dev, info->edev);
692 	if (ret) {
693 		dev_err(&pdev->dev, "failed to register extcon device\n");
694 		goto err_irq;
695 	}
696 
697 	if (pdata && pdata->muic_pdata) {
698 		struct max8997_muic_platform_data *muic_pdata
699 			= pdata->muic_pdata;
700 
701 		/* Initialize registers according to platform data */
702 		for (i = 0; i < muic_pdata->num_init_data; i++) {
703 			max8997_write_reg(info->muic,
704 					muic_pdata->init_data[i].addr,
705 					muic_pdata->init_data[i].data);
706 		}
707 
708 		/*
709 		 * Default usb/uart path whether UART/USB or AUX_UART/AUX_USB
710 		 * h/w path of COMP2/COMN1 on CONTROL1 register.
711 		 */
712 		if (muic_pdata->path_uart)
713 			info->path_uart = muic_pdata->path_uart;
714 		else
715 			info->path_uart = CONTROL1_SW_UART;
716 
717 		if (muic_pdata->path_usb)
718 			info->path_usb = muic_pdata->path_usb;
719 		else
720 			info->path_usb = CONTROL1_SW_USB;
721 
722 		/*
723 		 * Default delay time for detecting cable state
724 		 * after certain time.
725 		 */
726 		if (muic_pdata->detcable_delay_ms)
727 			delay_jiffies =
728 				msecs_to_jiffies(muic_pdata->detcable_delay_ms);
729 		else
730 			delay_jiffies = msecs_to_jiffies(DELAY_MS_DEFAULT);
731 	} else {
732 		info->path_uart = CONTROL1_SW_UART;
733 		info->path_usb = CONTROL1_SW_USB;
734 		delay_jiffies = msecs_to_jiffies(DELAY_MS_DEFAULT);
735 	}
736 
737 	/* Set initial path for UART */
738 	 max8997_muic_set_path(info, info->path_uart, true);
739 
740 	/* Set ADC debounce time */
741 	max8997_muic_set_debounce_time(info, ADC_DEBOUNCE_TIME_25MS);
742 
743 	/*
744 	 * Detect accessory after completing the initialization of platform
745 	 *
746 	 * - Use delayed workqueue to detect cable state and then
747 	 * notify cable state to notifiee/platform through uevent.
748 	 * After completing the booting of platform, the extcon provider
749 	 * driver should notify cable state to upper layer.
750 	 */
751 	INIT_DELAYED_WORK(&info->wq_detcable, max8997_muic_detect_cable_wq);
752 	queue_delayed_work(system_power_efficient_wq, &info->wq_detcable,
753 			delay_jiffies);
754 
755 	return 0;
756 
757 err_irq:
758 	while (--i >= 0)
759 		free_irq(muic_irqs[i].virq, info);
760 	return ret;
761 }
762 
763 static int max8997_muic_remove(struct platform_device *pdev)
764 {
765 	struct max8997_muic_info *info = platform_get_drvdata(pdev);
766 	int i;
767 
768 	for (i = 0; i < ARRAY_SIZE(muic_irqs); i++)
769 		free_irq(muic_irqs[i].virq, info);
770 	cancel_work_sync(&info->irq_work);
771 
772 	return 0;
773 }
774 
775 static struct platform_driver max8997_muic_driver = {
776 	.driver		= {
777 		.name	= DEV_NAME,
778 	},
779 	.probe		= max8997_muic_probe,
780 	.remove		= max8997_muic_remove,
781 };
782 
783 module_platform_driver(max8997_muic_driver);
784 
785 MODULE_DESCRIPTION("Maxim MAX8997 Extcon driver");
786 MODULE_AUTHOR("Donggeun Kim <dg77.kim@samsung.com>");
787 MODULE_LICENSE("GPL");
788