?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 3.12.39
[linux/fpc-iii.git] / drivers / extcon / extcon-max77693.c
blob9966fc0a527f73b5080a20d7243f52e3c53060e7
1 /*
2 * extcon-max77693.c - MAX77693 extcon driver to support MAX77693 MUIC
3 *
4 * Copyright (C) 2012 Samsung Electrnoics
5 * Chanwoo Choi <cw00.choi@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/input.h>
23 #include <linux/interrupt.h>
24 #include <linux/err.h>
25 #include <linux/platform_device.h>
26 #include <linux/mfd/max77693.h>
27 #include <linux/mfd/max77693-private.h>
28 #include <linux/extcon.h>
29 #include <linux/regmap.h>
30 #include <linux/irqdomain.h>
31
32 #define DEV_NAME "max77693-muic"
33 #define DELAY_MS_DEFAULT 20000 /* unit: millisecond */
34
35 /*
36 * Default value of MAX77693 register to bring up MUIC device.
37 * If user don't set some initial value for MUIC device through platform data,
38 * extcon-max77693 driver use 'default_init_data' to bring up base operation
39 * of MAX77693 MUIC device.
40 */
41 static struct max77693_reg_data default_init_data[] = {
42 {
43 /* STATUS2 - [3]ChgDetRun */
44 .addr = MAX77693_MUIC_REG_STATUS2,
45 .data = STATUS2_CHGDETRUN_MASK,
46 }, {
47 /* INTMASK1 - Unmask [3]ADC1KM,[0]ADCM */
48 .addr = MAX77693_MUIC_REG_INTMASK1,
49 .data = INTMASK1_ADC1K_MASK
50 | INTMASK1_ADC_MASK,
51 }, {
52 /* INTMASK2 - Unmask [0]ChgTypM */
53 .addr = MAX77693_MUIC_REG_INTMASK2,
54 .data = INTMASK2_CHGTYP_MASK,
55 }, {
56 /* INTMASK3 - Mask all of interrupts */
57 .addr = MAX77693_MUIC_REG_INTMASK3,
58 .data = 0x0,
59 }, {
60 /* CDETCTRL2 */
61 .addr = MAX77693_MUIC_REG_CDETCTRL2,
62 .data = CDETCTRL2_VIDRMEN_MASK
63 | CDETCTRL2_DXOVPEN_MASK,
64 },
65 };
66
67 enum max77693_muic_adc_debounce_time {
68 ADC_DEBOUNCE_TIME_5MS = 0,
69 ADC_DEBOUNCE_TIME_10MS,
70 ADC_DEBOUNCE_TIME_25MS,
71 ADC_DEBOUNCE_TIME_38_62MS,
72 };
73
74 struct max77693_muic_info {
75 struct device *dev;
76 struct max77693_dev *max77693;
77 struct extcon_dev *edev;
78 int prev_cable_type;
79 int prev_cable_type_gnd;
80 int prev_chg_type;
81 int prev_button_type;
82 u8 status[2];
83
84 int irq;
85 struct work_struct irq_work;
86 struct mutex mutex;
87
88 /*
89 * Use delayed workqueue to detect cable state and then
90 * notify cable state to notifiee/platform through uevent.
91 * After completing the booting of platform, the extcon provider
92 * driver should notify cable state to upper layer.
93 */
94 struct delayed_work wq_detcable;
95
96 /* Button of dock device */
97 struct input_dev *dock;
98
99 /*
100 * Default usb/uart path whether UART/USB or AUX_UART/AUX_USB
101 * h/w path of COMP2/COMN1 on CONTROL1 register.
102 */
103 int path_usb;
104 int path_uart;
105 };
106
107 enum max77693_muic_cable_group {
108 MAX77693_CABLE_GROUP_ADC = 0,
109 MAX77693_CABLE_GROUP_ADC_GND,
110 MAX77693_CABLE_GROUP_CHG,
111 MAX77693_CABLE_GROUP_VBVOLT,
112 };
113
114 enum max77693_muic_charger_type {
115 MAX77693_CHARGER_TYPE_NONE = 0,
116 MAX77693_CHARGER_TYPE_USB,
117 MAX77693_CHARGER_TYPE_DOWNSTREAM_PORT,
118 MAX77693_CHARGER_TYPE_DEDICATED_CHG,
119 MAX77693_CHARGER_TYPE_APPLE_500MA,
120 MAX77693_CHARGER_TYPE_APPLE_1A_2A,
121 MAX77693_CHARGER_TYPE_DEAD_BATTERY = 7,
122 };
123
124 /**
125 * struct max77693_muic_irq
126 * @irq: the index of irq list of MUIC device.
127 * @name: the name of irq.
128 * @virq: the virtual irq to use irq domain
129 */
130 struct max77693_muic_irq {
131 unsigned int irq;
132 const char *name;
133 unsigned int virq;
134 };
135
136 static struct max77693_muic_irq muic_irqs[] = {
137 { MAX77693_MUIC_IRQ_INT1_ADC, "muic-ADC" },
138 { MAX77693_MUIC_IRQ_INT1_ADC_LOW, "muic-ADCLOW" },
139 { MAX77693_MUIC_IRQ_INT1_ADC_ERR, "muic-ADCError" },
140 { MAX77693_MUIC_IRQ_INT1_ADC1K, "muic-ADC1K" },
141 { MAX77693_MUIC_IRQ_INT2_CHGTYP, "muic-CHGTYP" },
142 { MAX77693_MUIC_IRQ_INT2_CHGDETREUN, "muic-CHGDETREUN" },
143 { MAX77693_MUIC_IRQ_INT2_DCDTMR, "muic-DCDTMR" },
144 { MAX77693_MUIC_IRQ_INT2_DXOVP, "muic-DXOVP" },
145 { MAX77693_MUIC_IRQ_INT2_VBVOLT, "muic-VBVOLT" },
146 { MAX77693_MUIC_IRQ_INT2_VIDRM, "muic-VIDRM" },
147 { MAX77693_MUIC_IRQ_INT3_EOC, "muic-EOC" },
148 { MAX77693_MUIC_IRQ_INT3_CGMBC, "muic-CGMBC" },
149 { MAX77693_MUIC_IRQ_INT3_OVP, "muic-OVP" },
150 { MAX77693_MUIC_IRQ_INT3_MBCCHG_ERR, "muic-MBCCHG_ERR" },
151 { MAX77693_MUIC_IRQ_INT3_CHG_ENABLED, "muic-CHG_ENABLED" },
152 { MAX77693_MUIC_IRQ_INT3_BAT_DET, "muic-BAT_DET" },
153 };
154
155 /* Define supported accessory type */
156 enum max77693_muic_acc_type {
157 MAX77693_MUIC_ADC_GROUND = 0x0,
158 MAX77693_MUIC_ADC_SEND_END_BUTTON,
159 MAX77693_MUIC_ADC_REMOTE_S1_BUTTON,
160 MAX77693_MUIC_ADC_REMOTE_S2_BUTTON,
161 MAX77693_MUIC_ADC_REMOTE_S3_BUTTON,
162 MAX77693_MUIC_ADC_REMOTE_S4_BUTTON,
163 MAX77693_MUIC_ADC_REMOTE_S5_BUTTON,
164 MAX77693_MUIC_ADC_REMOTE_S6_BUTTON,
165 MAX77693_MUIC_ADC_REMOTE_S7_BUTTON,
166 MAX77693_MUIC_ADC_REMOTE_S8_BUTTON,
167 MAX77693_MUIC_ADC_REMOTE_S9_BUTTON,
168 MAX77693_MUIC_ADC_REMOTE_S10_BUTTON,
169 MAX77693_MUIC_ADC_REMOTE_S11_BUTTON,
170 MAX77693_MUIC_ADC_REMOTE_S12_BUTTON,
171 MAX77693_MUIC_ADC_RESERVED_ACC_1,
172 MAX77693_MUIC_ADC_RESERVED_ACC_2,
173 MAX77693_MUIC_ADC_RESERVED_ACC_3,
174 MAX77693_MUIC_ADC_RESERVED_ACC_4,
175 MAX77693_MUIC_ADC_RESERVED_ACC_5,
176 MAX77693_MUIC_ADC_CEA936_AUDIO,
177 MAX77693_MUIC_ADC_PHONE_POWERED_DEV,
178 MAX77693_MUIC_ADC_TTY_CONVERTER,
179 MAX77693_MUIC_ADC_UART_CABLE,
180 MAX77693_MUIC_ADC_CEA936A_TYPE1_CHG,
181 MAX77693_MUIC_ADC_FACTORY_MODE_USB_OFF,
182 MAX77693_MUIC_ADC_FACTORY_MODE_USB_ON,
183 MAX77693_MUIC_ADC_AV_CABLE_NOLOAD,
184 MAX77693_MUIC_ADC_CEA936A_TYPE2_CHG,
185 MAX77693_MUIC_ADC_FACTORY_MODE_UART_OFF,
186 MAX77693_MUIC_ADC_FACTORY_MODE_UART_ON,
187 MAX77693_MUIC_ADC_AUDIO_MODE_REMOTE,
188 MAX77693_MUIC_ADC_OPEN,
189
190 /* The below accessories have same ADC value so ADCLow and
191 ADC1K bit is used to separate specific accessory */
192 MAX77693_MUIC_GND_USB_OTG = 0x100, /* ADC:0x0, VBVolot:0, ADCLow:0, ADC1K:0 */
193 MAX77693_MUIC_GND_USB_OTG_VB = 0x104, /* ADC:0x0, VBVolot:1, ADCLow:0, ADC1K:0 */
194 MAX77693_MUIC_GND_AV_CABLE_LOAD = 0x102,/* ADC:0x0, VBVolot:0, ADCLow:1, ADC1K:0 */
195 MAX77693_MUIC_GND_MHL = 0x103, /* ADC:0x0, VBVolot:0, ADCLow:1, ADC1K:1 */
196 MAX77693_MUIC_GND_MHL_VB = 0x107, /* ADC:0x0, VBVolot:1, ADCLow:1, ADC1K:1 */
197 };
198
199 /* MAX77693 MUIC device support below list of accessories(external connector) */
200 enum {
201 EXTCON_CABLE_USB = 0,
202 EXTCON_CABLE_USB_HOST,
203 EXTCON_CABLE_TA,
204 EXTCON_CABLE_FAST_CHARGER,
205 EXTCON_CABLE_SLOW_CHARGER,
206 EXTCON_CABLE_CHARGE_DOWNSTREAM,
207 EXTCON_CABLE_MHL,
208 EXTCON_CABLE_MHL_TA,
209 EXTCON_CABLE_JIG_USB_ON,
210 EXTCON_CABLE_JIG_USB_OFF,
211 EXTCON_CABLE_JIG_UART_OFF,
212 EXTCON_CABLE_JIG_UART_ON,
213 EXTCON_CABLE_DOCK_SMART,
214 EXTCON_CABLE_DOCK_DESK,
215 EXTCON_CABLE_DOCK_AUDIO,
216
217 _EXTCON_CABLE_NUM,
218 };
219
220 static const char *max77693_extcon_cable[] = {
221 [EXTCON_CABLE_USB] = "USB",
222 [EXTCON_CABLE_USB_HOST] = "USB-Host",
223 [EXTCON_CABLE_TA] = "TA",
224 [EXTCON_CABLE_FAST_CHARGER] = "Fast-charger",
225 [EXTCON_CABLE_SLOW_CHARGER] = "Slow-charger",
226 [EXTCON_CABLE_CHARGE_DOWNSTREAM] = "Charge-downstream",
227 [EXTCON_CABLE_MHL] = "MHL",
228 [EXTCON_CABLE_MHL_TA] = "MHL_TA",
229 [EXTCON_CABLE_JIG_USB_ON] = "JIG-USB-ON",
230 [EXTCON_CABLE_JIG_USB_OFF] = "JIG-USB-OFF",
231 [EXTCON_CABLE_JIG_UART_OFF] = "JIG-UART-OFF",
232 [EXTCON_CABLE_JIG_UART_ON] = "Dock-Car",
233 [EXTCON_CABLE_DOCK_SMART] = "Dock-Smart",
234 [EXTCON_CABLE_DOCK_DESK] = "Dock-Desk",
235 [EXTCON_CABLE_DOCK_AUDIO] = "Dock-Audio",
236
237 NULL,
238 };
239
240 /*
241 * max77693_muic_set_debounce_time - Set the debounce time of ADC
242 * @info: the instance including private data of max77693 MUIC
243 * @time: the debounce time of ADC
244 */
245 static int max77693_muic_set_debounce_time(struct max77693_muic_info *info,
246 enum max77693_muic_adc_debounce_time time)
247 {
248 int ret;
249
250 switch (time) {
251 case ADC_DEBOUNCE_TIME_5MS:
252 case ADC_DEBOUNCE_TIME_10MS:
253 case ADC_DEBOUNCE_TIME_25MS:
254 case ADC_DEBOUNCE_TIME_38_62MS:
255 ret = max77693_update_reg(info->max77693->regmap_muic,
256 MAX77693_MUIC_REG_CTRL3,
257 time << CONTROL3_ADCDBSET_SHIFT,
258 CONTROL3_ADCDBSET_MASK);
259 if (ret) {
260 dev_err(info->dev, "failed to set ADC debounce time\n");
261 return ret;
262 }
263 break;
264 default:
265 dev_err(info->dev, "invalid ADC debounce time\n");
266 return -EINVAL;
267 }
268
269 return 0;
270 };
271
272 /*
273 * max77693_muic_set_path - Set hardware line according to attached cable
274 * @info: the instance including private data of max77693 MUIC
275 * @value: the path according to attached cable
276 * @attached: the state of cable (true:attached, false:detached)
277 *
278 * The max77693 MUIC device share outside H/W line among a varity of cables
279 * so, this function set internal path of H/W line according to the type of
280 * attached cable.
281 */
282 static int max77693_muic_set_path(struct max77693_muic_info *info,
283 u8 val, bool attached)
284 {
285 int ret = 0;
286 u8 ctrl1, ctrl2 = 0;
287
288 if (attached)
289 ctrl1 = val;
290 else
291 ctrl1 = CONTROL1_SW_OPEN;
292
293 ret = max77693_update_reg(info->max77693->regmap_muic,
294 MAX77693_MUIC_REG_CTRL1, ctrl1, COMP_SW_MASK);
295 if (ret < 0) {
296 dev_err(info->dev, "failed to update MUIC register\n");
297 return ret;
298 }
299
300 if (attached)
301 ctrl2 |= CONTROL2_CPEN_MASK; /* LowPwr=0, CPEn=1 */
302 else
303 ctrl2 |= CONTROL2_LOWPWR_MASK; /* LowPwr=1, CPEn=0 */
304
305 ret = max77693_update_reg(info->max77693->regmap_muic,
306 MAX77693_MUIC_REG_CTRL2, ctrl2,
307 CONTROL2_LOWPWR_MASK | CONTROL2_CPEN_MASK);
308 if (ret < 0) {
309 dev_err(info->dev, "failed to update MUIC register\n");
310 return ret;
311 }
312
313 dev_info(info->dev,
314 "CONTROL1 : 0x%02x, CONTROL2 : 0x%02x, state : %s\n",
315 ctrl1, ctrl2, attached ? "attached" : "detached");
316
317 return 0;
318 }
319
320 /*
321 * max77693_muic_get_cable_type - Return cable type and check cable state
322 * @info: the instance including private data of max77693 MUIC
323 * @group: the path according to attached cable
324 * @attached: store cable state and return
325 *
326 * This function check the cable state either attached or detached,
327 * and then divide precise type of cable according to cable group.
328 * - MAX77693_CABLE_GROUP_ADC
329 * - MAX77693_CABLE_GROUP_ADC_GND
330 * - MAX77693_CABLE_GROUP_CHG
331 * - MAX77693_CABLE_GROUP_VBVOLT
332 */
333 static int max77693_muic_get_cable_type(struct max77693_muic_info *info,
334 enum max77693_muic_cable_group group, bool *attached)
335 {
336 int cable_type = 0;
337 int adc;
338 int adc1k;
339 int adclow;
340 int vbvolt;
341 int chg_type;
342
343 switch (group) {
344 case MAX77693_CABLE_GROUP_ADC:
345 /*
346 * Read ADC value to check cable type and decide cable state
347 * according to cable type
348 */
349 adc = info->status[0] & STATUS1_ADC_MASK;
350 adc >>= STATUS1_ADC_SHIFT;
351
352 /*
353 * Check current cable state/cable type and store cable type
354 * (info->prev_cable_type) for handling cable when cable is
355 * detached.
356 */
357 if (adc == MAX77693_MUIC_ADC_OPEN) {
358 *attached = false;
359
360 cable_type = info->prev_cable_type;
361 info->prev_cable_type = MAX77693_MUIC_ADC_OPEN;
362 } else {
363 *attached = true;
364
365 cable_type = info->prev_cable_type = adc;
366 }
367 break;
368 case MAX77693_CABLE_GROUP_ADC_GND:
369 /*
370 * Read ADC value to check cable type and decide cable state
371 * according to cable type
372 */
373 adc = info->status[0] & STATUS1_ADC_MASK;
374 adc >>= STATUS1_ADC_SHIFT;
375
376 /*
377 * Check current cable state/cable type and store cable type
378 * (info->prev_cable_type/_gnd) for handling cable when cable
379 * is detached.
380 */
381 if (adc == MAX77693_MUIC_ADC_OPEN) {
382 *attached = false;
383
384 cable_type = info->prev_cable_type_gnd;
385 info->prev_cable_type_gnd = MAX77693_MUIC_ADC_OPEN;
386 } else {
387 *attached = true;
388
389 adclow = info->status[0] & STATUS1_ADCLOW_MASK;
390 adclow >>= STATUS1_ADCLOW_SHIFT;
391 adc1k = info->status[0] & STATUS1_ADC1K_MASK;
392 adc1k >>= STATUS1_ADC1K_SHIFT;
393
394 vbvolt = info->status[1] & STATUS2_VBVOLT_MASK;
395 vbvolt >>= STATUS2_VBVOLT_SHIFT;
396
397 /**
398 * [0x1][VBVolt][ADCLow][ADC1K]
399 * [0x1 0 0 0 ] : USB_OTG
400 * [0x1 1 0 0 ] : USB_OTG_VB
401 * [0x1 0 1 0 ] : Audio Video Cable with load
402 * [0x1 0 1 1 ] : MHL without charging connector
403 * [0x1 1 1 1 ] : MHL with charging connector
404 */
405 cable_type = ((0x1 << 8)
406 | (vbvolt << 2)
407 | (adclow << 1)
408 | adc1k);
409
410 info->prev_cable_type = adc;
411 info->prev_cable_type_gnd = cable_type;
412 }
413
414 break;
415 case MAX77693_CABLE_GROUP_CHG:
416 /*
417 * Read charger type to check cable type and decide cable state
418 * according to type of charger cable.
419 */
420 chg_type = info->status[1] & STATUS2_CHGTYP_MASK;
421 chg_type >>= STATUS2_CHGTYP_SHIFT;
422
423 if (chg_type == MAX77693_CHARGER_TYPE_NONE) {
424 *attached = false;
425
426 cable_type = info->prev_chg_type;
427 info->prev_chg_type = MAX77693_CHARGER_TYPE_NONE;
428 } else {
429 *attached = true;
430
431 /*
432 * Check current cable state/cable type and store cable
433 * type(info->prev_chg_type) for handling cable when
434 * charger cable is detached.
435 */
436 cable_type = info->prev_chg_type = chg_type;
437 }
438
439 break;
440 case MAX77693_CABLE_GROUP_VBVOLT:
441 /*
442 * Read ADC value to check cable type and decide cable state
443 * according to cable type
444 */
445 adc = info->status[0] & STATUS1_ADC_MASK;
446 adc >>= STATUS1_ADC_SHIFT;
447 chg_type = info->status[1] & STATUS2_CHGTYP_MASK;
448 chg_type >>= STATUS2_CHGTYP_SHIFT;
449
450 if (adc == MAX77693_MUIC_ADC_OPEN
451 && chg_type == MAX77693_CHARGER_TYPE_NONE)
452 *attached = false;
453 else
454 *attached = true;
455
456 /*
457 * Read vbvolt field, if vbvolt is 1,
458 * this cable is used for charging.
459 */
460 vbvolt = info->status[1] & STATUS2_VBVOLT_MASK;
461 vbvolt >>= STATUS2_VBVOLT_SHIFT;
462
463 cable_type = vbvolt;
464 break;
465 default:
466 dev_err(info->dev, "Unknown cable group (%d)\n", group);
467 cable_type = -EINVAL;
468 break;
469 }
470
471 return cable_type;
472 }
473
474 static int max77693_muic_dock_handler(struct max77693_muic_info *info,
475 int cable_type, bool attached)
476 {
477 int ret = 0;
478 int vbvolt;
479 bool cable_attached;
480 char dock_name[CABLE_NAME_MAX];
481
482 dev_info(info->dev,
483 "external connector is %s (adc:0x%02x)\n",
484 attached ? "attached" : "detached", cable_type);
485
486 switch (cable_type) {
487 case MAX77693_MUIC_ADC_RESERVED_ACC_3: /* Dock-Smart */
488 /*
489 * Check power cable whether attached or detached state.
490 * The Dock-Smart device need surely external power supply.
491 * If power cable(USB/TA) isn't connected to Dock device,
492 * user can't use Dock-Smart for desktop mode.
493 */
494 vbvolt = max77693_muic_get_cable_type(info,
495 MAX77693_CABLE_GROUP_VBVOLT, &cable_attached);
496 if (attached && !vbvolt) {
497 dev_warn(info->dev,
498 "Cannot detect external power supply\n");
499 return 0;
500 }
501
502 /*
503 * Notify Dock-Smart/MHL state.
504 * - Dock-Smart device include three type of cable which
505 * are HDMI, USB for mouse/keyboard and micro-usb port
506 * for USB/TA cable. Dock-Smart device need always exteranl
507 * power supply(USB/TA cable through micro-usb cable). Dock-
508 * Smart device support screen output of target to separate
509 * monitor and mouse/keyboard for desktop mode.
510 *
511 * Features of 'USB/TA cable with Dock-Smart device'
512 * - Support MHL
513 * - Support external output feature of audio
514 * - Support charging through micro-usb port without data
515 * connection if TA cable is connected to target.
516 * - Support charging and data connection through micro-usb port
517 * if USB cable is connected between target and host
518 * device.
519 * - Support OTG device (Mouse/Keyboard)
520 */
521 ret = max77693_muic_set_path(info, info->path_usb, attached);
522 if (ret < 0)
523 return ret;
524
525 extcon_set_cable_state(info->edev, "Dock-Smart", attached);
526 extcon_set_cable_state(info->edev, "MHL", attached);
527 goto out;
528 case MAX77693_MUIC_ADC_FACTORY_MODE_UART_ON: /* Dock-Car */
529 strcpy(dock_name, "Dock-Car");
530 break;
531 case MAX77693_MUIC_ADC_AUDIO_MODE_REMOTE: /* Dock-Desk */
532 strcpy(dock_name, "Dock-Desk");
533 break;
534 case MAX77693_MUIC_ADC_AV_CABLE_NOLOAD: /* Dock-Audio */
535 strcpy(dock_name, "Dock-Audio");
536 if (!attached)
537 extcon_set_cable_state(info->edev, "USB", false);
538 break;
539 default:
540 dev_err(info->dev, "failed to detect %s dock device\n",
541 attached ? "attached" : "detached");
542 return -EINVAL;
543 }
544
545 /* Dock-Car/Desk/Audio, PATH:AUDIO */
546 ret = max77693_muic_set_path(info, CONTROL1_SW_AUDIO, attached);
547 if (ret < 0)
548 return ret;
549 extcon_set_cable_state(info->edev, dock_name, attached);
550
551 out:
552 return 0;
553 }
554
555 static int max77693_muic_dock_button_handler(struct max77693_muic_info *info,
556 int button_type, bool attached)
557 {
558 struct input_dev *dock = info->dock;
559 unsigned int code;
560
561 switch (button_type) {
562 case MAX77693_MUIC_ADC_REMOTE_S3_BUTTON-1
563 ... MAX77693_MUIC_ADC_REMOTE_S3_BUTTON+1:
564 /* DOCK_KEY_PREV */
565 code = KEY_PREVIOUSSONG;
566 break;
567 case MAX77693_MUIC_ADC_REMOTE_S7_BUTTON-1
568 ... MAX77693_MUIC_ADC_REMOTE_S7_BUTTON+1:
569 /* DOCK_KEY_NEXT */
570 code = KEY_NEXTSONG;
571 break;
572 case MAX77693_MUIC_ADC_REMOTE_S9_BUTTON:
573 /* DOCK_VOL_DOWN */
574 code = KEY_VOLUMEDOWN;
575 break;
576 case MAX77693_MUIC_ADC_REMOTE_S10_BUTTON:
577 /* DOCK_VOL_UP */
578 code = KEY_VOLUMEUP;
579 break;
580 case MAX77693_MUIC_ADC_REMOTE_S12_BUTTON-1
581 ... MAX77693_MUIC_ADC_REMOTE_S12_BUTTON+1:
582 /* DOCK_KEY_PLAY_PAUSE */
583 code = KEY_PLAYPAUSE;
584 break;
585 default:
586 dev_err(info->dev,
587 "failed to detect %s key (adc:0x%x)\n",
588 attached ? "pressed" : "released", button_type);
589 return -EINVAL;
590 }
591
592 input_event(dock, EV_KEY, code, attached);
593 input_sync(dock);
594
595 return 0;
596 }
597
598 static int max77693_muic_adc_ground_handler(struct max77693_muic_info *info)
599 {
600 int cable_type_gnd;
601 int ret = 0;
602 bool attached;
603
604 cable_type_gnd = max77693_muic_get_cable_type(info,
605 MAX77693_CABLE_GROUP_ADC_GND, &attached);
606
607 switch (cable_type_gnd) {
608 case MAX77693_MUIC_GND_USB_OTG:
609 case MAX77693_MUIC_GND_USB_OTG_VB:
610 /* USB_OTG, PATH: AP_USB */
611 ret = max77693_muic_set_path(info, CONTROL1_SW_USB, attached);
612 if (ret < 0)
613 return ret;
614 extcon_set_cable_state(info->edev, "USB-Host", attached);
615 break;
616 case MAX77693_MUIC_GND_AV_CABLE_LOAD:
617 /* Audio Video Cable with load, PATH:AUDIO */
618 ret = max77693_muic_set_path(info, CONTROL1_SW_AUDIO, attached);
619 if (ret < 0)
620 return ret;
621 extcon_set_cable_state(info->edev,
622 "Audio-video-load", attached);
623 break;
624 case MAX77693_MUIC_GND_MHL:
625 case MAX77693_MUIC_GND_MHL_VB:
626 /* MHL or MHL with USB/TA cable */
627 extcon_set_cable_state(info->edev, "MHL", attached);
628 break;
629 default:
630 dev_err(info->dev, "failed to detect %s cable of gnd type\n",
631 attached ? "attached" : "detached");
632 return -EINVAL;
633 }
634
635 return 0;
636 }
637
638 static int max77693_muic_jig_handler(struct max77693_muic_info *info,
639 int cable_type, bool attached)
640 {
641 char cable_name[32];
642 int ret = 0;
643 u8 path = CONTROL1_SW_OPEN;
644
645 dev_info(info->dev,
646 "external connector is %s (adc:0x%02x)\n",
647 attached ? "attached" : "detached", cable_type);
648
649 switch (cable_type) {
650 case MAX77693_MUIC_ADC_FACTORY_MODE_USB_OFF: /* ADC_JIG_USB_OFF */
651 /* PATH:AP_USB */
652 strcpy(cable_name, "JIG-USB-OFF");
653 path = CONTROL1_SW_USB;
654 break;
655 case MAX77693_MUIC_ADC_FACTORY_MODE_USB_ON: /* ADC_JIG_USB_ON */
656 /* PATH:AP_USB */
657 strcpy(cable_name, "JIG-USB-ON");
658 path = CONTROL1_SW_USB;
659 break;
660 case MAX77693_MUIC_ADC_FACTORY_MODE_UART_OFF: /* ADC_JIG_UART_OFF */
661 /* PATH:AP_UART */
662 strcpy(cable_name, "JIG-UART-OFF");
663 path = CONTROL1_SW_UART;
664 break;
665 default:
666 dev_err(info->dev, "failed to detect %s jig cable\n",
667 attached ? "attached" : "detached");
668 return -EINVAL;
669 }
670
671 ret = max77693_muic_set_path(info, path, attached);
672 if (ret < 0)
673 return ret;
674
675 extcon_set_cable_state(info->edev, cable_name, attached);
676
677 return 0;
678 }
679
680 static int max77693_muic_adc_handler(struct max77693_muic_info *info)
681 {
682 int cable_type;
683 int button_type;
684 bool attached;
685 int ret = 0;
686
687 /* Check accessory state which is either detached or attached */
688 cable_type = max77693_muic_get_cable_type(info,
689 MAX77693_CABLE_GROUP_ADC, &attached);
690
691 dev_info(info->dev,
692 "external connector is %s (adc:0x%02x, prev_adc:0x%x)\n",
693 attached ? "attached" : "detached", cable_type,
694 info->prev_cable_type);
695
696 switch (cable_type) {
697 case MAX77693_MUIC_ADC_GROUND:
698 /* USB_OTG/MHL/Audio */
699 max77693_muic_adc_ground_handler(info);
700 break;
701 case MAX77693_MUIC_ADC_FACTORY_MODE_USB_OFF:
702 case MAX77693_MUIC_ADC_FACTORY_MODE_USB_ON:
703 case MAX77693_MUIC_ADC_FACTORY_MODE_UART_OFF:
704 /* JIG */
705 ret = max77693_muic_jig_handler(info, cable_type, attached);
706 if (ret < 0)
707 return ret;
708 break;
709 case MAX77693_MUIC_ADC_RESERVED_ACC_3: /* Dock-Smart */
710 case MAX77693_MUIC_ADC_FACTORY_MODE_UART_ON: /* Dock-Car */
711 case MAX77693_MUIC_ADC_AUDIO_MODE_REMOTE: /* Dock-Desk */
712 case MAX77693_MUIC_ADC_AV_CABLE_NOLOAD: /* Dock-Audio */
713 /*
714 * DOCK device
715 *
716 * The MAX77693 MUIC device can detect total 34 cable type
717 * except of charger cable and MUIC device didn't define
718 * specfic role of cable in the range of from 0x01 to 0x12
719 * of ADC value. So, can use/define cable with no role according
720 * to schema of hardware board.
721 */
722 ret = max77693_muic_dock_handler(info, cable_type, attached);
723 if (ret < 0)
724 return ret;
725 break;
726 case MAX77693_MUIC_ADC_REMOTE_S3_BUTTON: /* DOCK_KEY_PREV */
727 case MAX77693_MUIC_ADC_REMOTE_S7_BUTTON: /* DOCK_KEY_NEXT */
728 case MAX77693_MUIC_ADC_REMOTE_S9_BUTTON: /* DOCK_VOL_DOWN */
729 case MAX77693_MUIC_ADC_REMOTE_S10_BUTTON: /* DOCK_VOL_UP */
730 case MAX77693_MUIC_ADC_REMOTE_S12_BUTTON: /* DOCK_KEY_PLAY_PAUSE */
731 /*
732 * Button of DOCK device
733 * - the Prev/Next/Volume Up/Volume Down/Play-Pause button
734 *
735 * The MAX77693 MUIC device can detect total 34 cable type
736 * except of charger cable and MUIC device didn't define
737 * specfic role of cable in the range of from 0x01 to 0x12
738 * of ADC value. So, can use/define cable with no role according
739 * to schema of hardware board.
740 */
741 if (attached)
742 button_type = info->prev_button_type = cable_type;
743 else
744 button_type = info->prev_button_type;
745
746 ret = max77693_muic_dock_button_handler(info, button_type,
747 attached);
748 if (ret < 0)
749 return ret;
750 break;
751 case MAX77693_MUIC_ADC_SEND_END_BUTTON:
752 case MAX77693_MUIC_ADC_REMOTE_S1_BUTTON:
753 case MAX77693_MUIC_ADC_REMOTE_S2_BUTTON:
754 case MAX77693_MUIC_ADC_REMOTE_S4_BUTTON:
755 case MAX77693_MUIC_ADC_REMOTE_S5_BUTTON:
756 case MAX77693_MUIC_ADC_REMOTE_S6_BUTTON:
757 case MAX77693_MUIC_ADC_REMOTE_S8_BUTTON:
758 case MAX77693_MUIC_ADC_REMOTE_S11_BUTTON:
759 case MAX77693_MUIC_ADC_RESERVED_ACC_1:
760 case MAX77693_MUIC_ADC_RESERVED_ACC_2:
761 case MAX77693_MUIC_ADC_RESERVED_ACC_4:
762 case MAX77693_MUIC_ADC_RESERVED_ACC_5:
763 case MAX77693_MUIC_ADC_CEA936_AUDIO:
764 case MAX77693_MUIC_ADC_PHONE_POWERED_DEV:
765 case MAX77693_MUIC_ADC_TTY_CONVERTER:
766 case MAX77693_MUIC_ADC_UART_CABLE:
767 case MAX77693_MUIC_ADC_CEA936A_TYPE1_CHG:
768 case MAX77693_MUIC_ADC_CEA936A_TYPE2_CHG:
769 /*
770 * This accessory isn't used in general case if it is specially
771 * needed to detect additional accessory, should implement
772 * proper operation when this accessory is attached/detached.
773 */
774 dev_info(info->dev,
775 "accessory is %s but it isn't used (adc:0x%x)\n",
776 attached ? "attached" : "detached", cable_type);
777 return -EAGAIN;
778 default:
779 dev_err(info->dev,
780 "failed to detect %s accessory (adc:0x%x)\n",
781 attached ? "attached" : "detached", cable_type);
782 return -EINVAL;
783 }
784
785 return 0;
786 }
787
788 static int max77693_muic_chg_handler(struct max77693_muic_info *info)
789 {
790 int chg_type;
791 int cable_type_gnd;
792 int cable_type;
793 bool attached;
794 bool cable_attached;
795 int ret = 0;
796
797 chg_type = max77693_muic_get_cable_type(info,
798 MAX77693_CABLE_GROUP_CHG, &attached);
799
800 dev_info(info->dev,
801 "external connector is %s(chg_type:0x%x, prev_chg_type:0x%x)\n",
802 attached ? "attached" : "detached",
803 chg_type, info->prev_chg_type);
804
805 switch (chg_type) {
806 case MAX77693_CHARGER_TYPE_USB:
807 case MAX77693_CHARGER_TYPE_DEDICATED_CHG:
808 case MAX77693_CHARGER_TYPE_NONE:
809 /* Check MAX77693_CABLE_GROUP_ADC_GND type */
810 cable_type_gnd = max77693_muic_get_cable_type(info,
811 MAX77693_CABLE_GROUP_ADC_GND,
812 &cable_attached);
813 switch (cable_type_gnd) {
814 case MAX77693_MUIC_GND_MHL:
815 case MAX77693_MUIC_GND_MHL_VB:
816 /*
817 * MHL cable with MHL_TA(USB/TA) cable
818 * - MHL cable include two port(HDMI line and separate micro-
819 * usb port. When the target connect MHL cable, extcon driver
820 * check whether MHL_TA(USB/TA) cable is connected. If MHL_TA
821 * cable is connected, extcon driver notify state to notifiee
822 * for charging battery.
823 *
824 * Features of 'MHL_TA(USB/TA) with MHL cable'
825 * - Support MHL
826 * - Support charging through micro-usb port without data connection
827 */
828 extcon_set_cable_state(info->edev, "MHL_TA", attached);
829 if (!cable_attached)
830 extcon_set_cable_state(info->edev, "MHL", cable_attached);
831 break;
832 }
833
834 /* Check MAX77693_CABLE_GROUP_ADC type */
835 cable_type = max77693_muic_get_cable_type(info,
836 MAX77693_CABLE_GROUP_ADC,
837 &cable_attached);
838 switch (cable_type) {
839 case MAX77693_MUIC_ADC_AV_CABLE_NOLOAD: /* Dock-Audio */
840 /*
841 * Dock-Audio device with USB/TA cable
842 * - Dock device include two port(Dock-Audio and micro-usb
843 * port). When the target connect Dock-Audio device, extcon
844 * driver check whether USB/TA cable is connected. If USB/TA
845 * cable is connected, extcon driver notify state to notifiee
846 * for charging battery.
847 *
848 * Features of 'USB/TA cable with Dock-Audio device'
849 * - Support external output feature of audio.
850 * - Support charging through micro-usb port without data
851 * connection.
852 */
853 extcon_set_cable_state(info->edev, "USB", attached);
854
855 if (!cable_attached)
856 extcon_set_cable_state(info->edev, "Dock-Audio", cable_attached);
857 break;
858 case MAX77693_MUIC_ADC_RESERVED_ACC_3: /* Dock-Smart */
859 /*
860 * Dock-Smart device with USB/TA cable
861 * - Dock-Desk device include three type of cable which
862 * are HDMI, USB for mouse/keyboard and micro-usb port
863 * for USB/TA cable. Dock-Smart device need always exteranl
864 * power supply(USB/TA cable through micro-usb cable). Dock-
865 * Smart device support screen output of target to separate
866 * monitor and mouse/keyboard for desktop mode.
867 *
868 * Features of 'USB/TA cable with Dock-Smart device'
869 * - Support MHL
870 * - Support external output feature of audio
871 * - Support charging through micro-usb port without data
872 * connection if TA cable is connected to target.
873 * - Support charging and data connection through micro-usb port
874 * if USB cable is connected between target and host
875 * device.
876 * - Support OTG device (Mouse/Keyboard)
877 */
878 ret = max77693_muic_set_path(info, info->path_usb, attached);
879 if (ret < 0)
880 return ret;
881
882 extcon_set_cable_state(info->edev, "Dock-Smart", attached);
883 extcon_set_cable_state(info->edev, "MHL", attached);
884
885 break;
886 }
887
888 /* Check MAX77693_CABLE_GROUP_CHG type */
889 switch (chg_type) {
890 case MAX77693_CHARGER_TYPE_NONE:
891 /*
892 * When MHL(with USB/TA cable) or Dock-Audio with USB/TA cable
893 * is attached, muic device happen below two interrupt.
894 * - 'MAX77693_MUIC_IRQ_INT1_ADC' for detecting MHL/Dock-Audio.
895 * - 'MAX77693_MUIC_IRQ_INT2_CHGTYP' for detecting USB/TA cable
896 * connected to MHL or Dock-Audio.
897 * Always, happen eariler MAX77693_MUIC_IRQ_INT1_ADC interrupt
898 * than MAX77693_MUIC_IRQ_INT2_CHGTYP interrupt.
899 *
900 * If user attach MHL (with USB/TA cable and immediately detach
901 * MHL with USB/TA cable before MAX77693_MUIC_IRQ_INT2_CHGTYP
902 * interrupt is happened, USB/TA cable remain connected state to
903 * target. But USB/TA cable isn't connected to target. The user
904 * be face with unusual action. So, driver should check this
905 * situation in spite of, that previous charger type is N/A.
906 */
907 break;
908 case MAX77693_CHARGER_TYPE_USB:
909 /* Only USB cable, PATH:AP_USB */
910 ret = max77693_muic_set_path(info, info->path_usb, attached);
911 if (ret < 0)
912 return ret;
913
914 extcon_set_cable_state(info->edev, "USB", attached);
915 break;
916 case MAX77693_CHARGER_TYPE_DEDICATED_CHG:
917 /* Only TA cable */
918 extcon_set_cable_state(info->edev, "TA", attached);
919 break;
920 }
921 break;
922 case MAX77693_CHARGER_TYPE_DOWNSTREAM_PORT:
923 extcon_set_cable_state(info->edev,
924 "Charge-downstream", attached);
925 break;
926 case MAX77693_CHARGER_TYPE_APPLE_500MA:
927 extcon_set_cable_state(info->edev, "Slow-charger", attached);
928 break;
929 case MAX77693_CHARGER_TYPE_APPLE_1A_2A:
930 extcon_set_cable_state(info->edev, "Fast-charger", attached);
931 break;
932 case MAX77693_CHARGER_TYPE_DEAD_BATTERY:
933 break;
934 default:
935 dev_err(info->dev,
936 "failed to detect %s accessory (chg_type:0x%x)\n",
937 attached ? "attached" : "detached", chg_type);
938 return -EINVAL;
939 }
940
941 return 0;
942 }
943
944 static void max77693_muic_irq_work(struct work_struct *work)
945 {
946 struct max77693_muic_info *info = container_of(work,
947 struct max77693_muic_info, irq_work);
948 int irq_type = -1;
949 int i, ret = 0;
950
951 if (!info->edev)
952 return;
953
954 mutex_lock(&info->mutex);
955
956 for (i = 0 ; i < ARRAY_SIZE(muic_irqs) ; i++)
957 if (info->irq == muic_irqs[i].virq)
958 irq_type = muic_irqs[i].irq;
959
960 ret = max77693_bulk_read(info->max77693->regmap_muic,
961 MAX77693_MUIC_REG_STATUS1, 2, info->status);
962 if (ret) {
963 dev_err(info->dev, "failed to read MUIC register\n");
964 mutex_unlock(&info->mutex);
965 return;
966 }
967
968 switch (irq_type) {
969 case MAX77693_MUIC_IRQ_INT1_ADC:
970 case MAX77693_MUIC_IRQ_INT1_ADC_LOW:
971 case MAX77693_MUIC_IRQ_INT1_ADC_ERR:
972 case MAX77693_MUIC_IRQ_INT1_ADC1K:
973 /* Handle all of accessory except for
974 type of charger accessory */
975 ret = max77693_muic_adc_handler(info);
976 break;
977 case MAX77693_MUIC_IRQ_INT2_CHGTYP:
978 case MAX77693_MUIC_IRQ_INT2_CHGDETREUN:
979 case MAX77693_MUIC_IRQ_INT2_DCDTMR:
980 case MAX77693_MUIC_IRQ_INT2_DXOVP:
981 case MAX77693_MUIC_IRQ_INT2_VBVOLT:
982 case MAX77693_MUIC_IRQ_INT2_VIDRM:
983 /* Handle charger accessory */
984 ret = max77693_muic_chg_handler(info);
985 break;
986 case MAX77693_MUIC_IRQ_INT3_EOC:
987 case MAX77693_MUIC_IRQ_INT3_CGMBC:
988 case MAX77693_MUIC_IRQ_INT3_OVP:
989 case MAX77693_MUIC_IRQ_INT3_MBCCHG_ERR:
990 case MAX77693_MUIC_IRQ_INT3_CHG_ENABLED:
991 case MAX77693_MUIC_IRQ_INT3_BAT_DET:
992 break;
993 default:
994 dev_err(info->dev, "muic interrupt: irq %d occurred\n",
995 irq_type);
996 mutex_unlock(&info->mutex);
997 return;
998 }
999
1000 if (ret < 0)
1001 dev_err(info->dev, "failed to handle MUIC interrupt\n");
1002
1003 mutex_unlock(&info->mutex);
1004
1005 return;
1006 }
1007
1008 static irqreturn_t max77693_muic_irq_handler(int irq, void *data)
1009 {
1010 struct max77693_muic_info *info = data;
1011
1012 info->irq = irq;
1013 schedule_work(&info->irq_work);
1014
1015 return IRQ_HANDLED;
1016 }
1017
1018 static struct regmap_config max77693_muic_regmap_config = {
1019 .reg_bits = 8,
1020 .val_bits = 8,
1021 };
1022
1023 static int max77693_muic_detect_accessory(struct max77693_muic_info *info)
1024 {
1025 int ret = 0;
1026 int adc;
1027 int chg_type;
1028 bool attached;
1029
1030 mutex_lock(&info->mutex);
1031
1032 /* Read STATUSx register to detect accessory */
1033 ret = max77693_bulk_read(info->max77693->regmap_muic,
1034 MAX77693_MUIC_REG_STATUS1, 2, info->status);
1035 if (ret) {
1036 dev_err(info->dev, "failed to read MUIC register\n");
1037 mutex_unlock(&info->mutex);
1038 return ret;
1039 }
1040
1041 adc = max77693_muic_get_cable_type(info, MAX77693_CABLE_GROUP_ADC,
1042 &attached);
1043 if (attached && adc != MAX77693_MUIC_ADC_OPEN) {
1044 ret = max77693_muic_adc_handler(info);
1045 if (ret < 0) {
1046 dev_err(info->dev, "Cannot detect accessory\n");
1047 mutex_unlock(&info->mutex);
1048 return ret;
1049 }
1050 }
1051
1052 chg_type = max77693_muic_get_cable_type(info, MAX77693_CABLE_GROUP_CHG,
1053 &attached);
1054 if (attached && chg_type != MAX77693_CHARGER_TYPE_NONE) {
1055 ret = max77693_muic_chg_handler(info);
1056 if (ret < 0) {
1057 dev_err(info->dev, "Cannot detect charger accessory\n");
1058 mutex_unlock(&info->mutex);
1059 return ret;
1060 }
1061 }
1062
1063 mutex_unlock(&info->mutex);
1064
1065 return 0;
1066 }
1067
1068 static void max77693_muic_detect_cable_wq(struct work_struct *work)
1069 {
1070 struct max77693_muic_info *info = container_of(to_delayed_work(work),
1071 struct max77693_muic_info, wq_detcable);
1072
1073 max77693_muic_detect_accessory(info);
1074 }
1075
1076 static int max77693_muic_probe(struct platform_device *pdev)
1077 {
1078 struct max77693_dev *max77693 = dev_get_drvdata(pdev->dev.parent);
1079 struct max77693_platform_data *pdata = dev_get_platdata(max77693->dev);
1080 struct max77693_muic_info *info;
1081 struct max77693_reg_data *init_data;
1082 int num_init_data;
1083 int delay_jiffies;
1084 int ret;
1085 int i;
1086 u8 id;
1087
1088 info = devm_kzalloc(&pdev->dev, sizeof(struct max77693_muic_info),
1089 GFP_KERNEL);
1090 if (!info) {
1091 dev_err(&pdev->dev, "failed to allocate memory\n");
1092 return -ENOMEM;
1093 }
1094 info->dev = &pdev->dev;
1095 info->max77693 = max77693;
1096 if (info->max77693->regmap_muic) {
1097 dev_dbg(&pdev->dev, "allocate register map\n");
1098 } else {
1099 info->max77693->regmap_muic = devm_regmap_init_i2c(
1100 info->max77693->muic,
1101 &max77693_muic_regmap_config);
1102 if (IS_ERR(info->max77693->regmap_muic)) {
1103 ret = PTR_ERR(info->max77693->regmap_muic);
1104 dev_err(max77693->dev,
1105 "failed to allocate register map: %d\n", ret);
1106 return ret;
1107 }
1108 }
1109
1110 /* Register input device for button of dock device */
1111 info->dock = devm_input_allocate_device(&pdev->dev);
1112 if (!info->dock) {
1113 dev_err(&pdev->dev, "%s: failed to allocate input\n", __func__);
1114 return -ENOMEM;
1115 }
1116 info->dock->name = "max77693-muic/dock";
1117 info->dock->phys = "max77693-muic/extcon";
1118 info->dock->dev.parent = &pdev->dev;
1119
1120 __set_bit(EV_REP, info->dock->evbit);
1121
1122 input_set_capability(info->dock, EV_KEY, KEY_VOLUMEUP);
1123 input_set_capability(info->dock, EV_KEY, KEY_VOLUMEDOWN);
1124 input_set_capability(info->dock, EV_KEY, KEY_PLAYPAUSE);
1125 input_set_capability(info->dock, EV_KEY, KEY_PREVIOUSSONG);
1126 input_set_capability(info->dock, EV_KEY, KEY_NEXTSONG);
1127
1128 ret = input_register_device(info->dock);
1129 if (ret < 0) {
1130 dev_err(&pdev->dev, "Cannot register input device error(%d)\n",
1131 ret);
1132 return ret;
1133 }
1134
1135 platform_set_drvdata(pdev, info);
1136 mutex_init(&info->mutex);
1137
1138 INIT_WORK(&info->irq_work, max77693_muic_irq_work);
1139
1140 /* Support irq domain for MAX77693 MUIC device */
1141 for (i = 0; i < ARRAY_SIZE(muic_irqs); i++) {
1142 struct max77693_muic_irq *muic_irq = &muic_irqs[i];
1143 unsigned int virq = 0;
1144
1145 virq = irq_create_mapping(max77693->irq_domain, muic_irq->irq);
1146 if (!virq) {
1147 ret = -EINVAL;
1148 goto err_irq;
1149 }
1150 muic_irq->virq = virq;
1151
1152 ret = request_threaded_irq(virq, NULL,
1153 max77693_muic_irq_handler,
1154 IRQF_NO_SUSPEND,
1155 muic_irq->name, info);
1156 if (ret) {
1157 dev_err(&pdev->dev,
1158 "failed: irq request (IRQ: %d,"
1159 " error :%d)\n",
1160 muic_irq->irq, ret);
1161 goto err_irq;
1162 }
1163 }
1164
1165 /* Initialize extcon device */
1166 info->edev = devm_kzalloc(&pdev->dev, sizeof(struct extcon_dev),
1167 GFP_KERNEL);
1168 if (!info->edev) {
1169 dev_err(&pdev->dev, "failed to allocate memory for extcon\n");
1170 ret = -ENOMEM;
1171 goto err_irq;
1172 }
1173 info->edev->name = DEV_NAME;
1174 info->edev->supported_cable = max77693_extcon_cable;
1175 ret = extcon_dev_register(info->edev, NULL);
1176 if (ret) {
1177 dev_err(&pdev->dev, "failed to register extcon device\n");
1178 goto err_irq;
1179 }
1180
1181
1182 /* Initialize MUIC register by using platform data or default data */
1183 if (pdata && pdata->muic_data) {
1184 init_data = pdata->muic_data->init_data;
1185 num_init_data = pdata->muic_data->num_init_data;
1186 } else {
1187 init_data = default_init_data;
1188 num_init_data = ARRAY_SIZE(default_init_data);
1189 }
1190
1191 for (i = 0 ; i < num_init_data ; i++) {
1192 enum max77693_irq_source irq_src
1193 = MAX77693_IRQ_GROUP_NR;
1194
1195 max77693_write_reg(info->max77693->regmap_muic,
1196 init_data[i].addr,
1197 init_data[i].data);
1198
1199 switch (init_data[i].addr) {
1200 case MAX77693_MUIC_REG_INTMASK1:
1201 irq_src = MUIC_INT1;
1202 break;
1203 case MAX77693_MUIC_REG_INTMASK2:
1204 irq_src = MUIC_INT2;
1205 break;
1206 case MAX77693_MUIC_REG_INTMASK3:
1207 irq_src = MUIC_INT3;
1208 break;
1209 }
1210
1211 if (irq_src < MAX77693_IRQ_GROUP_NR)
1212 info->max77693->irq_masks_cur[irq_src]
1213 = init_data[i].data;
1214 }
1215
1216 if (pdata && pdata->muic_data) {
1217 struct max77693_muic_platform_data *muic_pdata = pdata->muic_data;
1218
1219 /*
1220 * Default usb/uart path whether UART/USB or AUX_UART/AUX_USB
1221 * h/w path of COMP2/COMN1 on CONTROL1 register.
1222 */
1223 if (muic_pdata->path_uart)
1224 info->path_uart = muic_pdata->path_uart;
1225 else
1226 info->path_uart = CONTROL1_SW_UART;
1227
1228 if (muic_pdata->path_usb)
1229 info->path_usb = muic_pdata->path_usb;
1230 else
1231 info->path_usb = CONTROL1_SW_USB;
1232
1233 /*
1234 * Default delay time for detecting cable state
1235 * after certain time.
1236 */
1237 if (muic_pdata->detcable_delay_ms)
1238 delay_jiffies =
1239 msecs_to_jiffies(muic_pdata->detcable_delay_ms);
1240 else
1241 delay_jiffies = msecs_to_jiffies(DELAY_MS_DEFAULT);
1242 } else {
1243 info->path_usb = CONTROL1_SW_USB;
1244 info->path_uart = CONTROL1_SW_UART;
1245 delay_jiffies = msecs_to_jiffies(DELAY_MS_DEFAULT);
1246 }
1247
1248 /* Set initial path for UART */
1249 max77693_muic_set_path(info, info->path_uart, true);
1250
1251 /* Check revision number of MUIC device*/
1252 ret = max77693_read_reg(info->max77693->regmap_muic,
1253 MAX77693_MUIC_REG_ID, &id);
1254 if (ret < 0) {
1255 dev_err(&pdev->dev, "failed to read revision number\n");
1256 goto err_extcon;
1257 }
1258 dev_info(info->dev, "device ID : 0x%x\n", id);
1259
1260 /* Set ADC debounce time */
1261 max77693_muic_set_debounce_time(info, ADC_DEBOUNCE_TIME_25MS);
1262
1263 /*
1264 * Detect accessory after completing the initialization of platform
1265 *
1266 * - Use delayed workqueue to detect cable state and then
1267 * notify cable state to notifiee/platform through uevent.
1268 * After completing the booting of platform, the extcon provider
1269 * driver should notify cable state to upper layer.
1270 */
1271 INIT_DELAYED_WORK(&info->wq_detcable, max77693_muic_detect_cable_wq);
1272 schedule_delayed_work(&info->wq_detcable, delay_jiffies);
1273
1274 return ret;
1275
1276 err_extcon:
1277 extcon_dev_unregister(info->edev);
1278 err_irq:
1279 while (--i >= 0)
1280 free_irq(muic_irqs[i].virq, info);
1281 return ret;
1282 }
1283
1284 static int max77693_muic_remove(struct platform_device *pdev)
1285 {
1286 struct max77693_muic_info *info = platform_get_drvdata(pdev);
1287 int i;
1288
1289 for (i = 0; i < ARRAY_SIZE(muic_irqs); i++)
1290 free_irq(muic_irqs[i].virq, info);
1291 cancel_work_sync(&info->irq_work);
1292 input_unregister_device(info->dock);
1293 extcon_dev_unregister(info->edev);
1294
1295 return 0;
1296 }
1297
1298 static struct platform_driver max77693_muic_driver = {
1299 .driver = {
1300 .name = DEV_NAME,
1301 .owner = THIS_MODULE,
1302 },
1303 .probe = max77693_muic_probe,
1304 .remove = max77693_muic_remove,
1305 };
1306
1307 module_platform_driver(max77693_muic_driver);
1308
1309 MODULE_DESCRIPTION("Maxim MAX77693 Extcon driver");
1310 MODULE_AUTHOR("Chanwoo Choi <cw00.choi@samsung.com>");
1311 MODULE_LICENSE("GPL");
1312 MODULE_ALIAS("platform:extcon-max77693");
Linux with added FPC-III support