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-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->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->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");