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