drivers/extcon/extcon-arizona.c

   1 /*
   2  * extcon-arizona.c - Extcon driver Wolfson Arizona devices
   3  *
   4  *  Copyright (C) 2012 Wolfson Microelectronics plc
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  */
  16
  17 #include <linux/kernel.h>
  18 #include <linux/module.h>
  19 #include <linux/i2c.h>
  20 #include <linux/slab.h>
  21 #include <linux/interrupt.h>
  22 #include <linux/err.h>
  23 #include <linux/gpio.h>
  24 #include <linux/input.h>
  25 #include <linux/platform_device.h>
  26 #include <linux/pm_runtime.h>
  27 #include <linux/regulator/consumer.h>
  28 #include <linux/extcon.h>
  29
  30 #include <sound/soc.h>
  31
  32 #include <linux/mfd/arizona/core.h>
  33 #include <linux/mfd/arizona/pdata.h>
  34 #include <linux/mfd/arizona/registers.h>
  35
  36 #define ARIZONA_MAX_MICD_RANGE 8
  37
  38 #define ARIZONA_ACCDET_MODE_MIC 0
  39 #define ARIZONA_ACCDET_MODE_HPL 1
  40 #define ARIZONA_ACCDET_MODE_HPR 2
  41
  42 #define HPDET_DEBOUNCE 250
  43
  44 struct arizona_extcon_info {
  45         struct device *dev;
  46         struct arizona *arizona;
  47         struct mutex lock;
  48         struct regulator *micvdd;
  49         struct input_dev *input;
  50
  51         u16 last_jackdet;
  52
  53         int micd_mode;
  54         const struct arizona_micd_config *micd_modes;
  55         int micd_num_modes;
  56
  57         const struct arizona_micd_range *micd_ranges;
  58         int num_micd_ranges;
  59
  60         bool micd_reva;
  61         bool micd_clamp;
  62
  63         struct delayed_work hpdet_work;
  64
  65         bool hpdet_active;
  66         bool hpdet_done;
  67
  68         int num_hpdet_res;
  69         unsigned int hpdet_res[3];
  70
  71         bool mic;
  72         bool detecting;
  73         int jack_flips;
  74
  75         int hpdet_ip;
  76
  77         struct extcon_dev edev;
  78 };
  79
  80 static const struct arizona_micd_config micd_default_modes[] = {
  81         { ARIZONA_ACCDET_SRC, 1 << ARIZONA_MICD_BIAS_SRC_SHIFT, 0 },
  82         { 0,                  2 << ARIZONA_MICD_BIAS_SRC_SHIFT, 1 },
  83 };
  84
  85 static const struct arizona_micd_range micd_default_ranges[] = {
  86         { .max =  11, .key = BTN_0 },
  87         { .max =  28, .key = BTN_1 },
  88         { .max =  54, .key = BTN_2 },
  89         { .max = 100, .key = BTN_3 },
  90         { .max = 186, .key = BTN_4 },
  91         { .max = 430, .key = BTN_5 },
  92 };
  93
  94 static const int arizona_micd_levels[] = {
  95         3, 6, 8, 11, 13, 16, 18, 21, 23, 26, 28, 31, 34, 36, 39, 41, 44, 46,
  96         49, 52, 54, 57, 60, 62, 65, 67, 70, 73, 75, 78, 81, 83, 89, 94, 100,
  97         105, 111, 116, 122, 127, 139, 150, 161, 173, 186, 196, 209, 220, 245,
  98         270, 295, 321, 348, 375, 402, 430, 489, 550, 614, 681, 752, 903, 1071,
  99         1257,
 100 };
 101
 102 #define ARIZONA_CABLE_MECHANICAL 0
 103 #define ARIZONA_CABLE_MICROPHONE 1
 104 #define ARIZONA_CABLE_HEADPHONE  2
 105 #define ARIZONA_CABLE_LINEOUT    3
 106
 107 static const char *arizona_cable[] = {
 108         "Mechanical",
 109         "Microphone",
 110         "Headphone",
 111         "Line-out",
 112         NULL,
 113 };
 114
 115 static void arizona_extcon_do_magic(struct arizona_extcon_info *info,
 116                                     unsigned int magic)
 117 {
 118         struct arizona *arizona = info->arizona;
 119         int ret;
 120
 121         mutex_lock(&arizona->dapm->card->dapm_mutex);
 122
 123         arizona->hpdet_magic = magic;
 124
 125         /* Keep the HP output stages disabled while doing the magic */
 126         if (magic) {
 127                 ret = regmap_update_bits(arizona->regmap,
 128                                          ARIZONA_OUTPUT_ENABLES_1,
 129                                          ARIZONA_OUT1L_ENA |
 130                                          ARIZONA_OUT1R_ENA, 0);
 131                 if (ret != 0)
 132                         dev_warn(arizona->dev,
 133                                 "Failed to disable headphone outputs: %d\n",
 134                                  ret);
 135         }
 136
 137         ret = regmap_update_bits(arizona->regmap, 0x225, 0x4000,
 138                                  magic);
 139         if (ret != 0)
 140                 dev_warn(arizona->dev, "Failed to do magic: %d\n",
 141                                  ret);
 142
 143         ret = regmap_update_bits(arizona->regmap, 0x226, 0x4000,
 144                                  magic);
 145         if (ret != 0)
 146                 dev_warn(arizona->dev, "Failed to do magic: %d\n",
 147                          ret);
 148
 149         /* Restore the desired state while not doing the magic */
 150         if (!magic) {
 151                 ret = regmap_update_bits(arizona->regmap,
 152                                          ARIZONA_OUTPUT_ENABLES_1,
 153                                          ARIZONA_OUT1L_ENA |
 154                                          ARIZONA_OUT1R_ENA, arizona->hp_ena);
 155                 if (ret != 0)
 156                         dev_warn(arizona->dev,
 157                                  "Failed to restore headphone outputs: %d\n",
 158                                  ret);
 159         }
 160
 161         mutex_unlock(&arizona->dapm->card->dapm_mutex);
 162 }
 163
 164 static void arizona_extcon_set_mode(struct arizona_extcon_info *info, int mode)
 165 {
 166         struct arizona *arizona = info->arizona;
 167
 168         mode %= info->micd_num_modes;
 169
 170         if (arizona->pdata.micd_pol_gpio > 0)
 171                 gpio_set_value_cansleep(arizona->pdata.micd_pol_gpio,
 172                                         info->micd_modes[mode].gpio);
 173         regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
 174                            ARIZONA_MICD_BIAS_SRC_MASK,
 175                            info->micd_modes[mode].bias);
 176         regmap_update_bits(arizona->regmap, ARIZONA_ACCESSORY_DETECT_MODE_1,
 177                            ARIZONA_ACCDET_SRC, info->micd_modes[mode].src);
 178
 179         info->micd_mode = mode;
 180
 181         dev_dbg(arizona->dev, "Set jack polarity to %d\n", mode);
 182 }
 183
 184 static const char *arizona_extcon_get_micbias(struct arizona_extcon_info *info)
 185 {
 186         switch (info->micd_modes[0].bias >> ARIZONA_MICD_BIAS_SRC_SHIFT) {
 187         case 1:
 188                 return "MICBIAS1";
 189         case 2:
 190                 return "MICBIAS2";
 191         case 3:
 192                 return "MICBIAS3";
 193         default:
 194                 return "MICVDD";
 195         }
 196 }
 197
 198 static void arizona_extcon_pulse_micbias(struct arizona_extcon_info *info)
 199 {
 200         struct arizona *arizona = info->arizona;
 201         const char *widget = arizona_extcon_get_micbias(info);
 202         struct snd_soc_dapm_context *dapm = arizona->dapm;
 203         int ret;
 204
 205         mutex_lock(&dapm->card->dapm_mutex);
 206
 207         ret = snd_soc_dapm_force_enable_pin(dapm, widget);
 208         if (ret != 0)
 209                 dev_warn(arizona->dev, "Failed to enable %s: %d\n",
 210                          widget, ret);
 211
 212         mutex_unlock(&dapm->card->dapm_mutex);
 213
 214         snd_soc_dapm_sync(dapm);
 215
 216         if (!arizona->pdata.micd_force_micbias) {
 217                 mutex_lock(&dapm->card->dapm_mutex);
 218
 219                 ret = snd_soc_dapm_disable_pin(arizona->dapm, widget);
 220                 if (ret != 0)
 221                         dev_warn(arizona->dev, "Failed to disable %s: %d\n",
 222                                  widget, ret);
 223
 224                 mutex_unlock(&dapm->card->dapm_mutex);
 225
 226                 snd_soc_dapm_sync(dapm);
 227         }
 228 }
 229
 230 static void arizona_start_mic(struct arizona_extcon_info *info)
 231 {
 232         struct arizona *arizona = info->arizona;
 233         bool change;
 234         int ret;
 235
 236         /* Microphone detection can't use idle mode */
 237         pm_runtime_get(info->dev);
 238
 239         if (info->detecting) {
 240                 ret = regulator_allow_bypass(info->micvdd, false);
 241                 if (ret != 0) {
 242                         dev_err(arizona->dev,
 243                                 "Failed to regulate MICVDD: %d\n",
 244                                 ret);
 245                 }
 246         }
 247
 248         ret = regulator_enable(info->micvdd);
 249         if (ret != 0) {
 250                 dev_err(arizona->dev, "Failed to enable MICVDD: %d\n",
 251                         ret);
 252         }
 253
 254         if (info->micd_reva) {
 255                 regmap_write(arizona->regmap, 0x80, 0x3);
 256                 regmap_write(arizona->regmap, 0x294, 0);
 257                 regmap_write(arizona->regmap, 0x80, 0x0);
 258         }
 259
 260         regmap_update_bits(arizona->regmap,
 261                            ARIZONA_ACCESSORY_DETECT_MODE_1,
 262                            ARIZONA_ACCDET_MODE_MASK, ARIZONA_ACCDET_MODE_MIC);
 263
 264         arizona_extcon_pulse_micbias(info);
 265
 266         regmap_update_bits_check(arizona->regmap, ARIZONA_MIC_DETECT_1,
 267                                  ARIZONA_MICD_ENA, ARIZONA_MICD_ENA,
 268                                  &change);
 269         if (!change) {
 270                 regulator_disable(info->micvdd);
 271                 pm_runtime_put_autosuspend(info->dev);
 272         }
 273 }
 274
 275 static void arizona_stop_mic(struct arizona_extcon_info *info)
 276 {
 277         struct arizona *arizona = info->arizona;
 278         const char *widget = arizona_extcon_get_micbias(info);
 279         struct snd_soc_dapm_context *dapm = arizona->dapm;
 280         bool change;
 281         int ret;
 282
 283         regmap_update_bits_check(arizona->regmap, ARIZONA_MIC_DETECT_1,
 284                                  ARIZONA_MICD_ENA, 0,
 285                                  &change);
 286
 287         mutex_lock(&dapm->card->dapm_mutex);
 288
 289         ret = snd_soc_dapm_disable_pin(dapm, widget);
 290         if (ret != 0)
 291                 dev_warn(arizona->dev,
 292                          "Failed to disable %s: %d\n",
 293                          widget, ret);
 294
 295         mutex_unlock(&dapm->card->dapm_mutex);
 296
 297         snd_soc_dapm_sync(dapm);
 298
 299         if (info->micd_reva) {
 300                 regmap_write(arizona->regmap, 0x80, 0x3);
 301                 regmap_write(arizona->regmap, 0x294, 2);
 302                 regmap_write(arizona->regmap, 0x80, 0x0);
 303         }
 304
 305         ret = regulator_allow_bypass(info->micvdd, true);
 306         if (ret != 0) {
 307                 dev_err(arizona->dev, "Failed to bypass MICVDD: %d\n",
 308                         ret);
 309         }
 310
 311         if (change) {
 312                 regulator_disable(info->micvdd);
 313                 pm_runtime_mark_last_busy(info->dev);
 314                 pm_runtime_put_autosuspend(info->dev);
 315         }
 316 }
 317
 318 static struct {
 319         unsigned int factor_a;
 320         unsigned int factor_b;
 321 } arizona_hpdet_b_ranges[] = {
 322         {  5528,   362464 },
 323         { 11084,  6186851 },
 324         { 11065, 65460395 },
 325 };
 326
 327 static struct {
 328         int min;
 329         int max;
 330 } arizona_hpdet_c_ranges[] = {
 331         { 0,       30 },
 332         { 8,      100 },
 333         { 100,   1000 },
 334         { 1000, 10000 },
 335 };
 336
 337 static int arizona_hpdet_read(struct arizona_extcon_info *info)
 338 {
 339         struct arizona *arizona = info->arizona;
 340         unsigned int val, range;
 341         int ret;
 342
 343         ret = regmap_read(arizona->regmap, ARIZONA_HEADPHONE_DETECT_2, &val);
 344         if (ret != 0) {
 345                 dev_err(arizona->dev, "Failed to read HPDET status: %d\n",
 346                         ret);
 347                 return ret;
 348         }
 349
 350         switch (info->hpdet_ip) {
 351         case 0:
 352                 if (!(val & ARIZONA_HP_DONE)) {
 353                         dev_err(arizona->dev, "HPDET did not complete: %x\n",
 354                                 val);
 355                         return -EAGAIN;
 356                 }
 357
 358                 val &= ARIZONA_HP_LVL_MASK;
 359                 break;
 360
 361         case 1:
 362                 if (!(val & ARIZONA_HP_DONE_B)) {
 363                         dev_err(arizona->dev, "HPDET did not complete: %x\n",
 364                                 val);
 365                         return -EAGAIN;
 366                 }
 367
 368                 ret = regmap_read(arizona->regmap, ARIZONA_HP_DACVAL, &val);
 369                 if (ret != 0) {
 370                         dev_err(arizona->dev, "Failed to read HP value: %d\n",
 371                                 ret);
 372                         return -EAGAIN;
 373                 }
 374
 375                 regmap_read(arizona->regmap, ARIZONA_HEADPHONE_DETECT_1,
 376                             &range);
 377                 range = (range & ARIZONA_HP_IMPEDANCE_RANGE_MASK)
 378                            >> ARIZONA_HP_IMPEDANCE_RANGE_SHIFT;
 379
 380                 if (range < ARRAY_SIZE(arizona_hpdet_b_ranges) - 1 &&
 381                     (val < 100 || val > 0x3fb)) {
 382                         range++;
 383                         dev_dbg(arizona->dev, "Moving to HPDET range %d\n",
 384                                 range);
 385                         regmap_update_bits(arizona->regmap,
 386                                            ARIZONA_HEADPHONE_DETECT_1,
 387                                            ARIZONA_HP_IMPEDANCE_RANGE_MASK,
 388                                            range <<
 389                                            ARIZONA_HP_IMPEDANCE_RANGE_SHIFT);
 390                         return -EAGAIN;
 391                 }
 392
 393                 /* If we go out of range report top of range */
 394                 if (val < 100 || val > 0x3fb) {
 395                         dev_dbg(arizona->dev, "Measurement out of range\n");
 396                         return 10000;
 397                 }
 398
 399                 dev_dbg(arizona->dev, "HPDET read %d in range %d\n",
 400                         val, range);
 401
 402                 val = arizona_hpdet_b_ranges[range].factor_b
 403                         / ((val * 100) -
 404                            arizona_hpdet_b_ranges[range].factor_a);
 405                 break;
 406
 407         default:
 408                 dev_warn(arizona->dev, "Unknown HPDET IP revision %d\n",
 409                          info->hpdet_ip);
 410         case 2:
 411                 if (!(val & ARIZONA_HP_DONE_B)) {
 412                         dev_err(arizona->dev, "HPDET did not complete: %x\n",
 413                                 val);
 414                         return -EAGAIN;
 415                 }
 416
 417                 val &= ARIZONA_HP_LVL_B_MASK;
 418
 419                 regmap_read(arizona->regmap, ARIZONA_HEADPHONE_DETECT_1,
 420                             &range);
 421                 range = (range & ARIZONA_HP_IMPEDANCE_RANGE_MASK)
 422                            >> ARIZONA_HP_IMPEDANCE_RANGE_SHIFT;
 423
 424                 /* Skip up or down a range? */
 425                 if (range && (val < arizona_hpdet_c_ranges[range].min)) {
 426                         range--;
 427                         dev_dbg(arizona->dev, "Moving to HPDET range %d-%d\n",
 428                                 arizona_hpdet_c_ranges[range].min,
 429                                 arizona_hpdet_c_ranges[range].max);
 430                         regmap_update_bits(arizona->regmap,
 431                                            ARIZONA_HEADPHONE_DETECT_1,
 432                                            ARIZONA_HP_IMPEDANCE_RANGE_MASK,
 433                                            range <<
 434                                            ARIZONA_HP_IMPEDANCE_RANGE_SHIFT);
 435                         return -EAGAIN;
 436                 }
 437
 438                 if (range < ARRAY_SIZE(arizona_hpdet_c_ranges) - 1 &&
 439                     (val >= arizona_hpdet_c_ranges[range].max)) {
 440                         range++;
 441                         dev_dbg(arizona->dev, "Moving to HPDET range %d-%d\n",
 442                                 arizona_hpdet_c_ranges[range].min,
 443                                 arizona_hpdet_c_ranges[range].max);
 444                         regmap_update_bits(arizona->regmap,
 445                                            ARIZONA_HEADPHONE_DETECT_1,
 446                                            ARIZONA_HP_IMPEDANCE_RANGE_MASK,
 447                                            range <<
 448                                            ARIZONA_HP_IMPEDANCE_RANGE_SHIFT);
 449                         return -EAGAIN;
 450                 }
 451         }
 452
 453         dev_dbg(arizona->dev, "HP impedance %d ohms\n", val);
 454         return val;
 455 }
 456
 457 static int arizona_hpdet_do_id(struct arizona_extcon_info *info, int *reading)
 458 {
 459         struct arizona *arizona = info->arizona;
 460         int id_gpio = arizona->pdata.hpdet_id_gpio;
 461
 462         /*
 463          * If we're using HPDET for accessory identification we need
 464          * to take multiple measurements, step through them in sequence.
 465          */
 466         if (arizona->pdata.hpdet_acc_id) {
 467                 info->hpdet_res[info->num_hpdet_res++] = *reading;
 468
 469                 /*
 470                  * If the impedence is too high don't measure the
 471                  * second ground.
 472                  */
 473                 if (info->num_hpdet_res == 1 && *reading >= 45) {
 474                         dev_dbg(arizona->dev, "Skipping ground flip\n");
 475                         info->hpdet_res[info->num_hpdet_res++] = *reading;
 476                 }
 477
 478                 if (info->num_hpdet_res == 1) {
 479                         dev_dbg(arizona->dev, "Flipping ground\n");
 480
 481                         regmap_update_bits(arizona->regmap,
 482                                            ARIZONA_ACCESSORY_DETECT_MODE_1,
 483                                            ARIZONA_ACCDET_SRC,
 484                                            ~info->micd_modes[0].src);
 485
 486                         regmap_update_bits(arizona->regmap,
 487                                            ARIZONA_HEADPHONE_DETECT_1,
 488                                            ARIZONA_HP_POLL, ARIZONA_HP_POLL);
 489                         return -EAGAIN;
 490                 }
 491
 492                 /* Only check the mic directly if we didn't already ID it */
 493                 if (id_gpio && info->num_hpdet_res == 2 &&
 494                     !((info->hpdet_res[0] > info->hpdet_res[1] * 2))) {
 495                         dev_dbg(arizona->dev, "Measuring mic\n");
 496
 497                         regmap_update_bits(arizona->regmap,
 498                                            ARIZONA_ACCESSORY_DETECT_MODE_1,
 499                                            ARIZONA_ACCDET_MODE_MASK |
 500                                            ARIZONA_ACCDET_SRC,
 501                                            ARIZONA_ACCDET_MODE_HPR |
 502                                            info->micd_modes[0].src);
 503
 504                         gpio_set_value_cansleep(id_gpio, 1);
 505
 506                         regmap_update_bits(arizona->regmap,
 507                                            ARIZONA_HEADPHONE_DETECT_1,
 508                                            ARIZONA_HP_POLL, ARIZONA_HP_POLL);
 509                         return -EAGAIN;
 510                 }
 511
 512                 /* OK, got both.  Now, compare... */
 513                 dev_dbg(arizona->dev, "HPDET measured %d %d %d\n",
 514                         info->hpdet_res[0], info->hpdet_res[1],
 515                         info->hpdet_res[2]);
 516
 517
 518                 /* Take the headphone impedance for the main report */
 519                 *reading = info->hpdet_res[0];
 520
 521                 /*
 522                  * Either the two grounds measure differently or we
 523                  * measure the mic as high impedance.
 524                  */
 525                 if ((info->hpdet_res[0] > info->hpdet_res[1] * 2) ||
 526                     (id_gpio && info->hpdet_res[2] > 1257)) {
 527                         dev_dbg(arizona->dev, "Detected mic\n");
 528                         info->mic = true;
 529                         info->detecting = true;
 530                 } else {
 531                         dev_dbg(arizona->dev, "Detected headphone\n");
 532                 }
 533
 534                 /* Make sure everything is reset back to the real polarity */
 535                 regmap_update_bits(arizona->regmap,
 536                                    ARIZONA_ACCESSORY_DETECT_MODE_1,
 537                                    ARIZONA_ACCDET_SRC,
 538                                    info->micd_modes[0].src);
 539         }
 540
 541         return 0;
 542 }
 543
 544 static irqreturn_t arizona_hpdet_irq(int irq, void *data)
 545 {
 546         struct arizona_extcon_info *info = data;
 547         struct arizona *arizona = info->arizona;
 548         int id_gpio = arizona->pdata.hpdet_id_gpio;
 549         int report = ARIZONA_CABLE_HEADPHONE;
 550         int ret, reading;
 551
 552         mutex_lock(&info->lock);
 553
 554         /* If we got a spurious IRQ for some reason then ignore it */
 555         if (!info->hpdet_active) {
 556                 dev_warn(arizona->dev, "Spurious HPDET IRQ\n");
 557                 mutex_unlock(&info->lock);
 558                 return IRQ_NONE;
 559         }
 560
 561         /* If the cable was removed while measuring ignore the result */
 562         ret = extcon_get_cable_state_(&info->edev, ARIZONA_CABLE_MECHANICAL);
 563         if (ret < 0) {
 564                 dev_err(arizona->dev, "Failed to check cable state: %d\n",
 565                         ret);
 566                 goto out;
 567         } else if (!ret) {
 568                 dev_dbg(arizona->dev, "Ignoring HPDET for removed cable\n");
 569                 goto done;
 570         }
 571
 572         ret = arizona_hpdet_read(info);
 573         if (ret == -EAGAIN) {
 574                 goto out;
 575         } else if (ret < 0) {
 576                 goto done;
 577         }
 578         reading = ret;
 579
 580         /* Reset back to starting range */
 581         regmap_update_bits(arizona->regmap,
 582                            ARIZONA_HEADPHONE_DETECT_1,
 583                            ARIZONA_HP_IMPEDANCE_RANGE_MASK | ARIZONA_HP_POLL,
 584                            0);
 585
 586         ret = arizona_hpdet_do_id(info, &reading);
 587         if (ret == -EAGAIN) {
 588                 goto out;
 589         } else if (ret < 0) {
 590                 goto done;
 591         }
 592
 593         /* Report high impedence cables as line outputs */
 594         if (reading >= 5000)
 595                 report = ARIZONA_CABLE_LINEOUT;
 596         else
 597                 report = ARIZONA_CABLE_HEADPHONE;
 598
 599         ret = extcon_set_cable_state_(&info->edev, report, true);
 600         if (ret != 0)
 601                 dev_err(arizona->dev, "Failed to report HP/line: %d\n",
 602                         ret);
 603
 604         arizona_extcon_do_magic(info, 0);
 605
 606 done:
 607         if (id_gpio)
 608                 gpio_set_value_cansleep(id_gpio, 0);
 609
 610         /* Revert back to MICDET mode */
 611         regmap_update_bits(arizona->regmap,
 612                            ARIZONA_ACCESSORY_DETECT_MODE_1,
 613                            ARIZONA_ACCDET_MODE_MASK, ARIZONA_ACCDET_MODE_MIC);
 614
 615         /* If we have a mic then reenable MICDET */
 616         if (info->mic)
 617                 arizona_start_mic(info);
 618
 619         if (info->hpdet_active) {
 620                 pm_runtime_put_autosuspend(info->dev);
 621                 info->hpdet_active = false;
 622         }
 623
 624         info->hpdet_done = true;
 625
 626 out:
 627         mutex_unlock(&info->lock);
 628
 629         return IRQ_HANDLED;
 630 }
 631
 632 static void arizona_identify_headphone(struct arizona_extcon_info *info)
 633 {
 634         struct arizona *arizona = info->arizona;
 635         int ret;
 636
 637         if (info->hpdet_done)
 638                 return;
 639
 640         dev_dbg(arizona->dev, "Starting HPDET\n");
 641
 642         /* Make sure we keep the device enabled during the measurement */
 643         pm_runtime_get(info->dev);
 644
 645         info->hpdet_active = true;
 646
 647         if (info->mic)
 648                 arizona_stop_mic(info);
 649
 650         arizona_extcon_do_magic(info, 0x4000);
 651
 652         ret = regmap_update_bits(arizona->regmap,
 653                                  ARIZONA_ACCESSORY_DETECT_MODE_1,
 654                                  ARIZONA_ACCDET_MODE_MASK,
 655                                  ARIZONA_ACCDET_MODE_HPL);
 656         if (ret != 0) {
 657                 dev_err(arizona->dev, "Failed to set HPDETL mode: %d\n", ret);
 658                 goto err;
 659         }
 660
 661         ret = regmap_update_bits(arizona->regmap, ARIZONA_HEADPHONE_DETECT_1,
 662                                  ARIZONA_HP_POLL, ARIZONA_HP_POLL);
 663         if (ret != 0) {
 664                 dev_err(arizona->dev, "Can't start HPDETL measurement: %d\n",
 665                         ret);
 666                 goto err;
 667         }
 668
 669         return;
 670
 671 err:
 672         regmap_update_bits(arizona->regmap, ARIZONA_ACCESSORY_DETECT_MODE_1,
 673                            ARIZONA_ACCDET_MODE_MASK, ARIZONA_ACCDET_MODE_MIC);
 674
 675         /* Just report headphone */
 676         ret = extcon_update_state(&info->edev,
 677                                   1 << ARIZONA_CABLE_HEADPHONE,
 678                                   1 << ARIZONA_CABLE_HEADPHONE);
 679         if (ret != 0)
 680                 dev_err(arizona->dev, "Failed to report headphone: %d\n", ret);
 681
 682         if (info->mic)
 683                 arizona_start_mic(info);
 684
 685         info->hpdet_active = false;
 686 }
 687
 688 static void arizona_start_hpdet_acc_id(struct arizona_extcon_info *info)
 689 {
 690         struct arizona *arizona = info->arizona;
 691         int ret;
 692
 693         dev_dbg(arizona->dev, "Starting identification via HPDET\n");
 694
 695         /* Make sure we keep the device enabled during the measurement */
 696         pm_runtime_get_sync(info->dev);
 697
 698         info->hpdet_active = true;
 699
 700         arizona_extcon_do_magic(info, 0x4000);
 701
 702         ret = regmap_update_bits(arizona->regmap,
 703                                  ARIZONA_ACCESSORY_DETECT_MODE_1,
 704                                  ARIZONA_ACCDET_SRC | ARIZONA_ACCDET_MODE_MASK,
 705                                  info->micd_modes[0].src |
 706                                  ARIZONA_ACCDET_MODE_HPL);
 707         if (ret != 0) {
 708                 dev_err(arizona->dev, "Failed to set HPDETL mode: %d\n", ret);
 709                 goto err;
 710         }
 711
 712         ret = regmap_update_bits(arizona->regmap, ARIZONA_HEADPHONE_DETECT_1,
 713                                  ARIZONA_HP_POLL, ARIZONA_HP_POLL);
 714         if (ret != 0) {
 715                 dev_err(arizona->dev, "Can't start HPDETL measurement: %d\n",
 716                         ret);
 717                 goto err;
 718         }
 719
 720         return;
 721
 722 err:
 723         regmap_update_bits(arizona->regmap, ARIZONA_ACCESSORY_DETECT_MODE_1,
 724                            ARIZONA_ACCDET_MODE_MASK, ARIZONA_ACCDET_MODE_MIC);
 725
 726         /* Just report headphone */
 727         ret = extcon_update_state(&info->edev,
 728                                   1 << ARIZONA_CABLE_HEADPHONE,
 729                                   1 << ARIZONA_CABLE_HEADPHONE);
 730         if (ret != 0)
 731                 dev_err(arizona->dev, "Failed to report headphone: %d\n", ret);
 732
 733         info->hpdet_active = false;
 734 }
 735
 736 static irqreturn_t arizona_micdet(int irq, void *data)
 737 {
 738         struct arizona_extcon_info *info = data;
 739         struct arizona *arizona = info->arizona;
 740         unsigned int val, lvl;
 741         int ret, i, key;
 742
 743         mutex_lock(&info->lock);
 744
 745         ret = regmap_read(arizona->regmap, ARIZONA_MIC_DETECT_3, &val);
 746         if (ret != 0) {
 747                 dev_err(arizona->dev, "Failed to read MICDET: %d\n", ret);
 748                 mutex_unlock(&info->lock);
 749                 return IRQ_NONE;
 750         }
 751
 752         dev_dbg(arizona->dev, "MICDET: %x\n", val);
 753
 754         if (!(val & ARIZONA_MICD_VALID)) {
 755                 dev_warn(arizona->dev, "Microphone detection state invalid\n");
 756                 mutex_unlock(&info->lock);
 757                 return IRQ_NONE;
 758         }
 759
 760         /* Due to jack detect this should never happen */
 761         if (!(val & ARIZONA_MICD_STS)) {
 762                 dev_warn(arizona->dev, "Detected open circuit\n");
 763                 info->detecting = false;
 764                 goto handled;
 765         }
 766
 767         /* If we got a high impedence we should have a headset, report it. */
 768         if (info->detecting && (val & 0x400)) {
 769                 arizona_identify_headphone(info);
 770
 771                 ret = extcon_update_state(&info->edev,
 772                                           1 << ARIZONA_CABLE_MICROPHONE,
 773                                           1 << ARIZONA_CABLE_MICROPHONE);
 774
 775                 if (ret != 0)
 776                         dev_err(arizona->dev, "Headset report failed: %d\n",
 777                                 ret);
 778
 779                 /* Don't need to regulate for button detection */
 780                 ret = regulator_allow_bypass(info->micvdd, false);
 781                 if (ret != 0) {
 782                         dev_err(arizona->dev, "Failed to bypass MICVDD: %d\n",
 783                                 ret);
 784                 }
 785
 786                 info->mic = true;
 787                 info->detecting = false;
 788                 goto handled;
 789         }
 790
 791         /* If we detected a lower impedence during initial startup
 792          * then we probably have the wrong polarity, flip it.  Don't
 793          * do this for the lowest impedences to speed up detection of
 794          * plain headphones.  If both polarities report a low
 795          * impedence then give up and report headphones.
 796          */
 797         if (info->detecting && (val & 0x3f8)) {
 798                 if (info->jack_flips >= info->micd_num_modes * 10) {
 799                         dev_dbg(arizona->dev, "Detected HP/line\n");
 800                         arizona_identify_headphone(info);
 801
 802                         info->detecting = false;
 803
 804                         arizona_stop_mic(info);
 805                 } else {
 806                         info->micd_mode++;
 807                         if (info->micd_mode == info->micd_num_modes)
 808                                 info->micd_mode = 0;
 809                         arizona_extcon_set_mode(info, info->micd_mode);
 810
 811                         info->jack_flips++;
 812                 }
 813
 814                 goto handled;
 815         }
 816
 817         /*
 818          * If we're still detecting and we detect a short then we've
 819          * got a headphone.  Otherwise it's a button press.
 820          */
 821         if (val & 0x3fc) {
 822                 if (info->mic) {
 823                         dev_dbg(arizona->dev, "Mic button detected\n");
 824
 825                         lvl = val & ARIZONA_MICD_LVL_MASK;
 826                         lvl >>= ARIZONA_MICD_LVL_SHIFT;
 827
 828                         WARN_ON(!lvl);
 829                         WARN_ON(ffs(lvl) - 1 >= info->num_micd_ranges);
 830                         if (lvl && ffs(lvl) - 1 < info->num_micd_ranges) {
 831                                 key = info->micd_ranges[ffs(lvl) - 1].key;
 832                                 input_report_key(info->input, key, 1);
 833                                 input_sync(info->input);
 834                         }
 835
 836                 } else if (info->detecting) {
 837                         dev_dbg(arizona->dev, "Headphone detected\n");
 838                         info->detecting = false;
 839                         arizona_stop_mic(info);
 840
 841                         arizona_identify_headphone(info);
 842                 } else {
 843                         dev_warn(arizona->dev, "Button with no mic: %x\n",
 844                                  val);
 845                 }
 846         } else {
 847                 dev_dbg(arizona->dev, "Mic button released\n");
 848                 for (i = 0; i < info->num_micd_ranges; i++)
 849                         input_report_key(info->input,
 850                                          info->micd_ranges[i].key, 0);
 851                 input_sync(info->input);
 852                 arizona_extcon_pulse_micbias(info);
 853         }
 854
 855 handled:
 856         pm_runtime_mark_last_busy(info->dev);
 857         mutex_unlock(&info->lock);
 858
 859         return IRQ_HANDLED;
 860 }
 861
 862 static void arizona_hpdet_work(struct work_struct *work)
 863 {
 864         struct arizona_extcon_info *info = container_of(work,
 865                                                         struct arizona_extcon_info,
 866                                                         hpdet_work.work);
 867
 868         mutex_lock(&info->lock);
 869         arizona_start_hpdet_acc_id(info);
 870         mutex_unlock(&info->lock);
 871 }
 872
 873 static irqreturn_t arizona_jackdet(int irq, void *data)
 874 {
 875         struct arizona_extcon_info *info = data;
 876         struct arizona *arizona = info->arizona;
 877         unsigned int val, present, mask;
 878         bool cancelled;
 879         int ret, i;
 880
 881         cancelled = cancel_delayed_work_sync(&info->hpdet_work);
 882
 883         pm_runtime_get_sync(info->dev);
 884
 885         mutex_lock(&info->lock);
 886
 887         if (arizona->pdata.jd_gpio5) {
 888                 mask = ARIZONA_MICD_CLAMP_STS;
 889                 present = 0;
 890         } else {
 891                 mask = ARIZONA_JD1_STS;
 892                 present = ARIZONA_JD1_STS;
 893         }
 894
 895         ret = regmap_read(arizona->regmap, ARIZONA_AOD_IRQ_RAW_STATUS, &val);
 896         if (ret != 0) {
 897                 dev_err(arizona->dev, "Failed to read jackdet status: %d\n",
 898                         ret);
 899                 mutex_unlock(&info->lock);
 900                 pm_runtime_put_autosuspend(info->dev);
 901                 return IRQ_NONE;
 902         }
 903
 904         val &= mask;
 905         if (val == info->last_jackdet) {
 906                 dev_dbg(arizona->dev, "Suppressing duplicate JACKDET\n");
 907                 if (cancelled)
 908                         schedule_delayed_work(&info->hpdet_work,
 909                                               msecs_to_jiffies(HPDET_DEBOUNCE));
 910
 911                 goto out;
 912         }
 913         info->last_jackdet = val;
 914
 915         if (info->last_jackdet == present) {
 916                 dev_dbg(arizona->dev, "Detected jack\n");
 917                 ret = extcon_set_cable_state_(&info->edev,
 918                                               ARIZONA_CABLE_MECHANICAL, true);
 919
 920                 if (ret != 0)
 921                         dev_err(arizona->dev, "Mechanical report failed: %d\n",
 922                                 ret);
 923
 924                 if (!arizona->pdata.hpdet_acc_id) {
 925                         info->detecting = true;
 926                         info->mic = false;
 927                         info->jack_flips = 0;
 928
 929                         arizona_start_mic(info);
 930                 } else {
 931                         schedule_delayed_work(&info->hpdet_work,
 932                                               msecs_to_jiffies(HPDET_DEBOUNCE));
 933                 }
 934
 935                 regmap_update_bits(arizona->regmap,
 936                                    ARIZONA_JACK_DETECT_DEBOUNCE,
 937                                    ARIZONA_MICD_CLAMP_DB | ARIZONA_JD1_DB, 0);
 938         } else {
 939                 dev_dbg(arizona->dev, "Detected jack removal\n");
 940
 941                 arizona_stop_mic(info);
 942
 943                 info->num_hpdet_res = 0;
 944                 for (i = 0; i < ARRAY_SIZE(info->hpdet_res); i++)
 945                         info->hpdet_res[i] = 0;
 946                 info->mic = false;
 947                 info->hpdet_done = false;
 948
 949                 for (i = 0; i < info->num_micd_ranges; i++)
 950                         input_report_key(info->input,
 951                                          info->micd_ranges[i].key, 0);
 952                 input_sync(info->input);
 953
 954                 ret = extcon_update_state(&info->edev, 0xffffffff, 0);
 955                 if (ret != 0)
 956                         dev_err(arizona->dev, "Removal report failed: %d\n",
 957                                 ret);
 958
 959                 regmap_update_bits(arizona->regmap,
 960                                    ARIZONA_JACK_DETECT_DEBOUNCE,
 961                                    ARIZONA_MICD_CLAMP_DB | ARIZONA_JD1_DB,
 962                                    ARIZONA_MICD_CLAMP_DB | ARIZONA_JD1_DB);
 963         }
 964
 965         /* Clear trig_sts to make sure DCVDD is not forced up */
 966         regmap_write(arizona->regmap, ARIZONA_AOD_WKUP_AND_TRIG,
 967                      ARIZONA_MICD_CLAMP_FALL_TRIG_STS |
 968                      ARIZONA_MICD_CLAMP_RISE_TRIG_STS |
 969                      ARIZONA_JD1_FALL_TRIG_STS |
 970                      ARIZONA_JD1_RISE_TRIG_STS);
 971
 972 out:
 973         mutex_unlock(&info->lock);
 974
 975         pm_runtime_mark_last_busy(info->dev);
 976         pm_runtime_put_autosuspend(info->dev);
 977
 978         return IRQ_HANDLED;
 979 }
 980
 981 /* Map a level onto a slot in the register bank */
 982 static void arizona_micd_set_level(struct arizona *arizona, int index,
 983                                    unsigned int level)
 984 {
 985         int reg;
 986         unsigned int mask;
 987
 988         reg = ARIZONA_MIC_DETECT_LEVEL_4 - (index / 2);
 989
 990         if (!(index % 2)) {
 991                 mask = 0x3f00;
 992                 level <<= 8;
 993         } else {
 994                 mask = 0x3f;
 995         }
 996
 997         /* Program the level itself */
 998         regmap_update_bits(arizona->regmap, reg, mask, level);
 999 }
