linux/drivers/extcon/extcon-max77693.c
<<
>>
Prefs
   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 */
  41static 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
  67enum 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
  74struct 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
 107enum 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
 114enum 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 */
 130struct max77693_muic_irq {
 131        unsigned int irq;
 132        const char *name;
 133        unsigned int virq;
 134};
 135
 136static 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 */
 156enum 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) */
 200enum {
 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
 220static 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 */
 245static 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 */
 282static 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 */
 333static 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
 474static 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
 551out:
 552        return 0;
 553}
 554
 555static 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
 598static 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
 638static 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
 680static 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
 788static 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
 944static 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
1008static 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
1018static struct regmap_config max77693_muic_regmap_config = {
1019        .reg_bits = 8,
1020        .val_bits = 8,
1021};
1022
1023static 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
1068static 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
1076static 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
1276err_extcon:
1277        extcon_dev_unregister(info->edev);
1278err_irq:
1279        while (--i >= 0)
1280                free_irq(muic_irqs[i].virq, info);
1281        return ret;
1282}
1283
1284static 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
1298static 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
1307module_platform_driver(max77693_muic_driver);
1308
1309MODULE_DESCRIPTION("Maxim MAX77693 Extcon driver");
1310MODULE_AUTHOR("Chanwoo Choi <cw00.choi@samsung.com>");
1311MODULE_LICENSE("GPL");
1312MODULE_ALIAS("platform:extcon-max77693");
1313
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.