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