1000
1001 static int arizona_extcon_probe(struct platform_device *pdev)
1002 {
1003         struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
1004         struct arizona_pdata *pdata;
1005         struct arizona_extcon_info *info;
1006         unsigned int val;
1007         int jack_irq_fall, jack_irq_rise;
1008         int ret, mode, i, j;
1009
1010         if (!arizona->dapm || !arizona->dapm->card)
1011                 return -EPROBE_DEFER;
1012
1013         pdata = dev_get_platdata(arizona->dev);
1014
1015         info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
1016         if (!info) {
1017                 dev_err(&pdev->dev, "Failed to allocate memory\n");
1018                 ret = -ENOMEM;
1019                 goto err;
1020         }
1021
1022         info->micvdd = devm_regulator_get(arizona->dev, "MICVDD");
1023         if (IS_ERR(info->micvdd)) {
1024                 ret = PTR_ERR(info->micvdd);
1025                 dev_err(arizona->dev, "Failed to get MICVDD: %d\n", ret);
1026                 goto err;
1027         }
1028
1029         mutex_init(&info->lock);
1030         info->arizona = arizona;
1031         info->dev = &pdev->dev;
1032         info->last_jackdet = ~(ARIZONA_MICD_CLAMP_STS | ARIZONA_JD1_STS);
1033         INIT_DELAYED_WORK(&info->hpdet_work, arizona_hpdet_work);
1034         platform_set_drvdata(pdev, info);
1035
1036         switch (arizona->type) {
1037         case WM5102:
1038                 switch (arizona->rev) {
1039                 case 0:
1040                         info->micd_reva = true;
1041                         break;
1042                 default:
1043                         info->micd_clamp = true;
1044                         info->hpdet_ip = 1;
1045                         break;
1046                 }
1047                 break;
1048         default:
1049                 break;
1050         }
1051
1052         info->edev.name = "Headset Jack";
1053         info->edev.supported_cable = arizona_cable;
1054
1055         ret = extcon_dev_register(&info->edev, arizona->dev);
1056         if (ret < 0) {
1057                 dev_err(arizona->dev, "extcon_dev_register() failed: %d\n",
1058                         ret);
1059                 goto err;
1060         }
1061
1062         info->input = devm_input_allocate_device(&pdev->dev);
1063         if (!info->input) {
1064                 dev_err(arizona->dev, "Can't allocate input dev\n");
1065                 ret = -ENOMEM;
1066                 goto err_register;
1067         }
1068
1069         info->input->name = "Headset";
1070         info->input->phys = "arizona/extcon";
1071         info->input->dev.parent = &pdev->dev;
1072
1073         if (pdata->num_micd_configs) {
1074                 info->micd_modes = pdata->micd_configs;
1075                 info->micd_num_modes = pdata->num_micd_configs;
1076         } else {
1077                 info->micd_modes = micd_default_modes;
1078                 info->micd_num_modes = ARRAY_SIZE(micd_default_modes);
1079         }
1080
1081         if (arizona->pdata.micd_pol_gpio > 0) {
1082                 if (info->micd_modes[0].gpio)
1083                         mode = GPIOF_OUT_INIT_HIGH;
1084                 else
1085                         mode = GPIOF_OUT_INIT_LOW;
1086
1087                 ret = devm_gpio_request_one(&pdev->dev,
1088                                             arizona->pdata.micd_pol_gpio,
1089                                             mode,
1090                                             "MICD polarity");
1091                 if (ret != 0) {
1092                         dev_err(arizona->dev, "Failed to request GPIO%d: %d\n",
1093                                 arizona->pdata.micd_pol_gpio, ret);
1094                         goto err_register;
1095                 }
1096         }
1097
1098         if (arizona->pdata.hpdet_id_gpio > 0) {
1099                 ret = devm_gpio_request_one(&pdev->dev,
1100                                             arizona->pdata.hpdet_id_gpio,
1101                                             GPIOF_OUT_INIT_LOW,
1102                                             "HPDET");
1103                 if (ret != 0) {
1104                         dev_err(arizona->dev, "Failed to request GPIO%d: %d\n",
1105                                 arizona->pdata.hpdet_id_gpio, ret);
1106                         goto err_register;
1107                 }
1108         }
1109
1110         if (arizona->pdata.micd_bias_start_time)
1111                 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1112                                    ARIZONA_MICD_BIAS_STARTTIME_MASK,
1113                                    arizona->pdata.micd_bias_start_time
1114                                    << ARIZONA_MICD_BIAS_STARTTIME_SHIFT);
1115
1116         if (arizona->pdata.micd_rate)
1117                 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1118                                    ARIZONA_MICD_RATE_MASK,
1119                                    arizona->pdata.micd_rate
1120                                    << ARIZONA_MICD_RATE_SHIFT);
1121
1122         if (arizona->pdata.micd_dbtime)
1123                 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1124                                    ARIZONA_MICD_DBTIME_MASK,
1125                                    arizona->pdata.micd_dbtime
1126                                    << ARIZONA_MICD_DBTIME_SHIFT);
1127
1128         BUILD_BUG_ON(ARRAY_SIZE(arizona_micd_levels) != 0x40);
1129
1130         if (arizona->pdata.num_micd_ranges) {
1131                 info->micd_ranges = pdata->micd_ranges;
1132                 info->num_micd_ranges = pdata->num_micd_ranges;
1133         } else {
1134                 info->micd_ranges = micd_default_ranges;
1135                 info->num_micd_ranges = ARRAY_SIZE(micd_default_ranges);
1136         }
1137
1138         if (arizona->pdata.num_micd_ranges > ARIZONA_MAX_MICD_RANGE) {
1139                 dev_err(arizona->dev, "Too many MICD ranges: %d\n",
1140                         arizona->pdata.num_micd_ranges);
1141         }
1142
1143         if (info->num_micd_ranges > 1) {
1144                 for (i = 1; i < info->num_micd_ranges; i++) {
1145                         if (info->micd_ranges[i - 1].max >
1146                             info->micd_ranges[i].max) {
1147                                 dev_err(arizona->dev,
1148                                         "MICD ranges must be sorted\n");
1149                                 ret = -EINVAL;
1150                                 goto err_input;
1151                         }
1152                 }
1153         }
1154
1155         /* Disable all buttons by default */
1156         regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_2,
1157                            ARIZONA_MICD_LVL_SEL_MASK, 0x81);
1158
1159         /* Set up all the buttons the user specified */
1160         for (i = 0; i < info->num_micd_ranges; i++) {
1161                 for (j = 0; j < ARRAY_SIZE(arizona_micd_levels); j++)
1162                         if (arizona_micd_levels[j] >= info->micd_ranges[i].max)
1163                                 break;
1164
1165                 if (j == ARRAY_SIZE(arizona_micd_levels)) {
1166                         dev_err(arizona->dev, "Unsupported MICD level %d\n",
1167                                 info->micd_ranges[i].max);
1168                         ret = -EINVAL;
1169                         goto err_input;
1170                 }
1171
1172                 dev_dbg(arizona->dev, "%d ohms for MICD threshold %d\n",
1173                         arizona_micd_levels[j], i);
1174
1175                 arizona_micd_set_level(arizona, i, j);
1176                 input_set_capability(info->input, EV_KEY,
1177                                      info->micd_ranges[i].key);
1178
1179                 /* Enable reporting of that range */
1180                 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_2,
1181                                    1 << i, 1 << i);
1182         }
1183
1184         /* Set all the remaining keys to a maximum */
1185         for (; i < ARIZONA_MAX_MICD_RANGE; i++)
1186                 arizona_micd_set_level(arizona, i, 0x3f);
1187
1188         /*
1189          * If we have a clamp use it, activating in conjunction with
1190          * GPIO5 if that is connected for jack detect operation.
1191          */
1192         if (info->micd_clamp) {
1193                 if (arizona->pdata.jd_gpio5) {
1194                         /* Put the GPIO into input mode with optional pull */
1195                         val = 0xc101;
1196                         if (arizona->pdata.jd_gpio5_nopull)
1197                                 val &= ~ARIZONA_GPN_PU;
1198
1199                         regmap_write(arizona->regmap, ARIZONA_GPIO5_CTRL,
1200                                      val);
1201
1202                         regmap_update_bits(arizona->regmap,
1203                                            ARIZONA_MICD_CLAMP_CONTROL,
1204                                            ARIZONA_MICD_CLAMP_MODE_MASK, 0x9);
1205                 } else {
1206                         regmap_update_bits(arizona->regmap,
1207                                            ARIZONA_MICD_CLAMP_CONTROL,
1208                                            ARIZONA_MICD_CLAMP_MODE_MASK, 0x4);
1209                 }
1210
1211                 regmap_update_bits(arizona->regmap,
1212                                    ARIZONA_JACK_DETECT_DEBOUNCE,
1213                                    ARIZONA_MICD_CLAMP_DB,
1214                                    ARIZONA_MICD_CLAMP_DB);
1215         }
1216
1217         arizona_extcon_set_mode(info, 0);
1218
1219         pm_runtime_enable(&pdev->dev);
1220         pm_runtime_idle(&pdev->dev);
1221         pm_runtime_get_sync(&pdev->dev);
1222
1223         if (arizona->pdata.jd_gpio5) {
1224                 jack_irq_rise = ARIZONA_IRQ_MICD_CLAMP_RISE;
1225                 jack_irq_fall = ARIZONA_IRQ_MICD_CLAMP_FALL;
1226         } else {
1227                 jack_irq_rise = ARIZONA_IRQ_JD_RISE;
1228                 jack_irq_fall = ARIZONA_IRQ_JD_FALL;
1229         }
1230
1231         ret = arizona_request_irq(arizona, jack_irq_rise,
1232                                   "JACKDET rise", arizona_jackdet, info);
1233         if (ret != 0) {
1234                 dev_err(&pdev->dev, "Failed to get JACKDET rise IRQ: %d\n",
1235                         ret);
1236                 goto err_input;
1237         }
1238
1239         ret = arizona_set_irq_wake(arizona, jack_irq_rise, 1);
1240         if (ret != 0) {
1241                 dev_err(&pdev->dev, "Failed to set JD rise IRQ wake: %d\n",
1242                         ret);
1243                 goto err_rise;
1244         }
1245
1246         ret = arizona_request_irq(arizona, jack_irq_fall,
1247                                   "JACKDET fall", arizona_jackdet, info);
1248         if (ret != 0) {
1249                 dev_err(&pdev->dev, "Failed to get JD fall IRQ: %d\n", ret);
1250                 goto err_rise_wake;
1251         }
1252
1253         ret = arizona_set_irq_wake(arizona, jack_irq_fall, 1);
1254         if (ret != 0) {
1255                 dev_err(&pdev->dev, "Failed to set JD fall IRQ wake: %d\n",
1256                         ret);
1257                 goto err_fall;
1258         }
1259
1260         ret = arizona_request_irq(arizona, ARIZONA_IRQ_MICDET,
1261                                   "MICDET", arizona_micdet, info);
1262         if (ret != 0) {
1263                 dev_err(&pdev->dev, "Failed to get MICDET IRQ: %d\n", ret);
1264                 goto err_fall_wake;
1265         }
1266
1267         ret = arizona_request_irq(arizona, ARIZONA_IRQ_HPDET,
1268                                   "HPDET", arizona_hpdet_irq, info);
1269         if (ret != 0) {
1270                 dev_err(&pdev->dev, "Failed to get HPDET IRQ: %d\n", ret);
1271                 goto err_micdet;
1272         }
1273
1274         arizona_clk32k_enable(arizona);
1275         regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_DEBOUNCE,
1276                            ARIZONA_JD1_DB, ARIZONA_JD1_DB);
1277         regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE,
1278                            ARIZONA_JD1_ENA, ARIZONA_JD1_ENA);
1279
1280         ret = regulator_allow_bypass(info->micvdd, true);
1281         if (ret != 0)
1282                 dev_warn(arizona->dev, "Failed to set MICVDD to bypass: %d\n",
1283                          ret);
1284
1285         pm_runtime_put(&pdev->dev);
1286
1287         ret = input_register_device(info->input);
1288         if (ret) {
1289                 dev_err(&pdev->dev, "Can't register input device: %d\n", ret);
1290                 goto err_hpdet;
1291         }
1292
1293         return 0;
1294
1295 err_hpdet:
1296         arizona_free_irq(arizona, ARIZONA_IRQ_HPDET, info);
1297 err_micdet:
1298         arizona_free_irq(arizona, ARIZONA_IRQ_MICDET, info);
1299 err_fall_wake:
1300         arizona_set_irq_wake(arizona, jack_irq_fall, 0);
1301 err_fall:
1302         arizona_free_irq(arizona, jack_irq_fall, info);
1303 err_rise_wake:
1304         arizona_set_irq_wake(arizona, jack_irq_rise, 0);
1305 err_rise:
1306         arizona_free_irq(arizona, jack_irq_rise, info);
1307 err_input:
1308 err_register:
1309         pm_runtime_disable(&pdev->dev);
1310         extcon_dev_unregister(&info->edev);
1311 err:
1312         return ret;
1313 }
1314
1315 static int arizona_extcon_remove(struct platform_device *pdev)
1316 {
1317         struct arizona_extcon_info *info = platform_get_drvdata(pdev);
1318         struct arizona *arizona = info->arizona;
1319         int jack_irq_rise, jack_irq_fall;
1320
1321         pm_runtime_disable(&pdev->dev);
1322
1323         regmap_update_bits(arizona->regmap,
1324                            ARIZONA_MICD_CLAMP_CONTROL,
1325                            ARIZONA_MICD_CLAMP_MODE_MASK, 0);
1326
1327         if (arizona->pdata.jd_gpio5) {
1328                 jack_irq_rise = ARIZONA_IRQ_MICD_CLAMP_RISE;
1329                 jack_irq_fall = ARIZONA_IRQ_MICD_CLAMP_FALL;
1330         } else {
1331                 jack_irq_rise = ARIZONA_IRQ_JD_RISE;
1332                 jack_irq_fall = ARIZONA_IRQ_JD_FALL;
1333         }
1334
1335         arizona_set_irq_wake(arizona, jack_irq_rise, 0);
1336         arizona_set_irq_wake(arizona, jack_irq_fall, 0);
1337         arizona_free_irq(arizona, ARIZONA_IRQ_HPDET, info);
1338         arizona_free_irq(arizona, ARIZONA_IRQ_MICDET, info);
1339         arizona_free_irq(arizona, jack_irq_rise, info);
1340         arizona_free_irq(arizona, jack_irq_fall, info);
1341         cancel_delayed_work_sync(&info->hpdet_work);
1342         regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE,
1343                            ARIZONA_JD1_ENA, 0);
1344         arizona_clk32k_disable(arizona);
1345         extcon_dev_unregister(&info->edev);
1346
1347         return 0;
1348 }
1349
1350 static struct platform_driver arizona_extcon_driver = {
1351         .driver         = {
1352                 .name   = "arizona-extcon",
1353                 .owner  = THIS_MODULE,
1354         },
1355         .probe          = arizona_extcon_probe,
1356         .remove         = arizona_extcon_remove,
1357 };
1358
1359 module_platform_driver(arizona_extcon_driver);
1360
1361 MODULE_DESCRIPTION("Arizona Extcon driver");
1362 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
1363 MODULE_LICENSE("GPL");
1364 MODULE_ALIAS("platform:extcon-arizona");