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;
 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         ret = extcon_get_state(info->edev, EXTCON_MECHANICAL);
 618         if (ret < 0) {
 619                 dev_err(arizona->dev, "Failed to check cable state: %d\n",
 620                         ret);
 621                 goto out;
 622         } else if (!ret) {
 623                 dev_dbg(arizona->dev, "Ignoring HPDET for removed cable\n");
 624                 goto done;
 625         }
 626
 627         ret = arizona_hpdet_read(info);
 628         if (ret == -EAGAIN)
 629                 goto out;
 630         else if (ret < 0)
 631                 goto done;
 632         reading = ret;
 633
 634         /* Reset back to starting range */
 635         regmap_update_bits(arizona->regmap,
 636                            ARIZONA_HEADPHONE_DETECT_1,
 637                            ARIZONA_HP_IMPEDANCE_RANGE_MASK | ARIZONA_HP_POLL,
 638                            0);
 639
 640         ret = arizona_hpdet_do_id(info, &reading, &mic);
 641         if (ret == -EAGAIN)
 642                 goto out;
 643         else if (ret < 0)
 644                 goto done;
 645
 646         /* Report high impedence cables as line outputs */
 647         if (reading >= 5000)
 648                 report = EXTCON_JACK_LINE_OUT;
 649         else
 650                 report = EXTCON_JACK_HEADPHONE;
 651
 652         ret = extcon_set_state_sync(info->edev, report, true);
 653         if (ret != 0)
 654                 dev_err(arizona->dev, "Failed to report HP/line: %d\n",
 655                         ret);
 656
 657 done:
 658         /* Reset back to starting range */
 659         regmap_update_bits(arizona->regmap,
 660                            ARIZONA_HEADPHONE_DETECT_1,
 661                            ARIZONA_HP_IMPEDANCE_RANGE_MASK | ARIZONA_HP_POLL,
 662                            0);
 663
 664         arizona_extcon_hp_clamp(info, false);
 665
 666         if (id_gpio)
 667                 gpio_set_value_cansleep(id_gpio, 0);
 668
 669         /* Revert back to MICDET mode */
 670         regmap_update_bits(arizona->regmap,
 671                            ARIZONA_ACCESSORY_DETECT_MODE_1,
 672                            ARIZONA_ACCDET_MODE_MASK, ARIZONA_ACCDET_MODE_MIC);
 673
 674         /* If we have a mic then reenable MICDET */
 675         if (mic || info->mic)
 676                 arizona_start_mic(info);
 677
 678         if (info->hpdet_active) {
 679                 pm_runtime_put_autosuspend(info->dev);
 680                 info->hpdet_active = false;
 681         }
 682
 683         info->hpdet_done = true;
 684
 685 out:
 686         mutex_unlock(&info->lock);
 687
 688         return IRQ_HANDLED;
 689 }
 690
 691 static void arizona_identify_headphone(struct arizona_extcon_info *info)
 692 {
 693         struct arizona *arizona = info->arizona;
 694         int ret;
 695
 696         if (info->hpdet_done)
 697                 return;
 698
 699         dev_dbg(arizona->dev, "Starting HPDET\n");
 700
 701         /* Make sure we keep the device enabled during the measurement */
 702         pm_runtime_get(info->dev);
 703
 704         info->hpdet_active = true;
 705
 706         if (info->mic)
 707                 arizona_stop_mic(info);
 708
 709         arizona_extcon_hp_clamp(info, true);
 710
 711         ret = regmap_update_bits(arizona->regmap,
 712                                  ARIZONA_ACCESSORY_DETECT_MODE_1,
 713                                  ARIZONA_ACCDET_MODE_MASK,
 714                                  arizona->pdata.hpdet_channel);
 715         if (ret != 0) {
 716                 dev_err(arizona->dev, "Failed to set HPDET mode: %d\n", ret);
 717                 goto err;
 718         }
 719
 720         ret = regmap_update_bits(arizona->regmap, ARIZONA_HEADPHONE_DETECT_1,
 721                                  ARIZONA_HP_POLL, ARIZONA_HP_POLL);
 722         if (ret != 0) {
 723                 dev_err(arizona->dev, "Can't start HPDETL measurement: %d\n",
 724                         ret);
 725                 goto err;
 726         }
 727
 728         return;
 729
 730 err:
 731         regmap_update_bits(arizona->regmap, ARIZONA_ACCESSORY_DETECT_MODE_1,
 732                            ARIZONA_ACCDET_MODE_MASK, ARIZONA_ACCDET_MODE_MIC);
 733
 734         /* Just report headphone */
 735         ret = extcon_set_state_sync(info->edev, EXTCON_JACK_HEADPHONE, true);
 736         if (ret != 0)
 737                 dev_err(arizona->dev, "Failed to report headphone: %d\n", ret);
 738
 739         if (info->mic)
 740                 arizona_start_mic(info);
 741
 742         info->hpdet_active = false;
 743 }
 744
 745 static void arizona_start_hpdet_acc_id(struct arizona_extcon_info *info)
 746 {
 747         struct arizona *arizona = info->arizona;
 748         int hp_reading = 32;
 749         bool mic;
 750         int ret;
 751
 752         dev_dbg(arizona->dev, "Starting identification via HPDET\n");
 753
 754         /* Make sure we keep the device enabled during the measurement */
 755         pm_runtime_get_sync(info->dev);
 756
 757         info->hpdet_active = true;
 758
 759         arizona_extcon_hp_clamp(info, true);
 760
 761         ret = regmap_update_bits(arizona->regmap,
 762                                  ARIZONA_ACCESSORY_DETECT_MODE_1,
 763                                  ARIZONA_ACCDET_SRC | ARIZONA_ACCDET_MODE_MASK,
 764                                  info->micd_modes[0].src |
 765                                  arizona->pdata.hpdet_channel);
 766         if (ret != 0) {
 767                 dev_err(arizona->dev, "Failed to set HPDET mode: %d\n", ret);
 768                 goto err;
 769         }
 770
 771         if (arizona->pdata.hpdet_acc_id_line) {
 772                 ret = regmap_update_bits(arizona->regmap,
 773                                          ARIZONA_HEADPHONE_DETECT_1,
 774                                          ARIZONA_HP_POLL, ARIZONA_HP_POLL);
 775                 if (ret != 0) {
 776                         dev_err(arizona->dev,
 777                                 "Can't start HPDETL measurement: %d\n",
 778                                 ret);
 779                         goto err;
 780                 }
 781         } else {
 782                 arizona_hpdet_do_id(info, &hp_reading, &mic);
 783         }
 784
 785         return;
 786
 787 err:
 788         regmap_update_bits(arizona->regmap, ARIZONA_ACCESSORY_DETECT_MODE_1,
 789                            ARIZONA_ACCDET_MODE_MASK, ARIZONA_ACCDET_MODE_MIC);
 790
 791         /* Just report headphone */
 792         ret = extcon_set_state_sync(info->edev, EXTCON_JACK_HEADPHONE, true);
 793         if (ret != 0)
 794                 dev_err(arizona->dev, "Failed to report headphone: %d\n", ret);
 795
 796         info->hpdet_active = false;
 797 }
 798
 799 static void arizona_micd_timeout_work(struct work_struct *work)
 800 {
 801         struct arizona_extcon_info *info = container_of(work,
 802                                                 struct arizona_extcon_info,
 803                                                 micd_timeout_work.work);
 804
 805         mutex_lock(&info->lock);
 806
 807         dev_dbg(info->arizona->dev, "MICD timed out, reporting HP\n");
 808
 809         info->detecting = false;
 810
 811         arizona_identify_headphone(info);
 812
 813         arizona_stop_mic(info);
 814
 815         mutex_unlock(&info->lock);
 816 }
 817
 818 static void arizona_micd_detect(struct work_struct *work)
 819 {
 820         struct arizona_extcon_info *info = container_of(work,
 821                                                 struct arizona_extcon_info,
 822                                                 micd_detect_work.work);
 823         struct arizona *arizona = info->arizona;
 824         unsigned int val = 0, lvl;
 825         int ret, i, key;
 826
 827         cancel_delayed_work_sync(&info->micd_timeout_work);
 828
 829         mutex_lock(&info->lock);
 830
 831         /* If the cable was removed while measuring ignore the result */
 832         ret = extcon_get_state(info->edev, EXTCON_MECHANICAL);
 833         if (ret < 0) {
 834                 dev_err(arizona->dev, "Failed to check cable state: %d\n",
 835                                 ret);
 836                 mutex_unlock(&info->lock);
 837                 return;
 838         } else if (!ret) {
 839                 dev_dbg(arizona->dev, "Ignoring MICDET for removed cable\n");
 840                 mutex_unlock(&info->lock);
 841                 return;
 842         }
 843
 844         if (info->detecting && arizona->pdata.micd_software_compare) {
 845                 /* Must disable MICD before we read the ADCVAL */
 846                 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
 847                                    ARIZONA_MICD_ENA, 0);
 848                 ret = regmap_read(arizona->regmap, ARIZONA_MIC_DETECT_4, &val);
 849                 if (ret != 0) {
 850                         dev_err(arizona->dev,
 851                                 "Failed to read MICDET_ADCVAL: %d\n",
 852                                 ret);
 853                         mutex_unlock(&info->lock);
 854                         return;
 855                 }
 856
 857                 dev_dbg(arizona->dev, "MICDET_ADCVAL: %x\n", val);
 858
 859                 val &= ARIZONA_MICDET_ADCVAL_MASK;
 860                 if (val < ARRAY_SIZE(arizona_micd_levels))
 861                         val = arizona_micd_levels[val];
 862                 else
 863                         val = INT_MAX;
 864
 865                 if (val <= QUICK_HEADPHONE_MAX_OHM)
 866                         val = ARIZONA_MICD_STS | ARIZONA_MICD_LVL_0;
 867                 else if (val <= MICROPHONE_MIN_OHM)
 868                         val = ARIZONA_MICD_STS | ARIZONA_MICD_LVL_1;
 869                 else if (val <= MICROPHONE_MAX_OHM)
 870                         val = ARIZONA_MICD_STS | ARIZONA_MICD_LVL_8;
 871                 else
 872                         val = ARIZONA_MICD_LVL_8;
 873         }
 874
 875         for (i = 0; i < 10 && !(val & MICD_LVL_0_TO_8); i++) {
 876                 ret = regmap_read(arizona->regmap, ARIZONA_MIC_DETECT_3, &val);
 877                 if (ret != 0) {
 878                         dev_err(arizona->dev,
 879                                 "Failed to read MICDET: %d\n", ret);
 880                         mutex_unlock(&info->lock);
 881                         return;
 882                 }
 883
 884                 dev_dbg(arizona->dev, "MICDET: %x\n", val);
 885
 886                 if (!(val & ARIZONA_MICD_VALID)) {
 887                         dev_warn(arizona->dev,
 888                                  "Microphone detection state invalid\n");
 889                         mutex_unlock(&info->lock);
 890                         return;
 891                 }
 892         }
 893
 894         if (i == 10 && !(val & MICD_LVL_0_TO_8)) {
 895                 dev_err(arizona->dev, "Failed to get valid MICDET value\n");
 896                 mutex_unlock(&info->lock);
 897                 return;
 898         }
 899
 900         /* Due to jack detect this should never happen */
 901         if (!(val & ARIZONA_MICD_STS)) {
 902                 dev_warn(arizona->dev, "Detected open circuit\n");
 903                 info->mic = false;
 904                 arizona_stop_mic(info);
 905                 info->detecting = false;
 906                 arizona_identify_headphone(info);
 907                 goto handled;
 908         }
 909
 910         /* If we got a high impedence we should have a headset, report it. */
 911         if (info->detecting && (val & ARIZONA_MICD_LVL_8)) {
 912                 info->mic = true;
 913                 info->detecting = false;
 914
 915                 arizona_identify_headphone(info);
 916
 917                 ret = extcon_set_state_sync(info->edev,
 918                                               EXTCON_JACK_MICROPHONE, true);
 919                 if (ret != 0)
 920                         dev_err(arizona->dev, "Headset report failed: %d\n",
 921                                 ret);
 922
 923                 /* Don't need to regulate for button detection */
 924                 ret = regulator_allow_bypass(info->micvdd, true);
 925                 if (ret != 0) {
 926                         dev_err(arizona->dev, "Failed to bypass MICVDD: %d\n",
 927                                 ret);
 928                 }
 929
 930                 goto handled;
 931         }
 932
 933         /* If we detected a lower impedence during initial startup
 934          * then we probably have the wrong polarity, flip it.  Don't
 935          * do this for the lowest impedences to speed up detection of
 936          * plain headphones.  If both polarities report a low
 937          * impedence then give up and report headphones.
 938          */
 939         if (info->detecting && (val & MICD_LVL_1_TO_7)) {
 940                 if (info->jack_flips >= info->micd_num_modes * 10) {
 941                         dev_dbg(arizona->dev, "Detected HP/line\n");
 942
 943                         info->detecting = false;
 944
 945                         arizona_identify_headphone(info);
 946
 947                         arizona_stop_mic(info);
 948                 } else {
 949                         info->micd_mode++;
 950                         if (info->micd_mode == info->micd_num_modes)
 951                                 info->micd_mode = 0;
 952                         arizona_extcon_set_mode(info, info->micd_mode);
 953
 954                         info->jack_flips++;
 955                 }
 956
 957                 goto handled;
 958         }
 959
 960         /*
 961          * If we're still detecting and we detect a short then we've
 962          * got a headphone.  Otherwise it's a button press.
 963          */
 964         if (val & MICD_LVL_0_TO_7) {
 965                 if (info->mic) {
 966                         dev_dbg(arizona->dev, "Mic button detected\n");
 967
 968                         lvl = val & ARIZONA_MICD_LVL_MASK;
 969                         lvl >>= ARIZONA_MICD_LVL_SHIFT;
 970
 971                         for (i = 0; i < info->num_micd_ranges; i++)
 972                                 input_report_key(info->input,
 973                                                  info->micd_ranges[i].key, 0);
 974
 975                         WARN_ON(!lvl);
 976                         WARN_ON(ffs(lvl) - 1 >= info->num_micd_ranges);
 977                         if (lvl && ffs(lvl) - 1 < info->num_micd_ranges) {
 978                                 key = info->micd_ranges[ffs(lvl) - 1].key;
 979                                 input_report_key(info->input, key, 1);
 980                                 input_sync(info->input);
 981                         }
 982
 983                 } else if (info->detecting) {
 984                         dev_dbg(arizona->dev, "Headphone detected\n");
 985                         info->detecting = false;
 986                         arizona_stop_mic(info);
 987
 988                         arizona_identify_headphone(info);
 989                 } else {
 990                         dev_warn(arizona->dev, "Button with no mic: %x\n",
 991                                  val);
 992                 }
 993         } else {
 994                 dev_dbg(arizona->dev, "Mic button released\n");
 995                 for (i = 0; i < info->num_micd_ranges; i++)
 996                         input_report_key(info->input,
 997                                          info->micd_ranges[i].key, 0);
 998                 input_sync(info->input);
 999                 arizona_extcon_pulse_micbias(info);
1000         }
1001
1002 handled:
1003         if (info->detecting) {
1004                 if (arizona->pdata.micd_software_compare)
1005                         regmap_update_bits(arizona->regmap,
1006                                            ARIZONA_MIC_DETECT_1,
1007                                            ARIZONA_MICD_ENA,
1008                                            ARIZONA_MICD_ENA);
1009
1010                 queue_delayed_work(system_power_efficient_wq,
1011                                    &info->micd_timeout_work,
1012                                    msecs_to_jiffies(info->micd_timeout));
1013         }
1014
1015         pm_runtime_mark_last_busy(info->dev);
1016         mutex_unlock(&info->lock);
1017 }
1018
1019 static irqreturn_t arizona_micdet(int irq, void *data)
1020 {
1021         struct arizona_extcon_info *info = data;
1022         struct arizona *arizona = info->arizona;
1023         int debounce = arizona->pdata.micd_detect_debounce;
1024
1025         cancel_delayed_work_sync(&info->micd_detect_work);
1026         cancel_delayed_work_sync(&info->micd_timeout_work);
1027
1028         mutex_lock(&info->lock);
1029         if (!info->detecting)
1030                 debounce = 0;
1031         mutex_unlock(&info->lock);
1032
1033         if (debounce)
1034                 queue_delayed_work(system_power_efficient_wq,
1035                                    &info->micd_detect_work,
1036                                    msecs_to_jiffies(debounce));
1037         else
1038                 arizona_micd_detect(&info->micd_detect_work.work);
1039
1040         return IRQ_HANDLED;
1041 }
1042
1043 static void arizona_hpdet_work(struct work_struct *work)
1044 {
1045         struct arizona_extcon_info *info = container_of(work,
1046                                                 struct arizona_extcon_info,
1047                                                 hpdet_work.work);
1048
1049         mutex_lock(&info->lock);
1050         arizona_start_hpdet_acc_id(info);
1051         mutex_unlock(&info->lock);
1052 }
1053
1054 static irqreturn_t arizona_jackdet(int irq, void *data)
1055 {
1056         struct arizona_extcon_info *info = data;
1057         struct arizona *arizona = info->arizona;
1058         unsigned int val, present, mask;
1059         bool cancelled_hp, cancelled_mic;
1060         int ret, i;
1061
1062         cancelled_hp = cancel_delayed_work_sync(&info->hpdet_work);
1063         cancelled_mic = cancel_delayed_work_sync(&info->micd_timeout_work);
1064
1065         pm_runtime_get_sync(info->dev);
1066
1067         mutex_lock(&info->lock);
1068
1069         if (info->micd_clamp) {
1070                 mask = ARIZONA_MICD_CLAMP_STS;
1071                 present = 0;
1072         } else {
1073                 mask = ARIZONA_JD1_STS;
1074                 if (arizona->pdata.jd_invert)
1075                         present = 0;
1076                 else
1077                         present = ARIZONA_JD1_STS;
1078         }
1079
1080         ret = regmap_read(arizona->regmap, ARIZONA_AOD_IRQ_RAW_STATUS, &val);
1081         if (ret != 0) {
1082                 dev_err(arizona->dev, "Failed to read jackdet status: %d\n",
1083                         ret);
1084                 mutex_unlock(&info->lock);
1085                 pm_runtime_put_autosuspend(info->dev);
1086                 return IRQ_NONE;
1087         }
1088
1089         val &= mask;
1090         if (val == info->last_jackdet) {
1091                 dev_dbg(arizona->dev, "Suppressing duplicate JACKDET\n");
1092                 if (cancelled_hp)
1093                         queue_delayed_work(system_power_efficient_wq,
1094                                            &info->hpdet_work,
1095                                            msecs_to_jiffies(HPDET_DEBOUNCE));
1096
1097                 if (cancelled_mic) {
1098                         int micd_timeout = info->micd_timeout;
1099
1100                         queue_delayed_work(system_power_efficient_wq,
1101                                            &info->micd_timeout_work,
1102                                            msecs_to_jiffies(micd_timeout));
1103                 }
1104
1105                 goto out;
1106         }
1107         info->last_jackdet = val;
1108
1109         if (info->last_jackdet == present) {
1110                 dev_dbg(arizona->dev, "Detected jack\n");
1111                 ret = extcon_set_state_sync(info->edev,
1112                                               EXTCON_MECHANICAL, true);
1113
1114                 if (ret != 0)
1115                         dev_err(arizona->dev, "Mechanical report failed: %d\n",
1116                                 ret);
1117
1118                 if (!arizona->pdata.hpdet_acc_id) {
1119                         info->detecting = true;
1120                         info->mic = false;
1121                         info->jack_flips = 0;
1122
1123                         arizona_start_mic(info);
1124                 } else {
1125                         queue_delayed_work(system_power_efficient_wq,
1126                                            &info->hpdet_work,
1127                                            msecs_to_jiffies(HPDET_DEBOUNCE));
1128                 }
1129
1130                 if (info->micd_clamp || !arizona->pdata.jd_invert)
1131                         regmap_update_bits(arizona->regmap,
1132                                            ARIZONA_JACK_DETECT_DEBOUNCE,
1133                                            ARIZONA_MICD_CLAMP_DB |
1134                                            ARIZONA_JD1_DB, 0);
1135         } else {
1136                 dev_dbg(arizona->dev, "Detected jack removal\n");
1137
1138                 arizona_stop_mic(info);
1139
1140                 info->num_hpdet_res = 0;
1141                 for (i = 0; i < ARRAY_SIZE(info->hpdet_res); i++)
1142                         info->hpdet_res[i] = 0;
1143                 info->mic = false;
1144                 info->hpdet_done = false;
1145                 info->hpdet_retried = false;
1146
1147                 for (i = 0; i < info->num_micd_ranges; i++)
1148                         input_report_key(info->input,
1149                                          info->micd_ranges[i].key, 0);
1150                 input_sync(info->input);
1151
1152                 for (i = 0; i < ARRAY_SIZE(arizona_cable) - 1; i++) {
1153                         ret = extcon_set_state_sync(info->edev,
1154                                         arizona_cable[i], false);
1155                         if (ret != 0)
1156                                 dev_err(arizona->dev,
1157                                         "Removal report failed: %d\n", ret);
1158                 }
1159
1160                 regmap_update_bits(arizona->regmap,
1161                                    ARIZONA_JACK_DETECT_DEBOUNCE,
1162                                    ARIZONA_MICD_CLAMP_DB | ARIZONA_JD1_DB,
1163                                    ARIZONA_MICD_CLAMP_DB | ARIZONA_JD1_DB);
1164         }
1165
1166         if (arizona->pdata.micd_timeout)
1167                 info->micd_timeout = arizona->pdata.micd_timeout;
1168         else
1169                 info->micd_timeout = DEFAULT_MICD_TIMEOUT;
1170
1171 out:
1172         /* Clear trig_sts to make sure DCVDD is not forced up */
1173         regmap_write(arizona->regmap, ARIZONA_AOD_WKUP_AND_TRIG,
1174                      ARIZONA_MICD_CLAMP_FALL_TRIG_STS |
1175                      ARIZONA_MICD_CLAMP_RISE_TRIG_STS |
1176                      ARIZONA_JD1_FALL_TRIG_STS |
1177                      ARIZONA_JD1_RISE_TRIG_STS);
1178
1179         mutex_unlock(&info->lock);
1180
1181         pm_runtime_mark_last_busy(info->dev);
1182         pm_runtime_put_autosuspend(info->dev);
1183
1184         return IRQ_HANDLED;
1185 }
1186
1187 /* Map a level onto a slot in the register bank */
1188 static void arizona_micd_set_level(struct arizona *arizona, int index,
1189                                    unsigned int level)
1190 {
1191         int reg;
1192         unsigned int mask;
1193
1194         reg = ARIZONA_MIC_DETECT_LEVEL_4 - (index / 2);
1195
1196         if (!(index % 2)) {
1197                 mask = 0x3f00;
1198                 level <<= 8;
1199         } else {
1200                 mask = 0x3f;
1201         }
1202
1203         /* Program the level itself */
1204         regmap_update_bits(arizona->regmap, reg, mask, level);
1205 }
1206
1207 static int arizona_extcon_get_micd_configs(struct device *dev,
1208                                            struct arizona *arizona)
1209 {
1210         const char * const prop = "wlf,micd-configs";
1211         const int entries_per_config = 3;
1212         struct arizona_micd_config *micd_configs;
1213         int nconfs, ret;
1214         int i, j;
1215         u32 *vals;
1216
1217         nconfs = device_property_read_u32_array(arizona->dev, prop, NULL, 0);
1218         if (nconfs <= 0)
1219                 return 0;
1220
1221         vals = kcalloc(nconfs, sizeof(u32), GFP_KERNEL);
1222         if (!vals)
1223                 return -ENOMEM;
1224
1225         ret = device_property_read_u32_array(arizona->dev, prop, vals, nconfs);
1226         if (ret < 0)
1227                 goto out;
1228
1229         nconfs /= entries_per_config;
1230
1231         micd_configs = devm_kzalloc(dev,
1232                                     nconfs * sizeof(struct arizona_micd_range),
1233                                     GFP_KERNEL);
1234         if (!micd_configs) {
1235                 ret = -ENOMEM;
1236                 goto out;
1237         }
1238
1239         for (i = 0, j = 0; i < nconfs; ++i) {
1240                 micd_configs[i].src = vals[j++] ? ARIZONA_ACCDET_SRC : 0;
1241                 micd_configs[i].bias = vals[j++];
1242                 micd_configs[i].gpio = vals[j++];
1243         }
1244
1245         arizona->pdata.micd_configs = micd_configs;
1246         arizona->pdata.num_micd_configs = nconfs;
1247
1248 out:
1249         kfree(vals);
1250         return ret;
1251 }
1252
1253 static int arizona_extcon_device_get_pdata(struct device *dev,
1254                                            struct arizona *arizona)
1255 {
1256         struct arizona_pdata *pdata = &arizona->pdata;
1257         unsigned int val = ARIZONA_ACCDET_MODE_HPL;
1258         int ret;
1259
1260         device_property_read_u32(arizona->dev, "wlf,hpdet-channel", &val);
1261         switch (val) {
1262         case ARIZONA_ACCDET_MODE_HPL:
1263         case ARIZONA_ACCDET_MODE_HPR:
1264                 pdata->hpdet_channel = val;
1265                 break;
1266         default:
1267                 dev_err(arizona->dev,
1268                         "Wrong wlf,hpdet-channel DT value %d\n", val);
1269                 pdata->hpdet_channel = ARIZONA_ACCDET_MODE_HPL;
1270         }
1271
1272         device_property_read_u32(arizona->dev, "wlf,micd-detect-debounce",
1273                                  &pdata->micd_detect_debounce);
1274
1275         device_property_read_u32(arizona->dev, "wlf,micd-bias-start-time",
1276                                  &pdata->micd_bias_start_time);
1277
1278         device_property_read_u32(arizona->dev, "wlf,micd-rate",
1279                                  &pdata->micd_rate);
1280
1281         device_property_read_u32(arizona->dev, "wlf,micd-dbtime",
1282                                  &pdata->micd_dbtime);
1283
1284         device_property_read_u32(arizona->dev, "wlf,micd-timeout-ms",
1285                                  &pdata->micd_timeout);
1286
1287         pdata->micd_force_micbias = device_property_read_bool(arizona->dev,
1288                                                 "wlf,micd-force-micbias");
1289
1290         pdata->micd_software_compare = device_property_read_bool(arizona->dev,
1291                                                 "wlf,micd-software-compare");
1292
1293         pdata->jd_invert = device_property_read_bool(arizona->dev,
1294                                                      "wlf,jd-invert");
1295
1296         device_property_read_u32(arizona->dev, "wlf,gpsw", &pdata->gpsw);
1297
1298         pdata->jd_gpio5 = device_property_read_bool(arizona->dev,
1299                                                     "wlf,use-jd2");
1300         pdata->jd_gpio5_nopull = device_property_read_bool(arizona->dev,
1301                                                 "wlf,use-jd2-nopull");
1302
1303         ret = arizona_extcon_get_micd_configs(dev, arizona);
1304         if (ret < 0)
1305                 dev_err(arizona->dev, "Failed to read micd configs: %d\n", ret);
1306
1307         return 0;
1308 }
1309
1310 static int arizona_extcon_probe(struct platform_device *pdev)
1311 {
1312         struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
1313         struct arizona_pdata *pdata = &arizona->pdata;
1314         struct arizona_extcon_info *info;
1315         unsigned int val;
1316         unsigned int clamp_mode;
1317         int jack_irq_fall, jack_irq_rise;
1318         int ret, mode, i, j;
1319
1320         if (!arizona->dapm || !arizona->dapm->card)
1321                 return -EPROBE_DEFER;
1322
1323         info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
1324         if (!info)
1325                 return -ENOMEM;
1326
1327         if (!dev_get_platdata(arizona->dev))
1328                 arizona_extcon_device_get_pdata(&pdev->dev, arizona);
1329
1330         info->micvdd = devm_regulator_get(&pdev->dev, "MICVDD");
1331         if (IS_ERR(info->micvdd)) {
1332                 ret = PTR_ERR(info->micvdd);
1333                 dev_err(arizona->dev, "Failed to get MICVDD: %d\n", ret);
1334                 return ret;
1335         }
1336
1337         mutex_init(&info->lock);
1338         info->arizona = arizona;
1339         info->dev = &pdev->dev;
1340         info->last_jackdet = ~(ARIZONA_MICD_CLAMP_STS | ARIZONA_JD1_STS);
1341         INIT_DELAYED_WORK(&info->hpdet_work, arizona_hpdet_work);
1342         INIT_DELAYED_WORK(&info->micd_detect_work, arizona_micd_detect);
1343         INIT_DELAYED_WORK(&info->micd_timeout_work, arizona_micd_timeout_work);
1344         platform_set_drvdata(pdev, info);
1345
1346         switch (arizona->type) {
1347         case WM5102:
1348                 switch (arizona->rev) {
1349                 case 0:
1350                         info->micd_reva = true;
1351                         break;
1352                 default:
1353                         info->micd_clamp = true;
1354                         info->hpdet_ip_version = 1;
1355                         break;
1356                 }
1357                 break;
1358         case WM5110:
1359         case WM8280:
1360                 switch (arizona->rev) {
1361                 case 0 ... 2:
1362                         break;
1363                 default:
1364                         info->micd_clamp = true;
1365                         info->hpdet_ip_version = 2;
1366                         break;
1367                 }
1368                 break;
1369         case WM8998:
1370         case WM1814:
1371                 info->micd_clamp = true;
1372                 info->hpdet_ip_version = 2;
1373                 break;
1374         default:
1375                 break;
1376         }
1377
1378         info->edev = devm_extcon_dev_allocate(&pdev->dev, arizona_cable);
1379         if (IS_ERR(info->edev)) {
1380                 dev_err(&pdev->dev, "failed to allocate extcon device\n");
1381                 return -ENOMEM;
1382         }
1383
1384         ret = devm_extcon_dev_register(&pdev->dev, info->edev);
1385         if (ret < 0) {
1386                 dev_err(arizona->dev, "extcon_dev_register() failed: %d\n",
1387                         ret);
1388                 return ret;
1389         }
1390
1391         info->input = devm_input_allocate_device(&pdev->dev);
1392         if (!info->input) {
1393                 dev_err(arizona->dev, "Can't allocate input dev\n");
1394                 ret = -ENOMEM;
1395                 goto err_register;
1396         }
1397
1398         info->input->name = "Headset";
1399         info->input->phys = "arizona/extcon";
1400
1401         if (pdata->num_micd_configs) {
1402                 info->micd_modes = pdata->micd_configs;
1403                 info->micd_num_modes = pdata->num_micd_configs;
1404         } else {
1405                 info->micd_modes = micd_default_modes;
1406                 info->micd_num_modes = ARRAY_SIZE(micd_default_modes);
1407         }
1408
1409         if (arizona->pdata.gpsw > 0)
1410                 regmap_update_bits(arizona->regmap, ARIZONA_GP_SWITCH_1,
1411                                 ARIZONA_SW1_MODE_MASK, arizona->pdata.gpsw);
1412
1413         if (arizona->pdata.micd_pol_gpio > 0) {
1414                 if (info->micd_modes[0].gpio)
1415                         mode = GPIOF_OUT_INIT_HIGH;
1416                 else
1417                         mode = GPIOF_OUT_INIT_LOW;
1418
1419                 ret = devm_gpio_request_one(&pdev->dev,
1420                                             arizona->pdata.micd_pol_gpio,
1421                                             mode,
1422                                             "MICD polarity");
1423                 if (ret != 0) {
1424                         dev_err(arizona->dev, "Failed to request GPIO%d: %d\n",
1425                                 arizona->pdata.micd_pol_gpio, ret);
1426                         goto err_register;
1427                 }
1428         } else {
1429                 if (info->micd_modes[0].gpio)
1430                         mode = GPIOD_OUT_HIGH;
1431                 else
1432                         mode = GPIOD_OUT_LOW;
1433
1434                 /* We can't use devm here because we need to do the get
1435                  * against the MFD device, as that is where the of_node
1436                  * will reside, but if we devm against that the GPIO
1437                  * will not be freed if the extcon driver is unloaded.
1438                  */
1439                 info->micd_pol_gpio = gpiod_get_optional(arizona->dev,
1440                                                          "wlf,micd-pol",
1441                                                          GPIOD_OUT_LOW);
1442                 if (IS_ERR(info->micd_pol_gpio)) {
1443                         ret = PTR_ERR(info->micd_pol_gpio);
1444                         dev_err(arizona->dev,
1445                                 "Failed to get microphone polarity GPIO: %d\n",
1446                                 ret);
1447                         goto err_register;
1448                 }
1449         }
1450
1451         if (arizona->pdata.hpdet_id_gpio > 0) {
1452                 ret = devm_gpio_request_one(&pdev->dev,
1453                                             arizona->pdata.hpdet_id_gpio,
1454                                             GPIOF_OUT_INIT_LOW,
1455                                             "HPDET");
1456                 if (ret != 0) {
1457                         dev_err(arizona->dev, "Failed to request GPIO%d: %d\n",
1458                                 arizona->pdata.hpdet_id_gpio, ret);
1459                         goto err_gpio;
1460                 }
1461         }
1462
1463         if (arizona->pdata.micd_bias_start_time)
1464                 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1465                                    ARIZONA_MICD_BIAS_STARTTIME_MASK,
1466                                    arizona->pdata.micd_bias_start_time
1467                                    << ARIZONA_MICD_BIAS_STARTTIME_SHIFT);
1468
1469         if (arizona->pdata.micd_rate)
1470                 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1471                                    ARIZONA_MICD_RATE_MASK,
1472                                    arizona->pdata.micd_rate
1473                                    << ARIZONA_MICD_RATE_SHIFT);
1474
1475         switch (arizona->pdata.micd_dbtime) {
1476         case MICD_DBTIME_FOUR_READINGS:
1477                 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1478                                    ARIZONA_MICD_DBTIME_MASK,
1479                                    ARIZONA_MICD_DBTIME);
1480                 break;
1481         case MICD_DBTIME_TWO_READINGS:
1482                 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1483                                    ARIZONA_MICD_DBTIME_MASK, 0);
1484                 break;
1485         default:
1486                 break;
1487         }
1488
1489         BUILD_BUG_ON(ARRAY_SIZE(arizona_micd_levels) <
1490                      ARIZONA_NUM_MICD_BUTTON_LEVELS);
1491
1492         if (arizona->pdata.num_micd_ranges) {
1493                 info->micd_ranges = pdata->micd_ranges;
1494                 info->num_micd_ranges = pdata->num_micd_ranges;
1495         } else {
1496                 info->micd_ranges = micd_default_ranges;
1497                 info->num_micd_ranges = ARRAY_SIZE(micd_default_ranges);
1498         }
1499
1500         if (arizona->pdata.num_micd_ranges > ARIZONA_MAX_MICD_RANGE) {
1501                 dev_err(arizona->dev, "Too many MICD ranges: %d\n",
1502                         arizona->pdata.num_micd_ranges);
1503         }
1504
1505         if (info->num_micd_ranges > 1) {
1506                 for (i = 1; i < info->num_micd_ranges; i++) {
1507                         if (info->micd_ranges[i - 1].max >
1508                             info->micd_ranges[i].max) {
1509                                 dev_err(arizona->dev,
1510                                         "MICD ranges must be sorted\n");
1511                                 ret = -EINVAL;
1512                                 goto err_gpio;
1513                         }
1514                 }
1515         }
1516
1517         /* Disable all buttons by default */
1518         regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_2,
1519                            ARIZONA_MICD_LVL_SEL_MASK, 0x81);
1520
1521         /* Set up all the buttons the user specified */
1522         for (i = 0; i < info->num_micd_ranges; i++) {
1523                 for (j = 0; j < ARIZONA_NUM_MICD_BUTTON_LEVELS; j++)
1524                         if (arizona_micd_levels[j] >= info->micd_ranges[i].max)
1525                                 break;
1526
1527                 if (j == ARIZONA_NUM_MICD_BUTTON_LEVELS) {
1528                         dev_err(arizona->dev, "Unsupported MICD level %d\n",
1529                                 info->micd_ranges[i].max);
1530                         ret = -EINVAL;
1531                         goto err_gpio;
1532                 }
1533
1534                 dev_dbg(arizona->dev, "%d ohms for MICD threshold %d\n",
1535                         arizona_micd_levels[j], i);
1536
1537                 arizona_micd_set_level(arizona, i, j);
1538                 input_set_capability(info->input, EV_KEY,
1539                                      info->micd_ranges[i].key);
1540
1541                 /* Enable reporting of that range */
1542                 regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_2,
1543                                    1 << i, 1 << i);
1544         }
1545
1546         /* Set all the remaining keys to a maximum */
1547         for (; i < ARIZONA_MAX_MICD_RANGE; i++)
1548                 arizona_micd_set_level(arizona, i, 0x3f);
1549
1550         /*
1551          * If we have a clamp use it, activating in conjunction with
1552          * GPIO5 if that is connected for jack detect operation.
1553          */
1554         if (info->micd_clamp) {
1555                 if (arizona->pdata.jd_gpio5) {
1556                         /* Put the GPIO into input mode with optional pull */
1557                         val = 0xc101;
1558                         if (arizona->pdata.jd_gpio5_nopull)
1559                                 val &= ~ARIZONA_GPN_PU;
1560
1561                         regmap_write(arizona->regmap, ARIZONA_GPIO5_CTRL,
1562                                      val);
1563
1564                         if (arizona->pdata.jd_invert)
1565                                 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDH_GP5H;
1566                         else
1567                                 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDL_GP5H;
1568                 } else {
1569                         if (arizona->pdata.jd_invert)
1570                                 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDH;
1571                         else
1572                                 clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDL;
1573                 }
1574
1575                 regmap_update_bits(arizona->regmap,
1576                                    ARIZONA_MICD_CLAMP_CONTROL,
1577                                    ARIZONA_MICD_CLAMP_MODE_MASK, clamp_mode);
1578
1579                 regmap_update_bits(arizona->regmap,
1580                                    ARIZONA_JACK_DETECT_DEBOUNCE,
1581                                    ARIZONA_MICD_CLAMP_DB,
1582                                    ARIZONA_MICD_CLAMP_DB);
1583         }
1584
1585         arizona_extcon_set_mode(info, 0);
1586
1587         pm_runtime_enable(&pdev->dev);
1588         pm_runtime_idle(&pdev->dev);
1589         pm_runtime_get_sync(&pdev->dev);
1590
1591         if (info->micd_clamp) {
1592                 jack_irq_rise = ARIZONA_IRQ_MICD_CLAMP_RISE;
1593                 jack_irq_fall = ARIZONA_IRQ_MICD_CLAMP_FALL;
1594         } else {
1595                 jack_irq_rise = ARIZONA_IRQ_JD_RISE;
1596                 jack_irq_fall = ARIZONA_IRQ_JD_FALL;
1597         }
1598
1599         ret = arizona_request_irq(arizona, jack_irq_rise,
1600                                   "JACKDET rise", arizona_jackdet, info);
1601         if (ret != 0) {
1602                 dev_err(&pdev->dev, "Failed to get JACKDET rise IRQ: %d\n",
1603                         ret);
1604                 goto err_gpio;
1605         }
1606
1607         ret = arizona_set_irq_wake(arizona, jack_irq_rise, 1);
1608         if (ret != 0) {
1609                 dev_err(&pdev->dev, "Failed to set JD rise IRQ wake: %d\n",
1610                         ret);
1611                 goto err_rise;
1612         }
1613
1614         ret = arizona_request_irq(arizona, jack_irq_fall,
1615                                   "JACKDET fall", arizona_jackdet, info);
1616         if (ret != 0) {
1617                 dev_err(&pdev->dev, "Failed to get JD fall IRQ: %d\n", ret);
1618                 goto err_rise_wake;
1619         }
1620
1621         ret = arizona_set_irq_wake(arizona, jack_irq_fall, 1);
1622         if (ret != 0) {
1623                 dev_err(&pdev->dev, "Failed to set JD fall IRQ wake: %d\n",
1624                         ret);
1625                 goto err_fall;
1626         }
1627
1628         ret = arizona_request_irq(arizona, ARIZONA_IRQ_MICDET,
1629                                   "MICDET", arizona_micdet, info);
1630         if (ret != 0) {
1631                 dev_err(&pdev->dev, "Failed to get MICDET IRQ: %d\n", ret);
1632                 goto err_fall_wake;
1633         }
1634
1635         ret = arizona_request_irq(arizona, ARIZONA_IRQ_HPDET,
1636                                   "HPDET", arizona_hpdet_irq, info);
1637         if (ret != 0) {
1638                 dev_err(&pdev->dev, "Failed to get HPDET IRQ: %d\n", ret);
1639                 goto err_micdet;
1640         }
1641
1642         arizona_clk32k_enable(arizona);
1643         regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_DEBOUNCE,
1644                            ARIZONA_JD1_DB, ARIZONA_JD1_DB);
1645         regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE,
1646                            ARIZONA_JD1_ENA, ARIZONA_JD1_ENA);
1647
1648         ret = regulator_allow_bypass(info->micvdd, true);
1649         if (ret != 0)
1650                 dev_warn(arizona->dev, "Failed to set MICVDD to bypass: %d\n",
1651                          ret);
1652
1653         pm_runtime_put(&pdev->dev);
1654
1655         ret = input_register_device(info->input);
1656         if (ret) {
1657                 dev_err(&pdev->dev, "Can't register input device: %d\n", ret);
1658                 goto err_hpdet;
1659         }
1660
1661         return 0;
1662
1663 err_hpdet:
1664         arizona_free_irq(arizona, ARIZONA_IRQ_HPDET, info);
1665 err_micdet:
1666         arizona_free_irq(arizona, ARIZONA_IRQ_MICDET, info);
1667 err_fall_wake:
1668         arizona_set_irq_wake(arizona, jack_irq_fall, 0);
1669 err_fall:
1670         arizona_free_irq(arizona, jack_irq_fall, info);
1671 err_rise_wake:
1672         arizona_set_irq_wake(arizona, jack_irq_rise, 0);
1673 err_rise:
1674         arizona_free_irq(arizona, jack_irq_rise, info);
1675 err_gpio:
1676         gpiod_put(info->micd_pol_gpio);
1677 err_register:
1678         pm_runtime_disable(&pdev->dev);
1679         return ret;
1680 }
1681
1682 static int arizona_extcon_remove(struct platform_device *pdev)
1683 {
1684         struct arizona_extcon_info *info = platform_get_drvdata(pdev);
1685         struct arizona *arizona = info->arizona;
1686         int jack_irq_rise, jack_irq_fall;
1687
1688         gpiod_put(info->micd_pol_gpio);
1689
1690         pm_runtime_disable(&pdev->dev);
1691
1692         regmap_update_bits(arizona->regmap,
1693                            ARIZONA_MICD_CLAMP_CONTROL,
1694                            ARIZONA_MICD_CLAMP_MODE_MASK, 0);
1695
1696         if (info->micd_clamp) {
1697                 jack_irq_rise = ARIZONA_IRQ_MICD_CLAMP_RISE;
1698                 jack_irq_fall = ARIZONA_IRQ_MICD_CLAMP_FALL;
1699         } else {
1700                 jack_irq_rise = ARIZONA_IRQ_JD_RISE;
1701                 jack_irq_fall = ARIZONA_IRQ_JD_FALL;
1702         }
1703
1704         arizona_set_irq_wake(arizona, jack_irq_rise, 0);
1705         arizona_set_irq_wake(arizona, jack_irq_fall, 0);
1706         arizona_free_irq(arizona, ARIZONA_IRQ_HPDET, info);
1707         arizona_free_irq(arizona, ARIZONA_IRQ_MICDET, info);
1708         arizona_free_irq(arizona, jack_irq_rise, info);
1709         arizona_free_irq(arizona, jack_irq_fall, info);
1710         cancel_delayed_work_sync(&info->hpdet_work);
1711         regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE,
1712                            ARIZONA_JD1_ENA, 0);
1713         arizona_clk32k_disable(arizona);
1714
1715         return 0;
1716 }
1717
1718 static struct platform_driver arizona_extcon_driver = {
1719         .driver         = {
1720                 .name   = "arizona-extcon",
1721         },
1722         .probe          = arizona_extcon_probe,
1723         .remove         = arizona_extcon_remove,
1724 };
1725
1726 module_platform_driver(arizona_extcon_driver);
1727
1728 MODULE_DESCRIPTION("Arizona Extcon driver");
1729 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
1730 MODULE_LICENSE("GPL");
1731 MODULE_ALIAS("platform:extcon-arizona");