drivers/extcon/extcon-arizona.c

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