drivers/extcon/extcon-max14577.c

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