Version:  2.0.40 2.2.26 2.4.37 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4

Linux/drivers/extcon/extcon-max77693.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us