drivers/extcon/extcon-arizona.c

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