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