2 * extcon-max14577.c - MAX14577/77836 extcon driver to support MUIC
4 * Copyright (C) 2013,2014 Samsung Electronics
5 * Chanwoo Choi <cw00.choi@samsung.com>
6 * Krzysztof Kozlowski <k.kozlowski@samsung.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
19 #include <linux/kernel.h>
20 #include <linux/module.h>
21 #include <linux/i2c.h>
22 #include <linux/interrupt.h>
23 #include <linux/platform_device.h>
24 #include <linux/mfd/max14577.h>
25 #include <linux/mfd/max14577-private.h>
26 #include <linux/extcon.h>
28 #define DELAY_MS_DEFAULT 17000 /* unit: millisecond */
30 enum max14577_muic_adc_debounce_time
{
31 ADC_DEBOUNCE_TIME_5MS
= 0,
32 ADC_DEBOUNCE_TIME_10MS
,
33 ADC_DEBOUNCE_TIME_25MS
,
34 ADC_DEBOUNCE_TIME_38_62MS
,
37 enum max14577_muic_status
{
38 MAX14577_MUIC_STATUS1
= 0,
39 MAX14577_MUIC_STATUS2
= 1,
40 MAX14577_MUIC_STATUS_END
,
44 * struct max14577_muic_irq
45 * @irq: the index of irq list of MUIC device.
46 * @name: the name of irq.
47 * @virq: the virtual irq to use irq domain
49 struct max14577_muic_irq
{
55 static struct max14577_muic_irq max14577_muic_irqs
[] = {
56 { MAX14577_IRQ_INT1_ADC
, "muic-ADC" },
57 { MAX14577_IRQ_INT1_ADCLOW
, "muic-ADCLOW" },
58 { MAX14577_IRQ_INT1_ADCERR
, "muic-ADCError" },
59 { MAX14577_IRQ_INT2_CHGTYP
, "muic-CHGTYP" },
60 { MAX14577_IRQ_INT2_CHGDETRUN
, "muic-CHGDETRUN" },
61 { MAX14577_IRQ_INT2_DCDTMR
, "muic-DCDTMR" },
62 { MAX14577_IRQ_INT2_DBCHG
, "muic-DBCHG" },
63 { MAX14577_IRQ_INT2_VBVOLT
, "muic-VBVOLT" },
66 static struct max14577_muic_irq max77836_muic_irqs
[] = {
67 { MAX14577_IRQ_INT1_ADC
, "muic-ADC" },
68 { MAX14577_IRQ_INT1_ADCLOW
, "muic-ADCLOW" },
69 { MAX14577_IRQ_INT1_ADCERR
, "muic-ADCError" },
70 { MAX77836_IRQ_INT1_ADC1K
, "muic-ADC1K" },
71 { MAX14577_IRQ_INT2_CHGTYP
, "muic-CHGTYP" },
72 { MAX14577_IRQ_INT2_CHGDETRUN
, "muic-CHGDETRUN" },
73 { MAX14577_IRQ_INT2_DCDTMR
, "muic-DCDTMR" },
74 { MAX14577_IRQ_INT2_DBCHG
, "muic-DBCHG" },
75 { MAX14577_IRQ_INT2_VBVOLT
, "muic-VBVOLT" },
76 { MAX77836_IRQ_INT2_VIDRM
, "muic-VIDRM" },
79 struct max14577_muic_info
{
81 struct max14577
*max14577
;
82 struct extcon_dev
*edev
;
85 u8 status
[MAX14577_MUIC_STATUS_END
];
87 struct max14577_muic_irq
*muic_irqs
;
88 unsigned int muic_irqs_num
;
91 struct work_struct irq_work
;
95 * Use delayed workqueue to detect cable state and then
96 * notify cable state to notifiee/platform through uevent.
97 * After completing the booting of platform, the extcon provider
98 * driver should notify cable state to upper layer.
100 struct delayed_work wq_detcable
;
103 * Default usb/uart path whether UART/USB or AUX_UART/AUX_USB
104 * h/w path of COMP2/COMN1 on CONTROL1 register.
110 enum max14577_muic_cable_group
{
111 MAX14577_CABLE_GROUP_ADC
= 0,
112 MAX14577_CABLE_GROUP_CHG
,
115 /* Define supported accessory type */
116 enum max14577_muic_acc_type
{
117 MAX14577_MUIC_ADC_GROUND
= 0x0,
118 MAX14577_MUIC_ADC_SEND_END_BUTTON
,
119 MAX14577_MUIC_ADC_REMOTE_S1_BUTTON
,
120 MAX14577_MUIC_ADC_REMOTE_S2_BUTTON
,
121 MAX14577_MUIC_ADC_REMOTE_S3_BUTTON
,
122 MAX14577_MUIC_ADC_REMOTE_S4_BUTTON
,
123 MAX14577_MUIC_ADC_REMOTE_S5_BUTTON
,
124 MAX14577_MUIC_ADC_REMOTE_S6_BUTTON
,
125 MAX14577_MUIC_ADC_REMOTE_S7_BUTTON
,
126 MAX14577_MUIC_ADC_REMOTE_S8_BUTTON
,
127 MAX14577_MUIC_ADC_REMOTE_S9_BUTTON
,
128 MAX14577_MUIC_ADC_REMOTE_S10_BUTTON
,
129 MAX14577_MUIC_ADC_REMOTE_S11_BUTTON
,
130 MAX14577_MUIC_ADC_REMOTE_S12_BUTTON
,
131 MAX14577_MUIC_ADC_RESERVED_ACC_1
,
132 MAX14577_MUIC_ADC_RESERVED_ACC_2
,
133 MAX14577_MUIC_ADC_RESERVED_ACC_3
,
134 MAX14577_MUIC_ADC_RESERVED_ACC_4
,
135 MAX14577_MUIC_ADC_RESERVED_ACC_5
,
136 MAX14577_MUIC_ADC_AUDIO_DEVICE_TYPE2
,
137 MAX14577_MUIC_ADC_PHONE_POWERED_DEV
,
138 MAX14577_MUIC_ADC_TTY_CONVERTER
,
139 MAX14577_MUIC_ADC_UART_CABLE
,
140 MAX14577_MUIC_ADC_CEA936A_TYPE1_CHG
,
141 MAX14577_MUIC_ADC_FACTORY_MODE_USB_OFF
,
142 MAX14577_MUIC_ADC_FACTORY_MODE_USB_ON
,
143 MAX14577_MUIC_ADC_AV_CABLE_NOLOAD
,
144 MAX14577_MUIC_ADC_CEA936A_TYPE2_CHG
,
145 MAX14577_MUIC_ADC_FACTORY_MODE_UART_OFF
,
146 MAX14577_MUIC_ADC_FACTORY_MODE_UART_ON
,
147 MAX14577_MUIC_ADC_AUDIO_DEVICE_TYPE1
, /* with Remote and Simple Ctrl */
148 MAX14577_MUIC_ADC_OPEN
,
151 static const unsigned int max14577_extcon_cable
[] = {
162 * max14577_muic_set_debounce_time - Set the debounce time of ADC
163 * @info: the instance including private data of max14577 MUIC
164 * @time: the debounce time of ADC
166 static int max14577_muic_set_debounce_time(struct max14577_muic_info
*info
,
167 enum max14577_muic_adc_debounce_time time
)
172 case ADC_DEBOUNCE_TIME_5MS
:
173 case ADC_DEBOUNCE_TIME_10MS
:
174 case ADC_DEBOUNCE_TIME_25MS
:
175 case ADC_DEBOUNCE_TIME_38_62MS
:
176 ret
= max14577_update_reg(info
->max14577
->regmap
,
177 MAX14577_MUIC_REG_CONTROL3
,
179 time
<< CTRL3_ADCDBSET_SHIFT
);
181 dev_err(info
->dev
, "failed to set ADC debounce time\n");
186 dev_err(info
->dev
, "invalid ADC debounce time\n");
194 * max14577_muic_set_path - Set hardware line according to attached cable
195 * @info: the instance including private data of max14577 MUIC
196 * @value: the path according to attached cable
197 * @attached: the state of cable (true:attached, false:detached)
199 * The max14577 MUIC device share outside H/W line among a varity of cables
200 * so, this function set internal path of H/W line according to the type of
203 static int max14577_muic_set_path(struct max14577_muic_info
*info
,
204 u8 val
, bool attached
)
209 /* Set open state to path before changing hw path */
210 ret
= max14577_update_reg(info
->max14577
->regmap
,
211 MAX14577_MUIC_REG_CONTROL1
,
212 CLEAR_IDBEN_MICEN_MASK
, CTRL1_SW_OPEN
);
214 dev_err(info
->dev
, "failed to update MUIC register\n");
221 ctrl1
= CTRL1_SW_OPEN
;
223 ret
= max14577_update_reg(info
->max14577
->regmap
,
224 MAX14577_MUIC_REG_CONTROL1
,
225 CLEAR_IDBEN_MICEN_MASK
, ctrl1
);
227 dev_err(info
->dev
, "failed to update MUIC register\n");
232 ctrl2
|= CTRL2_CPEN_MASK
; /* LowPwr=0, CPEn=1 */
234 ctrl2
|= CTRL2_LOWPWR_MASK
; /* LowPwr=1, CPEn=0 */
236 ret
= max14577_update_reg(info
->max14577
->regmap
,
237 MAX14577_REG_CONTROL2
,
238 CTRL2_LOWPWR_MASK
| CTRL2_CPEN_MASK
, ctrl2
);
240 dev_err(info
->dev
, "failed to update MUIC register\n");
245 "CONTROL1 : 0x%02x, CONTROL2 : 0x%02x, state : %s\n",
246 ctrl1
, ctrl2
, attached
? "attached" : "detached");
252 * max14577_muic_get_cable_type - Return cable type and check cable state
253 * @info: the instance including private data of max14577 MUIC
254 * @group: the path according to attached cable
255 * @attached: store cable state and return
257 * This function check the cable state either attached or detached,
258 * and then divide precise type of cable according to cable group.
259 * - max14577_CABLE_GROUP_ADC
260 * - max14577_CABLE_GROUP_CHG
262 static int max14577_muic_get_cable_type(struct max14577_muic_info
*info
,
263 enum max14577_muic_cable_group group
, bool *attached
)
270 case MAX14577_CABLE_GROUP_ADC
:
272 * Read ADC value to check cable type and decide cable state
273 * according to cable type
275 adc
= info
->status
[MAX14577_MUIC_STATUS1
] & STATUS1_ADC_MASK
;
276 adc
>>= STATUS1_ADC_SHIFT
;
279 * Check current cable state/cable type and store cable type
280 * (info->prev_cable_type) for handling cable when cable is
283 if (adc
== MAX14577_MUIC_ADC_OPEN
) {
286 cable_type
= info
->prev_cable_type
;
287 info
->prev_cable_type
= MAX14577_MUIC_ADC_OPEN
;
291 cable_type
= info
->prev_cable_type
= adc
;
294 case MAX14577_CABLE_GROUP_CHG
:
296 * Read charger type to check cable type and decide cable state
297 * according to type of charger cable.
299 chg_type
= info
->status
[MAX14577_MUIC_STATUS2
] &
301 chg_type
>>= STATUS2_CHGTYP_SHIFT
;
303 if (chg_type
== MAX14577_CHARGER_TYPE_NONE
) {
306 cable_type
= info
->prev_chg_type
;
307 info
->prev_chg_type
= MAX14577_CHARGER_TYPE_NONE
;
312 * Check current cable state/cable type and store cable
313 * type(info->prev_chg_type) for handling cable when
314 * charger cable is detached.
316 cable_type
= info
->prev_chg_type
= chg_type
;
321 dev_err(info
->dev
, "Unknown cable group (%d)\n", group
);
322 cable_type
= -EINVAL
;
329 static int max14577_muic_jig_handler(struct max14577_muic_info
*info
,
330 int cable_type
, bool attached
)
333 u8 path
= CTRL1_SW_OPEN
;
336 "external connector is %s (adc:0x%02x)\n",
337 attached
? "attached" : "detached", cable_type
);
339 switch (cable_type
) {
340 case MAX14577_MUIC_ADC_FACTORY_MODE_USB_OFF
: /* ADC_JIG_USB_OFF */
341 case MAX14577_MUIC_ADC_FACTORY_MODE_USB_ON
: /* ADC_JIG_USB_ON */
345 case MAX14577_MUIC_ADC_FACTORY_MODE_UART_OFF
: /* ADC_JIG_UART_OFF */
347 path
= CTRL1_SW_UART
;
350 dev_err(info
->dev
, "failed to detect %s jig cable\n",
351 attached
? "attached" : "detached");
355 ret
= max14577_muic_set_path(info
, path
, attached
);
359 extcon_set_cable_state_(info
->edev
, EXTCON_JIG
, attached
);
364 static int max14577_muic_adc_handler(struct max14577_muic_info
*info
)
370 /* Check accessory state which is either detached or attached */
371 cable_type
= max14577_muic_get_cable_type(info
,
372 MAX14577_CABLE_GROUP_ADC
, &attached
);
375 "external connector is %s (adc:0x%02x, prev_adc:0x%x)\n",
376 attached
? "attached" : "detached", cable_type
,
377 info
->prev_cable_type
);
379 switch (cable_type
) {
380 case MAX14577_MUIC_ADC_FACTORY_MODE_USB_OFF
:
381 case MAX14577_MUIC_ADC_FACTORY_MODE_USB_ON
:
382 case MAX14577_MUIC_ADC_FACTORY_MODE_UART_OFF
:
384 ret
= max14577_muic_jig_handler(info
, cable_type
, attached
);
388 case MAX14577_MUIC_ADC_GROUND
:
389 case MAX14577_MUIC_ADC_SEND_END_BUTTON
:
390 case MAX14577_MUIC_ADC_REMOTE_S1_BUTTON
:
391 case MAX14577_MUIC_ADC_REMOTE_S2_BUTTON
:
392 case MAX14577_MUIC_ADC_REMOTE_S3_BUTTON
:
393 case MAX14577_MUIC_ADC_REMOTE_S4_BUTTON
:
394 case MAX14577_MUIC_ADC_REMOTE_S5_BUTTON
:
395 case MAX14577_MUIC_ADC_REMOTE_S6_BUTTON
:
396 case MAX14577_MUIC_ADC_REMOTE_S7_BUTTON
:
397 case MAX14577_MUIC_ADC_REMOTE_S8_BUTTON
:
398 case MAX14577_MUIC_ADC_REMOTE_S9_BUTTON
:
399 case MAX14577_MUIC_ADC_REMOTE_S10_BUTTON
:
400 case MAX14577_MUIC_ADC_REMOTE_S11_BUTTON
:
401 case MAX14577_MUIC_ADC_REMOTE_S12_BUTTON
:
402 case MAX14577_MUIC_ADC_RESERVED_ACC_1
:
403 case MAX14577_MUIC_ADC_RESERVED_ACC_2
:
404 case MAX14577_MUIC_ADC_RESERVED_ACC_3
:
405 case MAX14577_MUIC_ADC_RESERVED_ACC_4
:
406 case MAX14577_MUIC_ADC_RESERVED_ACC_5
:
407 case MAX14577_MUIC_ADC_AUDIO_DEVICE_TYPE2
:
408 case MAX14577_MUIC_ADC_PHONE_POWERED_DEV
:
409 case MAX14577_MUIC_ADC_TTY_CONVERTER
:
410 case MAX14577_MUIC_ADC_UART_CABLE
:
411 case MAX14577_MUIC_ADC_CEA936A_TYPE1_CHG
:
412 case MAX14577_MUIC_ADC_AV_CABLE_NOLOAD
:
413 case MAX14577_MUIC_ADC_CEA936A_TYPE2_CHG
:
414 case MAX14577_MUIC_ADC_FACTORY_MODE_UART_ON
:
415 case MAX14577_MUIC_ADC_AUDIO_DEVICE_TYPE1
:
417 * This accessory isn't used in general case if it is specially
418 * needed to detect additional accessory, should implement
419 * proper operation when this accessory is attached/detached.
422 "accessory is %s but it isn't used (adc:0x%x)\n",
423 attached
? "attached" : "detached", cable_type
);
427 "failed to detect %s accessory (adc:0x%x)\n",
428 attached
? "attached" : "detached", cable_type
);
435 static int max14577_muic_chg_handler(struct max14577_muic_info
*info
)
441 chg_type
= max14577_muic_get_cable_type(info
,
442 MAX14577_CABLE_GROUP_CHG
, &attached
);
445 "external connector is %s(chg_type:0x%x, prev_chg_type:0x%x)\n",
446 attached
? "attached" : "detached",
447 chg_type
, info
->prev_chg_type
);
450 case MAX14577_CHARGER_TYPE_USB
:
452 ret
= max14577_muic_set_path(info
, info
->path_usb
, attached
);
456 extcon_set_cable_state_(info
->edev
, EXTCON_USB
, attached
);
458 case MAX14577_CHARGER_TYPE_DEDICATED_CHG
:
459 extcon_set_cable_state_(info
->edev
, EXTCON_CHG_USB_DCP
,
462 case MAX14577_CHARGER_TYPE_DOWNSTREAM_PORT
:
463 extcon_set_cable_state_(info
->edev
, EXTCON_CHG_USB_CDP
,
466 case MAX14577_CHARGER_TYPE_SPECIAL_500MA
:
467 extcon_set_cable_state_(info
->edev
, EXTCON_CHG_USB_SLOW
,
470 case MAX14577_CHARGER_TYPE_SPECIAL_1A
:
471 extcon_set_cable_state_(info
->edev
, EXTCON_CHG_USB_FAST
,
474 case MAX14577_CHARGER_TYPE_NONE
:
475 case MAX14577_CHARGER_TYPE_DEAD_BATTERY
:
479 "failed to detect %s accessory (chg_type:0x%x)\n",
480 attached
? "attached" : "detached", chg_type
);
487 static void max14577_muic_irq_work(struct work_struct
*work
)
489 struct max14577_muic_info
*info
= container_of(work
,
490 struct max14577_muic_info
, irq_work
);
496 mutex_lock(&info
->mutex
);
498 ret
= max14577_bulk_read(info
->max14577
->regmap
,
499 MAX14577_MUIC_REG_STATUS1
, info
->status
, 2);
501 dev_err(info
->dev
, "failed to read MUIC register\n");
502 mutex_unlock(&info
->mutex
);
507 ret
= max14577_muic_adc_handler(info
);
508 info
->irq_adc
= false;
511 ret
= max14577_muic_chg_handler(info
);
512 info
->irq_chg
= false;
516 dev_err(info
->dev
, "failed to handle MUIC interrupt\n");
518 mutex_unlock(&info
->mutex
);
522 * Sets irq_adc or irq_chg in max14577_muic_info and returns 1.
523 * Returns 0 if irq_type does not match registered IRQ for this device type.
525 static int max14577_parse_irq(struct max14577_muic_info
*info
, int irq_type
)
528 case MAX14577_IRQ_INT1_ADC
:
529 case MAX14577_IRQ_INT1_ADCLOW
:
530 case MAX14577_IRQ_INT1_ADCERR
:
531 /* Handle all of accessory except for
532 type of charger accessory */
533 info
->irq_adc
= true;
535 case MAX14577_IRQ_INT2_CHGTYP
:
536 case MAX14577_IRQ_INT2_CHGDETRUN
:
537 case MAX14577_IRQ_INT2_DCDTMR
:
538 case MAX14577_IRQ_INT2_DBCHG
:
539 case MAX14577_IRQ_INT2_VBVOLT
:
540 /* Handle charger accessory */
541 info
->irq_chg
= true;
549 * Sets irq_adc or irq_chg in max14577_muic_info and returns 1.
550 * Returns 0 if irq_type does not match registered IRQ for this device type.
552 static int max77836_parse_irq(struct max14577_muic_info
*info
, int irq_type
)
554 /* First check common max14577 interrupts */
555 if (max14577_parse_irq(info
, irq_type
))
559 case MAX77836_IRQ_INT1_ADC1K
:
560 info
->irq_adc
= true;
562 case MAX77836_IRQ_INT2_VIDRM
:
563 /* Handle charger accessory */
564 info
->irq_chg
= true;
571 static irqreturn_t
max14577_muic_irq_handler(int irq
, void *data
)
573 struct max14577_muic_info
*info
= data
;
574 int i
, irq_type
= -1;
578 * We may be called multiple times for different nested IRQ-s.
579 * Including changes in INT1_ADC and INT2_CGHTYP at once.
580 * However we only need to know whether it was ADC, charger
581 * or both interrupts so decode IRQ and turn on proper flags.
583 for (i
= 0; i
< info
->muic_irqs_num
; i
++)
584 if (irq
== info
->muic_irqs
[i
].virq
)
585 irq_type
= info
->muic_irqs
[i
].irq
;
587 switch (info
->max14577
->dev_type
) {
588 case MAXIM_DEVICE_TYPE_MAX77836
:
589 irq_parsed
= max77836_parse_irq(info
, irq_type
);
591 case MAXIM_DEVICE_TYPE_MAX14577
:
593 irq_parsed
= max14577_parse_irq(info
, irq_type
);
598 dev_err(info
->dev
, "muic interrupt: irq %d occurred, skipped\n",
602 schedule_work(&info
->irq_work
);
607 static int max14577_muic_detect_accessory(struct max14577_muic_info
*info
)
614 mutex_lock(&info
->mutex
);
616 /* Read STATUSx register to detect accessory */
617 ret
= max14577_bulk_read(info
->max14577
->regmap
,
618 MAX14577_MUIC_REG_STATUS1
, info
->status
, 2);
620 dev_err(info
->dev
, "failed to read MUIC register\n");
621 mutex_unlock(&info
->mutex
);
625 adc
= max14577_muic_get_cable_type(info
, MAX14577_CABLE_GROUP_ADC
,
627 if (attached
&& adc
!= MAX14577_MUIC_ADC_OPEN
) {
628 ret
= max14577_muic_adc_handler(info
);
630 dev_err(info
->dev
, "Cannot detect accessory\n");
631 mutex_unlock(&info
->mutex
);
636 chg_type
= max14577_muic_get_cable_type(info
, MAX14577_CABLE_GROUP_CHG
,
638 if (attached
&& chg_type
!= MAX14577_CHARGER_TYPE_NONE
) {
639 ret
= max14577_muic_chg_handler(info
);
641 dev_err(info
->dev
, "Cannot detect charger accessory\n");
642 mutex_unlock(&info
->mutex
);
647 mutex_unlock(&info
->mutex
);
652 static void max14577_muic_detect_cable_wq(struct work_struct
*work
)
654 struct max14577_muic_info
*info
= container_of(to_delayed_work(work
),
655 struct max14577_muic_info
, wq_detcable
);
657 max14577_muic_detect_accessory(info
);
660 static int max14577_muic_probe(struct platform_device
*pdev
)
662 struct max14577
*max14577
= dev_get_drvdata(pdev
->dev
.parent
);
663 struct max14577_muic_info
*info
;
669 info
= devm_kzalloc(&pdev
->dev
, sizeof(*info
), GFP_KERNEL
);
673 info
->dev
= &pdev
->dev
;
674 info
->max14577
= max14577
;
676 platform_set_drvdata(pdev
, info
);
677 mutex_init(&info
->mutex
);
679 INIT_WORK(&info
->irq_work
, max14577_muic_irq_work
);
681 switch (max14577
->dev_type
) {
682 case MAXIM_DEVICE_TYPE_MAX77836
:
683 info
->muic_irqs
= max77836_muic_irqs
;
684 info
->muic_irqs_num
= ARRAY_SIZE(max77836_muic_irqs
);
686 case MAXIM_DEVICE_TYPE_MAX14577
:
688 info
->muic_irqs
= max14577_muic_irqs
;
689 info
->muic_irqs_num
= ARRAY_SIZE(max14577_muic_irqs
);
692 /* Support irq domain for max14577 MUIC device */
693 for (i
= 0; i
< info
->muic_irqs_num
; i
++) {
694 struct max14577_muic_irq
*muic_irq
= &info
->muic_irqs
[i
];
695 unsigned int virq
= 0;
697 virq
= regmap_irq_get_virq(max14577
->irq_data
, muic_irq
->irq
);
700 muic_irq
->virq
= virq
;
702 ret
= devm_request_threaded_irq(&pdev
->dev
, virq
, NULL
,
703 max14577_muic_irq_handler
,
705 muic_irq
->name
, info
);
708 "failed: irq request (IRQ: %d, error :%d)\n",
714 /* Initialize extcon device */
715 info
->edev
= devm_extcon_dev_allocate(&pdev
->dev
,
716 max14577_extcon_cable
);
717 if (IS_ERR(info
->edev
)) {
718 dev_err(&pdev
->dev
, "failed to allocate memory for extcon\n");
722 ret
= devm_extcon_dev_register(&pdev
->dev
, info
->edev
);
724 dev_err(&pdev
->dev
, "failed to register extcon device\n");
728 /* Default h/w line path */
729 info
->path_usb
= CTRL1_SW_USB
;
730 info
->path_uart
= CTRL1_SW_UART
;
731 delay_jiffies
= msecs_to_jiffies(DELAY_MS_DEFAULT
);
733 /* Set initial path for UART */
734 max14577_muic_set_path(info
, info
->path_uart
, true);
736 /* Check revision number of MUIC device*/
737 ret
= max14577_read_reg(info
->max14577
->regmap
,
738 MAX14577_REG_DEVICEID
, &id
);
740 dev_err(&pdev
->dev
, "failed to read revision number\n");
743 dev_info(info
->dev
, "device ID : 0x%x\n", id
);
745 /* Set ADC debounce time */
746 max14577_muic_set_debounce_time(info
, ADC_DEBOUNCE_TIME_25MS
);
749 * Detect accessory after completing the initialization of platform
751 * - Use delayed workqueue to detect cable state and then
752 * notify cable state to notifiee/platform through uevent.
753 * After completing the booting of platform, the extcon provider
754 * driver should notify cable state to upper layer.
756 INIT_DELAYED_WORK(&info
->wq_detcable
, max14577_muic_detect_cable_wq
);
757 queue_delayed_work(system_power_efficient_wq
, &info
->wq_detcable
,
763 static int max14577_muic_remove(struct platform_device
*pdev
)
765 struct max14577_muic_info
*info
= platform_get_drvdata(pdev
);
767 cancel_work_sync(&info
->irq_work
);
772 static const struct platform_device_id max14577_muic_id
[] = {
773 { "max14577-muic", MAXIM_DEVICE_TYPE_MAX14577
, },
774 { "max77836-muic", MAXIM_DEVICE_TYPE_MAX77836
, },
777 MODULE_DEVICE_TABLE(platform
, max14577_muic_id
);
779 static struct platform_driver max14577_muic_driver
= {
781 .name
= "max14577-muic",
783 .probe
= max14577_muic_probe
,
784 .remove
= max14577_muic_remove
,
785 .id_table
= max14577_muic_id
,
788 module_platform_driver(max14577_muic_driver
);
790 MODULE_DESCRIPTION("Maxim 14577/77836 Extcon driver");
791 MODULE_AUTHOR("Chanwoo Choi <cw00.choi@samsung.com>, Krzysztof Kozlowski <k.kozlowski@samsung.com>");
792 MODULE_LICENSE("GPL");
793 MODULE_ALIAS("platform:extcon-max14577");