drivers/extcon/extcon-arizona.c

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