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