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