drivers/extcon/extcon-arizona.c

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