drivers/extcon/extcon-max77693.c

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

DEFINITIONS
