drivers/extcon/extcon-max14577.c

   1 /*
   2  * extcon-max14577.c - MAX14577/77836 extcon driver to support MUIC
   3  *
   4  * Copyright (C) 2013,2014 Samsung Electronics
   5  * Chanwoo Choi <cw00.choi@samsung.com>
   6  * Krzysztof Kozlowski <krzk@kernel.org>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  */
  18
  19 #include <linux/kernel.h>
  20 #include <linux/module.h>
  21 #include <linux/i2c.h>
  22 #include <linux/interrupt.h>
  23 #include <linux/platform_device.h>
  24 #include <linux/mfd/max14577.h>
  25 #include <linux/mfd/max14577-private.h>
  26 #include <linux/extcon.h>
  27
  28 #define DELAY_MS_DEFAULT                17000           /* unit: millisecond */
  29
  30 enum max14577_muic_adc_debounce_time {
  31         ADC_DEBOUNCE_TIME_5MS = 0,
  32         ADC_DEBOUNCE_TIME_10MS,
  33         ADC_DEBOUNCE_TIME_25MS,
  34         ADC_DEBOUNCE_TIME_38_62MS,
  35 };
  36
  37 enum max14577_muic_status {
  38         MAX14577_MUIC_STATUS1 = 0,
  39         MAX14577_MUIC_STATUS2 = 1,
  40         MAX14577_MUIC_STATUS_END,
  41 };
  42
  43 /**
  44  * struct max14577_muic_irq
  45  * @irq: the index of irq list of MUIC device.
  46  * @name: the name of irq.
  47  * @virq: the virtual irq to use irq domain
  48  */
  49 struct max14577_muic_irq {
  50         unsigned int irq;
  51         const char *name;
  52         unsigned int virq;
  53 };
  54
  55 static struct max14577_muic_irq max14577_muic_irqs[] = {
  56         { MAX14577_IRQ_INT1_ADC,        "muic-ADC" },
  57         { MAX14577_IRQ_INT1_ADCLOW,     "muic-ADCLOW" },
  58         { MAX14577_IRQ_INT1_ADCERR,     "muic-ADCError" },
  59         { MAX14577_IRQ_INT2_CHGTYP,     "muic-CHGTYP" },
  60         { MAX14577_IRQ_INT2_CHGDETRUN,  "muic-CHGDETRUN" },
  61         { MAX14577_IRQ_INT2_DCDTMR,     "muic-DCDTMR" },
  62         { MAX14577_IRQ_INT2_DBCHG,      "muic-DBCHG" },
  63         { MAX14577_IRQ_INT2_VBVOLT,     "muic-VBVOLT" },
  64 };
  65
  66 static struct max14577_muic_irq max77836_muic_irqs[] = {
  67         { MAX14577_IRQ_INT1_ADC,        "muic-ADC" },
  68         { MAX14577_IRQ_INT1_ADCLOW,     "muic-ADCLOW" },
  69         { MAX14577_IRQ_INT1_ADCERR,     "muic-ADCError" },
  70         { MAX77836_IRQ_INT1_ADC1K,      "muic-ADC1K" },
  71         { MAX14577_IRQ_INT2_CHGTYP,     "muic-CHGTYP" },
  72         { MAX14577_IRQ_INT2_CHGDETRUN,  "muic-CHGDETRUN" },
  73         { MAX14577_IRQ_INT2_DCDTMR,     "muic-DCDTMR" },
  74         { MAX14577_IRQ_INT2_DBCHG,      "muic-DBCHG" },
  75         { MAX14577_IRQ_INT2_VBVOLT,     "muic-VBVOLT" },
  76         { MAX77836_IRQ_INT2_VIDRM,      "muic-VIDRM" },
  77 };
  78
  79 struct max14577_muic_info {
  80         struct device *dev;
  81         struct max14577 *max14577;
  82         struct extcon_dev *edev;
  83         int prev_cable_type;
  84         int prev_chg_type;
  85         u8 status[MAX14577_MUIC_STATUS_END];
  86
  87         struct max14577_muic_irq *muic_irqs;
  88         unsigned int muic_irqs_num;
  89         bool irq_adc;
  90         bool irq_chg;
  91         struct work_struct irq_work;
  92         struct mutex mutex;
  93
  94         /*
  95          * Use delayed workqueue to detect cable state and then
  96          * notify cable state to notifiee/platform through uevent.
  97          * After completing the booting of platform, the extcon provider
  98          * driver should notify cable state to upper layer.
  99          */
 100         struct delayed_work wq_detcable;
 101
 102         /*
 103          * Default usb/uart path whether UART/USB or AUX_UART/AUX_USB
 104          * h/w path of COMP2/COMN1 on CONTROL1 register.
 105          */
 106         int path_usb;
 107         int path_uart;
 108 };
 109
 110 enum max14577_muic_cable_group {
 111         MAX14577_CABLE_GROUP_ADC = 0,
 112         MAX14577_CABLE_GROUP_CHG,
 113 };
 114
 115 /* Define supported accessory type */
 116 enum max14577_muic_acc_type {
 117         MAX14577_MUIC_ADC_GROUND = 0x0,
 118         MAX14577_MUIC_ADC_SEND_END_BUTTON,
 119         MAX14577_MUIC_ADC_REMOTE_S1_BUTTON,
 120         MAX14577_MUIC_ADC_REMOTE_S2_BUTTON,
 121         MAX14577_MUIC_ADC_REMOTE_S3_BUTTON,
 122         MAX14577_MUIC_ADC_REMOTE_S4_BUTTON,
 123         MAX14577_MUIC_ADC_REMOTE_S5_BUTTON,
 124         MAX14577_MUIC_ADC_REMOTE_S6_BUTTON,
 125         MAX14577_MUIC_ADC_REMOTE_S7_BUTTON,
 126         MAX14577_MUIC_ADC_REMOTE_S8_BUTTON,
 127         MAX14577_MUIC_ADC_REMOTE_S9_BUTTON,
 128         MAX14577_MUIC_ADC_REMOTE_S10_BUTTON,
 129         MAX14577_MUIC_ADC_REMOTE_S11_BUTTON,
 130         MAX14577_MUIC_ADC_REMOTE_S12_BUTTON,
 131         MAX14577_MUIC_ADC_RESERVED_ACC_1,
 132         MAX14577_MUIC_ADC_RESERVED_ACC_2,
 133         MAX14577_MUIC_ADC_RESERVED_ACC_3,
 134         MAX14577_MUIC_ADC_RESERVED_ACC_4,
 135         MAX14577_MUIC_ADC_RESERVED_ACC_5,
 136         MAX14577_MUIC_ADC_AUDIO_DEVICE_TYPE2,
 137         MAX14577_MUIC_ADC_PHONE_POWERED_DEV,
 138         MAX14577_MUIC_ADC_TTY_CONVERTER,
 139         MAX14577_MUIC_ADC_UART_CABLE,
 140         MAX14577_MUIC_ADC_CEA936A_TYPE1_CHG,
 141         MAX14577_MUIC_ADC_FACTORY_MODE_USB_OFF,
 142         MAX14577_MUIC_ADC_FACTORY_MODE_USB_ON,
 143         MAX14577_MUIC_ADC_AV_CABLE_NOLOAD,
 144         MAX14577_MUIC_ADC_CEA936A_TYPE2_CHG,
 145         MAX14577_MUIC_ADC_FACTORY_MODE_UART_OFF,
 146         MAX14577_MUIC_ADC_FACTORY_MODE_UART_ON,
 147         MAX14577_MUIC_ADC_AUDIO_DEVICE_TYPE1, /* with Remote and Simple Ctrl */
 148         MAX14577_MUIC_ADC_OPEN,
 149 };
 150
 151 static const unsigned int max14577_extcon_cable[] = {
 152         EXTCON_USB,
 153         EXTCON_CHG_USB_SDP,
 154         EXTCON_CHG_USB_DCP,
 155         EXTCON_CHG_USB_FAST,
 156         EXTCON_CHG_USB_SLOW,
 157         EXTCON_CHG_USB_CDP,
 158         EXTCON_JIG,
 159         EXTCON_NONE,
 160 };
 161
 162 /*
 163  * max14577_muic_set_debounce_time - Set the debounce time of ADC
 164  * @info: the instance including private data of max14577 MUIC
 165  * @time: the debounce time of ADC
 166  */
 167 static int max14577_muic_set_debounce_time(struct max14577_muic_info *info,
 168                 enum max14577_muic_adc_debounce_time time)
 169 {
 170         u8 ret;
 171
 172         switch (time) {
 173         case ADC_DEBOUNCE_TIME_5MS:
 174         case ADC_DEBOUNCE_TIME_10MS:
 175         case ADC_DEBOUNCE_TIME_25MS:
 176         case ADC_DEBOUNCE_TIME_38_62MS:
 177                 ret = max14577_update_reg(info->max14577->regmap,
 178                                           MAX14577_MUIC_REG_CONTROL3,
 179                                           CTRL3_ADCDBSET_MASK,
 180                                           time << CTRL3_ADCDBSET_SHIFT);
 181                 if (ret) {
 182                         dev_err(info->dev, "failed to set ADC debounce time\n");
 183                         return ret;
 184                 }
 185                 break;
 186         default:
 187                 dev_err(info->dev, "invalid ADC debounce time\n");
 188                 return -EINVAL;
 189         }
 190
 191         return 0;
 192 };
 193
 194 /*
 195  * max14577_muic_set_path - Set hardware line according to attached cable
 196  * @info: the instance including private data of max14577 MUIC
 197  * @value: the path according to attached cable
 198  * @attached: the state of cable (true:attached, false:detached)
 199  *
 200  * The max14577 MUIC device share outside H/W line among a varity of cables
 201  * so, this function set internal path of H/W line according to the type of
 202  * attached cable.
 203  */
 204 static int max14577_muic_set_path(struct max14577_muic_info *info,
 205                 u8 val, bool attached)
 206 {
 207         int ret = 0;
 208         u8 ctrl1, ctrl2 = 0;
 209
 210         /* Set open state to path before changing hw path */
 211         ret = max14577_update_reg(info->max14577->regmap,
 212                                 MAX14577_MUIC_REG_CONTROL1,
 213                                 CLEAR_IDBEN_MICEN_MASK, CTRL1_SW_OPEN);
 214         if (ret < 0) {
 215                 dev_err(info->dev, "failed to update MUIC register\n");
 216                 return ret;
 217         }
 218
 219         if (attached)
 220                 ctrl1 = val;
 221         else
 222                 ctrl1 = CTRL1_SW_OPEN;
 223
 224         ret = max14577_update_reg(info->max14577->regmap,
 225                                 MAX14577_MUIC_REG_CONTROL1,
 226                                 CLEAR_IDBEN_MICEN_MASK, ctrl1);
 227         if (ret < 0) {
 228                 dev_err(info->dev, "failed to update MUIC register\n");
 229                 return ret;
 230         }
 231
 232         if (attached)
 233                 ctrl2 |= CTRL2_CPEN_MASK;       /* LowPwr=0, CPEn=1 */
 234         else
 235                 ctrl2 |= CTRL2_LOWPWR_MASK;     /* LowPwr=1, CPEn=0 */
 236
 237         ret = max14577_update_reg(info->max14577->regmap,
 238                         MAX14577_REG_CONTROL2,
 239                         CTRL2_LOWPWR_MASK | CTRL2_CPEN_MASK, ctrl2);
 240         if (ret < 0) {
 241                 dev_err(info->dev, "failed to update MUIC register\n");
 242                 return ret;
 243         }
 244
 245         dev_dbg(info->dev,
 246                 "CONTROL1 : 0x%02x, CONTROL2 : 0x%02x, state : %s\n",
 247                 ctrl1, ctrl2, attached ? "attached" : "detached");
 248
 249         return 0;
 250 }
 251
 252 /*
 253  * max14577_muic_get_cable_type - Return cable type and check cable state
 254  * @info: the instance including private data of max14577 MUIC
 255  * @group: the path according to attached cable
 256  * @attached: store cable state and return
 257  *
 258  * This function check the cable state either attached or detached,
 259  * and then divide precise type of cable according to cable group.
 260  *      - max14577_CABLE_GROUP_ADC
 261  *      - max14577_CABLE_GROUP_CHG
 262  */
 263 static int max14577_muic_get_cable_type(struct max14577_muic_info *info,
 264                 enum max14577_muic_cable_group group, bool *attached)
 265 {
 266         int cable_type = 0;
 267         int adc;
 268         int chg_type;
 269
 270         switch (group) {
 271         case MAX14577_CABLE_GROUP_ADC:
 272                 /*
 273                  * Read ADC value to check cable type and decide cable state
 274                  * according to cable type
 275                  */
 276                 adc = info->status[MAX14577_MUIC_STATUS1] & STATUS1_ADC_MASK;
 277                 adc >>= STATUS1_ADC_SHIFT;
 278
 279                 /*
 280                  * Check current cable state/cable type and store cable type
 281                  * (info->prev_cable_type) for handling cable when cable is
 282                  * detached.
 283                  */
 284                 if (adc == MAX14577_MUIC_ADC_OPEN) {
 285                         *attached = false;
 286
 287                         cable_type = info->prev_cable_type;
 288                         info->prev_cable_type = MAX14577_MUIC_ADC_OPEN;
 289                 } else {
 290                         *attached = true;
 291
 292                         cable_type = info->prev_cable_type = adc;
 293                 }
 294                 break;
 295         case MAX14577_CABLE_GROUP_CHG:
 296                 /*
 297                  * Read charger type to check cable type and decide cable state
 298                  * according to type of charger cable.
 299                  */
 300                 chg_type = info->status[MAX14577_MUIC_STATUS2] &
 301                         STATUS2_CHGTYP_MASK;
 302                 chg_type >>= STATUS2_CHGTYP_SHIFT;
 303
 304                 if (chg_type == MAX14577_CHARGER_TYPE_NONE) {
 305                         *attached = false;
 306
 307                         cable_type = info->prev_chg_type;
 308                         info->prev_chg_type = MAX14577_CHARGER_TYPE_NONE;
 309                 } else {
 310                         *attached = true;
 311
 312                         /*
 313                          * Check current cable state/cable type and store cable
 314                          * type(info->prev_chg_type) for handling cable when
 315                          * charger cable is detached.
 316                          */
 317                         cable_type = info->prev_chg_type = chg_type;
 318                 }
 319
 320                 break;
 321         default:
 322                 dev_err(info->dev, "Unknown cable group (%d)\n", group);
 323                 cable_type = -EINVAL;
 324                 break;
 325         }
 326
 327         return cable_type;
 328 }
 329
 330 static int max14577_muic_jig_handler(struct max14577_muic_info *info,
 331                 int cable_type, bool attached)
 332 {
 333         int ret = 0;
 334         u8 path = CTRL1_SW_OPEN;
 335
 336         dev_dbg(info->dev,
 337                 "external connector is %s (adc:0x%02x)\n",
 338                 attached ? "attached" : "detached", cable_type);
 339
 340         switch (cable_type) {
 341         case MAX14577_MUIC_ADC_FACTORY_MODE_USB_OFF:    /* ADC_JIG_USB_OFF */
 342         case MAX14577_MUIC_ADC_FACTORY_MODE_USB_ON:     /* ADC_JIG_USB_ON */
 343                 /* PATH:AP_USB */
 344                 path = CTRL1_SW_USB;
 345                 break;
 346         case MAX14577_MUIC_ADC_FACTORY_MODE_UART_OFF:   /* ADC_JIG_UART_OFF */
 347                 /* PATH:AP_UART */
 348                 path = CTRL1_SW_UART;
 349                 break;
 350         default:
 351                 dev_err(info->dev, "failed to detect %s jig cable\n",
 352                         attached ? "attached" : "detached");
 353                 return -EINVAL;
 354         }
 355
 356         ret = max14577_muic_set_path(info, path, attached);
 357         if (ret < 0)
 358                 return ret;
 359
 360         extcon_set_state_sync(info->edev, EXTCON_JIG, attached);
 361
 362         return 0;
 363 }
 364
 365 static int max14577_muic_adc_handler(struct max14577_muic_info *info)
 366 {
 367         int cable_type;
 368         bool attached;
 369         int ret = 0;
 370
 371         /* Check accessory state which is either detached or attached */
 372         cable_type = max14577_muic_get_cable_type(info,
 373                                 MAX14577_CABLE_GROUP_ADC, &attached);
 374
 375         dev_dbg(info->dev,
 376                 "external connector is %s (adc:0x%02x, prev_adc:0x%x)\n",
 377                 attached ? "attached" : "detached", cable_type,
 378                 info->prev_cable_type);
 379
 380         switch (cable_type) {
 381         case MAX14577_MUIC_ADC_FACTORY_MODE_USB_OFF:
 382         case MAX14577_MUIC_ADC_FACTORY_MODE_USB_ON:
 383         case MAX14577_MUIC_ADC_FACTORY_MODE_UART_OFF:
 384                 /* JIG */
 385                 ret = max14577_muic_jig_handler(info, cable_type, attached);
 386                 if (ret < 0)
 387                         return ret;
 388                 break;
 389         case MAX14577_MUIC_ADC_GROUND:
 390         case MAX14577_MUIC_ADC_SEND_END_BUTTON:
 391         case MAX14577_MUIC_ADC_REMOTE_S1_BUTTON:
 392         case MAX14577_MUIC_ADC_REMOTE_S2_BUTTON:
 393         case MAX14577_MUIC_ADC_REMOTE_S3_BUTTON:
 394         case MAX14577_MUIC_ADC_REMOTE_S4_BUTTON:
 395         case MAX14577_MUIC_ADC_REMOTE_S5_BUTTON:
 396         case MAX14577_MUIC_ADC_REMOTE_S6_BUTTON:
 397         case MAX14577_MUIC_ADC_REMOTE_S7_BUTTON:
 398         case MAX14577_MUIC_ADC_REMOTE_S8_BUTTON:
 399         case MAX14577_MUIC_ADC_REMOTE_S9_BUTTON:
 400         case MAX14577_MUIC_ADC_REMOTE_S10_BUTTON:
 401         case MAX14577_MUIC_ADC_REMOTE_S11_BUTTON:
 402         case MAX14577_MUIC_ADC_REMOTE_S12_BUTTON:
 403         case MAX14577_MUIC_ADC_RESERVED_ACC_1:
 404         case MAX14577_MUIC_ADC_RESERVED_ACC_2:
 405         case MAX14577_MUIC_ADC_RESERVED_ACC_3:
 406         case MAX14577_MUIC_ADC_RESERVED_ACC_4:
 407         case MAX14577_MUIC_ADC_RESERVED_ACC_5:
 408         case MAX14577_MUIC_ADC_AUDIO_DEVICE_TYPE2:
 409         case MAX14577_MUIC_ADC_PHONE_POWERED_DEV:
 410         case MAX14577_MUIC_ADC_TTY_CONVERTER:
 411         case MAX14577_MUIC_ADC_UART_CABLE:
 412         case MAX14577_MUIC_ADC_CEA936A_TYPE1_CHG:
 413         case MAX14577_MUIC_ADC_AV_CABLE_NOLOAD:
 414         case MAX14577_MUIC_ADC_CEA936A_TYPE2_CHG:
 415         case MAX14577_MUIC_ADC_FACTORY_MODE_UART_ON:
 416         case MAX14577_MUIC_ADC_AUDIO_DEVICE_TYPE1:
 417                 /*
 418                  * This accessory isn't used in general case if it is specially
 419                  * needed to detect additional accessory, should implement
 420                  * proper operation when this accessory is attached/detached.
 421                  */
 422                 dev_info(info->dev,
 423                         "accessory is %s but it isn't used (adc:0x%x)\n",
 424                         attached ? "attached" : "detached", cable_type);
 425                 return -EAGAIN;
 426         default:
 427                 dev_err(info->dev,
 428                         "failed to detect %s accessory (adc:0x%x)\n",
 429                         attached ? "attached" : "detached", cable_type);
 430                 return -EINVAL;
 431         }
 432
 433         return 0;
 434 }
 435
 436 static int max14577_muic_chg_handler(struct max14577_muic_info *info)
 437 {
 438         int chg_type;
 439         bool attached;
 440         int ret = 0;
 441
 442         chg_type = max14577_muic_get_cable_type(info,
 443                                 MAX14577_CABLE_GROUP_CHG, &attached);
 444
 445         dev_dbg(info->dev,
 446                 "external connector is %s(chg_type:0x%x, prev_chg_type:0x%x)\n",
 447                         attached ? "attached" : "detached",
 448                         chg_type, info->prev_chg_type);
 449
 450         switch (chg_type) {
 451         case MAX14577_CHARGER_TYPE_USB:
 452                 /* PATH:AP_USB */
 453                 ret = max14577_muic_set_path(info, info->path_usb, attached);
 454                 if (ret < 0)
 455                         return ret;
 456
 457                 extcon_set_state_sync(info->edev, EXTCON_USB, attached);
 458                 extcon_set_state_sync(info->edev, EXTCON_CHG_USB_SDP,
 459                                         attached);
 460                 break;
 461         case MAX14577_CHARGER_TYPE_DEDICATED_CHG:
 462                 extcon_set_state_sync(info->edev, EXTCON_CHG_USB_DCP,
 463                                         attached);
 464                 break;
 465         case MAX14577_CHARGER_TYPE_DOWNSTREAM_PORT:
 466                 extcon_set_state_sync(info->edev, EXTCON_CHG_USB_CDP,
 467                                         attached);
 468                 break;
 469         case MAX14577_CHARGER_TYPE_SPECIAL_500MA:
 470                 extcon_set_state_sync(info->edev, EXTCON_CHG_USB_SLOW,
 471                                         attached);
 472                 break;
 473         case MAX14577_CHARGER_TYPE_SPECIAL_1A:
 474                 extcon_set_state_sync(info->edev, EXTCON_CHG_USB_FAST,
 475                                         attached);
 476                 break;
 477         case MAX14577_CHARGER_TYPE_NONE:
 478         case MAX14577_CHARGER_TYPE_DEAD_BATTERY:
 479                 break;
 480         default:
 481                 dev_err(info->dev,
 482                         "failed to detect %s accessory (chg_type:0x%x)\n",
 483                         attached ? "attached" : "detached", chg_type);
 484                 return -EINVAL;
 485         }
 486
 487         return 0;
 488 }
 489
 490 static void max14577_muic_irq_work(struct work_struct *work)
 491 {
 492         struct max14577_muic_info *info = container_of(work,
 493                         struct max14577_muic_info, irq_work);
 494         int ret = 0;
 495
 496         if (!info->edev)
 497                 return;
 498
 499         mutex_lock(&info->mutex);
 500
 501         ret = max14577_bulk_read(info->max14577->regmap,
 502                         MAX14577_MUIC_REG_STATUS1, info->status, 2);
 503         if (ret) {
 504                 dev_err(info->dev, "failed to read MUIC register\n");
 505                 mutex_unlock(&info->mutex);
 506                 return;
 507         }
 508
 509         if (info->irq_adc) {
 510                 ret = max14577_muic_adc_handler(info);
 511                 info->irq_adc = false;
 512         }
 513         if (info->irq_chg) {
 514                 ret = max14577_muic_chg_handler(info);
 515                 info->irq_chg = false;
 516         }
 517
 518         if (ret < 0)
 519                 dev_err(info->dev, "failed to handle MUIC interrupt\n");
 520
 521         mutex_unlock(&info->mutex);
 522 }
 523
 524 /*
 525  * Sets irq_adc or irq_chg in max14577_muic_info and returns 1.
 526  * Returns 0 if irq_type does not match registered IRQ for this device type.
 527  */
 528 static int max14577_parse_irq(struct max14577_muic_info *info, int irq_type)
 529 {
 530         switch (irq_type) {
 531         case MAX14577_IRQ_INT1_ADC:
 532         case MAX14577_IRQ_INT1_ADCLOW:
 533         case MAX14577_IRQ_INT1_ADCERR:
 534                 /* Handle all of accessory except for
 535                    type of charger accessory */
 536                 info->irq_adc = true;
 537                 return 1;
 538         case MAX14577_IRQ_INT2_CHGTYP:
 539         case MAX14577_IRQ_INT2_CHGDETRUN:
 540         case MAX14577_IRQ_INT2_DCDTMR:
 541         case MAX14577_IRQ_INT2_DBCHG:
 542         case MAX14577_IRQ_INT2_VBVOLT:
 543                 /* Handle charger accessory */
 544                 info->irq_chg = true;
 545                 return 1;
 546         default:
 547                 return 0;
 548         }
 549 }
 550
 551 /*
 552  * Sets irq_adc or irq_chg in max14577_muic_info and returns 1.
 553  * Returns 0 if irq_type does not match registered IRQ for this device type.
 554  */
 555 static int max77836_parse_irq(struct max14577_muic_info *info, int irq_type)
 556 {
 557         /* First check common max14577 interrupts */
 558         if (max14577_parse_irq(info, irq_type))
 559                 return 1;
 560
 561         switch (irq_type) {
 562         case MAX77836_IRQ_INT1_ADC1K:
 563                 info->irq_adc = true;
 564                 return 1;
 565         case MAX77836_IRQ_INT2_VIDRM:
 566                 /* Handle charger accessory */
 567                 info->irq_chg = true;
 568                 return 1;
 569         default:
 570                 return 0;
 571         }
 572 }
 573
 574 static irqreturn_t max14577_muic_irq_handler(int irq, void *data)
 575 {
 576         struct max14577_muic_info *info = data;
 577         int i, irq_type = -1;
 578         bool irq_parsed;
 579
 580         /*
 581          * We may be called multiple times for different nested IRQ-s.
 582          * Including changes in INT1_ADC and INT2_CGHTYP at once.
 583          * However we only need to know whether it was ADC, charger
 584          * or both interrupts so decode IRQ and turn on proper flags.
 585          */
 586         for (i = 0; i < info->muic_irqs_num; i++)
 587                 if (irq == info->muic_irqs[i].virq)
 588                         irq_type = info->muic_irqs[i].irq;
 589
 590         switch (info->max14577->dev_type) {
 591         case MAXIM_DEVICE_TYPE_MAX77836:
 592                 irq_parsed = max77836_parse_irq(info, irq_type);
 593                 break;
 594         case MAXIM_DEVICE_TYPE_MAX14577:
 595         default:
 596                 irq_parsed = max14577_parse_irq(info, irq_type);
 597                 break;
 598         }
 599
 600         if (!irq_parsed) {
 601                 dev_err(info->dev, "muic interrupt: irq %d occurred, skipped\n",
 602                                 irq_type);
 603                 return IRQ_HANDLED;
 604         }
 605         schedule_work(&info->irq_work);
 606
 607         return IRQ_HANDLED;
 608 }
 609
 610 static int max14577_muic_detect_accessory(struct max14577_muic_info *info)
 611 {
 612         int ret = 0;
 613         int adc;
 614         int chg_type;
 615         bool attached;
 616
 617         mutex_lock(&info->mutex);
 618
 619         /* Read STATUSx register to detect accessory */
 620         ret = max14577_bulk_read(info->max14577->regmap,
 621                         MAX14577_MUIC_REG_STATUS1, info->status, 2);
 622         if (ret) {
 623                 dev_err(info->dev, "failed to read MUIC register\n");
 624                 mutex_unlock(&info->mutex);
 625                 return ret;
 626         }
 627
 628         adc = max14577_muic_get_cable_type(info, MAX14577_CABLE_GROUP_ADC,
 629                                         &attached);
 630         if (attached && adc != MAX14577_MUIC_ADC_OPEN) {
 631                 ret = max14577_muic_adc_handler(info);
 632                 if (ret < 0) {
 633                         dev_err(info->dev, "Cannot detect accessory\n");
 634                         mutex_unlock(&info->mutex);
 635                         return ret;
 636                 }
 637         }
 638
 639         chg_type = max14577_muic_get_cable_type(info, MAX14577_CABLE_GROUP_CHG,
 640                                         &attached);
 641         if (attached && chg_type != MAX14577_CHARGER_TYPE_NONE) {
 642                 ret = max14577_muic_chg_handler(info);
 643                 if (ret < 0) {
 644                         dev_err(info->dev, "Cannot detect charger accessory\n");
 645                         mutex_unlock(&info->mutex);
 646                         return ret;
 647                 }
 648         }
 649
 650         mutex_unlock(&info->mutex);
 651
 652         return 0;
 653 }
 654
 655 static void max14577_muic_detect_cable_wq(struct work_struct *work)
 656 {
 657         struct max14577_muic_info *info = container_of(to_delayed_work(work),
 658                                 struct max14577_muic_info, wq_detcable);
 659
 660         max14577_muic_detect_accessory(info);
 661 }
 662
 663 static int max14577_muic_probe(struct platform_device *pdev)
 664 {
 665         struct max14577 *max14577 = dev_get_drvdata(pdev->dev.parent);
 666         struct max14577_muic_info *info;
 667         int delay_jiffies;
 668         int ret;
 669         int i;
 670         u8 id;
 671
 672         info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
 673         if (!info)
 674                 return -ENOMEM;
 675
 676         info->dev = &pdev->dev;
 677         info->max14577 = max14577;
 678
 679         platform_set_drvdata(pdev, info);
 680         mutex_init(&info->mutex);
 681
 682         INIT_WORK(&info->irq_work, max14577_muic_irq_work);
 683
 684         switch (max14577->dev_type) {
 685         case MAXIM_DEVICE_TYPE_MAX77836:
 686                 info->muic_irqs = max77836_muic_irqs;
 687                 info->muic_irqs_num = ARRAY_SIZE(max77836_muic_irqs);
 688                 break;
 689         case MAXIM_DEVICE_TYPE_MAX14577:
 690         default:
 691                 info->muic_irqs = max14577_muic_irqs;
 692                 info->muic_irqs_num = ARRAY_SIZE(max14577_muic_irqs);
 693         }
 694
 695         /* Support irq domain for max14577 MUIC device */
 696         for (i = 0; i < info->muic_irqs_num; i++) {
 697                 struct max14577_muic_irq *muic_irq = &info->muic_irqs[i];
 698                 int virq = 0;
 699
 700                 virq = regmap_irq_get_virq(max14577->irq_data, muic_irq->irq);
 701                 if (virq <= 0)
 702                         return -EINVAL;
 703                 muic_irq->virq = virq;
 704
 705                 ret = devm_request_threaded_irq(&pdev->dev, virq, NULL,
 706                                 max14577_muic_irq_handler,
 707                                 IRQF_NO_SUSPEND,
 708                                 muic_irq->name, info);
 709                 if (ret) {
 710                         dev_err(&pdev->dev,
 711                                 "failed: irq request (IRQ: %d, error :%d)\n",
 712                                 muic_irq->irq, ret);
 713                         return ret;
 714                 }
 715         }
 716
 717         /* Initialize extcon device */
 718         info->edev = devm_extcon_dev_allocate(&pdev->dev,
 719                                               max14577_extcon_cable);
 720         if (IS_ERR(info->edev)) {
 721                 dev_err(&pdev->dev, "failed to allocate memory for extcon\n");
 722                 return -ENOMEM;
 723         }
 724
 725         ret = devm_extcon_dev_register(&pdev->dev, info->edev);
 726         if (ret) {
 727                 dev_err(&pdev->dev, "failed to register extcon device\n");
 728                 return ret;
 729         }
 730
 731         /* Default h/w line path */
 732         info->path_usb = CTRL1_SW_USB;
 733         info->path_uart = CTRL1_SW_UART;
 734         delay_jiffies = msecs_to_jiffies(DELAY_MS_DEFAULT);
 735
 736         /* Set initial path for UART */
 737         max14577_muic_set_path(info, info->path_uart, true);
 738
 739         /* Check revision number of MUIC device*/
 740         ret = max14577_read_reg(info->max14577->regmap,
 741                         MAX14577_REG_DEVICEID, &id);
 742         if (ret < 0) {
 743                 dev_err(&pdev->dev, "failed to read revision number\n");
 744                 return ret;
 745         }
 746         dev_info(info->dev, "device ID : 0x%x\n", id);
 747
 748         /* Set ADC debounce time */
 749         max14577_muic_set_debounce_time(info, ADC_DEBOUNCE_TIME_25MS);
 750
 751         /*
 752          * Detect accessory after completing the initialization of platform
 753          *
 754          * - Use delayed workqueue to detect cable state and then
 755          * notify cable state to notifiee/platform through uevent.
 756          * After completing the booting of platform, the extcon provider
 757          * driver should notify cable state to upper layer.
 758          */
 759         INIT_DELAYED_WORK(&info->wq_detcable, max14577_muic_detect_cable_wq);
 760         queue_delayed_work(system_power_efficient_wq, &info->wq_detcable,
 761                         delay_jiffies);
 762
 763         return ret;
 764 }
 765
 766 static int max14577_muic_remove(struct platform_device *pdev)
 767 {
 768         struct max14577_muic_info *info = platform_get_drvdata(pdev);
 769
 770         cancel_work_sync(&info->irq_work);
 771
 772         return 0;
 773 }
 774
 775 static const struct platform_device_id max14577_muic_id[] = {
 776         { "max14577-muic", MAXIM_DEVICE_TYPE_MAX14577, },
 777         { "max77836-muic", MAXIM_DEVICE_TYPE_MAX77836, },
 778         { }
 779 };
 780 MODULE_DEVICE_TABLE(platform, max14577_muic_id);
 781
 782 static struct platform_driver max14577_muic_driver = {
 783         .driver         = {
 784                 .name   = "max14577-muic",
 785         },
 786         .probe          = max14577_muic_probe,
 787         .remove         = max14577_muic_remove,
 788         .id_table       = max14577_muic_id,
 789 };
 790
 791 module_platform_driver(max14577_muic_driver);
 792
 793 MODULE_DESCRIPTION("Maxim 14577/77836 Extcon driver");
 794 MODULE_AUTHOR("Chanwoo Choi <cw00.choi@samsung.com>, Krzysztof Kozlowski <krzk@kernel.org>");
 795 MODULE_LICENSE("GPL");
 796 MODULE_ALIAS("platform:extcon-max14577");