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_cable_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_cable_state_(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_cable_state_(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_cable_state_(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_cable_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_cable_state_(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_cable_state_(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                ret = extcon_update_state(info->edev, 0xffffffff, 0);
1153                if (ret != 0)
1154                        dev_err(arizona->dev, "Removal report failed: %d\n",
1155                                ret);
1156
1157                regmap_update_bits(arizona->regmap,
1158                                   ARIZONA_JACK_DETECT_DEBOUNCE,
1159                                   ARIZONA_MICD_CLAMP_DB | ARIZONA_JD1_DB,
1160                                   ARIZONA_MICD_CLAMP_DB | ARIZONA_JD1_DB);
1161        }
1162
1163        if (arizona->pdata.micd_timeout)
1164                info->micd_timeout = arizona->pdata.micd_timeout;
1165        else
1166                info->micd_timeout = DEFAULT_MICD_TIMEOUT;
1167
1168out:
1169        /* Clear trig_sts to make sure DCVDD is not forced up */
1170        regmap_write(arizona->regmap, ARIZONA_AOD_WKUP_AND_TRIG,
1171                     ARIZONA_MICD_CLAMP_FALL_TRIG_STS |
1172                     ARIZONA_MICD_CLAMP_RISE_TRIG_STS |
1173                     ARIZONA_JD1_FALL_TRIG_STS |
1174                     ARIZONA_JD1_RISE_TRIG_STS);
1175
1176        mutex_unlock(&info->lock);
1177
1178        pm_runtime_mark_last_busy(info->dev);
1179        pm_runtime_put_autosuspend(info->dev);
1180
1181        return IRQ_HANDLED;
1182}
1183
1184/* Map a level onto a slot in the register bank */
1185static void arizona_micd_set_level(struct arizona *arizona, int index,
1186                                   unsigned int level)
1187{
1188        int reg;
1189        unsigned int mask;
1190
1191        reg = ARIZONA_MIC_DETECT_LEVEL_4 - (index / 2);
1192
1193        if (!(index % 2)) {
1194                mask = 0x3f00;
1195                level <<= 8;
1196        } else {
1197                mask = 0x3f;
1198        }
1199
1200        /* Program the level itself */
1201        regmap_update_bits(arizona->regmap, reg, mask, level);
1202}
1203
1204static int arizona_extcon_get_micd_configs(struct device *dev,
1205                                           struct arizona *arizona)
1206{
1207        const char * const prop = "wlf,micd-configs";
1208        const int entries_per_config = 3;
1209        struct arizona_micd_config *micd_configs;
1210        int nconfs, ret;
1211        int i, j;
1212        u32 *vals;
1213
1214        nconfs = device_property_read_u32_array(arizona->dev, prop, NULL, 0);
1215        if (nconfs <= 0)
1216                return 0;
1217
1218        vals = kcalloc(nconfs, sizeof(u32), GFP_KERNEL);
1219        if (!vals)
1220                return -ENOMEM;
1221
1222        ret = device_property_read_u32_array(arizona->dev, prop, vals, nconfs);
1223        if (ret < 0)
1224                goto out;
1225
1226        nconfs /= entries_per_config;
1227
1228        micd_configs = devm_kzalloc(dev,
1229                                    nconfs * sizeof(struct arizona_micd_range),
1230                                    GFP_KERNEL);
1231        if (!micd_configs) {
1232                ret = -ENOMEM;
1233                goto out;
1234        }
1235
1236        for (i = 0, j = 0; i < nconfs; ++i) {
1237                micd_configs[i].src = vals[j++] ? ARIZONA_ACCDET_SRC : 0;
1238                micd_configs[i].bias = vals[j++];
1239                micd_configs[i].gpio = vals[j++];
1240        }
1241
1242        arizona->pdata.micd_configs = micd_configs;
1243        arizona->pdata.num_micd_configs = nconfs;
1244
1245out:
1246        kfree(vals);
1247        return ret;
1248}
1249
1250static int arizona_extcon_device_get_pdata(struct device *dev,
1251                                           struct arizona *arizona)
1252{
1253        struct arizona_pdata *pdata = &arizona->pdata;
1254        unsigned int val = ARIZONA_ACCDET_MODE_HPL;
1255        int ret;
1256
1257        device_property_read_u32(arizona->dev, "wlf,hpdet-channel", &val);
1258        switch (val) {
1259        case ARIZONA_ACCDET_MODE_HPL:
1260        case ARIZONA_ACCDET_MODE_HPR:
1261                pdata->hpdet_channel = val;
1262                break;
1263        default:
1264                dev_err(arizona->dev,
1265                        "Wrong wlf,hpdet-channel DT value %d\n", val);
1266                pdata->hpdet_channel = ARIZONA_ACCDET_MODE_HPL;
1267        }
1268
1269        device_property_read_u32(arizona->dev, "wlf,micd-detect-debounce",
1270                                 &pdata->micd_detect_debounce);
1271
1272        device_property_read_u32(arizona->dev, "wlf,micd-bias-start-time",
1273                                 &pdata->micd_bias_start_time);
1274
1275        device_property_read_u32(arizona->dev, "wlf,micd-rate",
1276                                 &pdata->micd_rate);
1277
1278        device_property_read_u32(arizona->dev, "wlf,micd-dbtime",
1279                                 &pdata->micd_dbtime);
1280
1281        device_property_read_u32(arizona->dev, "wlf,micd-timeout-ms",
1282                                 &pdata->micd_timeout);
1283
1284        pdata->micd_force_micbias = device_property_read_bool(arizona->dev,
1285                                                "wlf,micd-force-micbias");
1286
1287        pdata->micd_software_compare = device_property_read_bool(arizona->dev,
1288                                                "wlf,micd-software-compare");
1289
1290        pdata->jd_invert = device_property_read_bool(arizona->dev,
1291                                                     "wlf,jd-invert");
1292
1293        device_property_read_u32(arizona->dev, "wlf,gpsw", &pdata->gpsw);
1294
1295        pdata->jd_gpio5 = device_property_read_bool(arizona->dev,
1296                                                    "wlf,use-jd2");
1297        pdata->jd_gpio5_nopull = device_property_read_bool(arizona->dev,
1298                                                "wlf,use-jd2-nopull");
1299
1300        ret = arizona_extcon_get_micd_configs(dev, arizona);
1301        if (ret < 0)
1302                dev_err(arizona->dev, "Failed to read micd configs: %d\n", ret);
1303
1304        return 0;
1305}
1306
1307static int arizona_extcon_probe(struct platform_device *pdev)
1308{
1309        struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
1310        struct arizona_pdata *pdata = &arizona->pdata;
1311        struct arizona_extcon_info *info;
1312        unsigned int val;
1313        unsigned int clamp_mode;
1314        int jack_irq_fall, jack_irq_rise;
1315        int ret, mode, i, j;
1316
1317        if (!arizona->dapm || !arizona->dapm->card)
1318                return -EPROBE_DEFER;
1319
1320        info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
1321        if (!info)
1322                return -ENOMEM;
1323
1324        if (!dev_get_platdata(arizona->dev))
1325                arizona_extcon_device_get_pdata(&pdev->dev, arizona);
1326
1327        info->micvdd = devm_regulator_get(&pdev->dev, "MICVDD");
1328        if (IS_ERR(info->micvdd)) {
1329                ret = PTR_ERR(info->micvdd);
1330                dev_err(arizona->dev, "Failed to get MICVDD: %d\n", ret);
1331                return ret;
1332        }
1333
1334        mutex_init(&info->lock);
1335        info->arizona = arizona;
1336        info->dev = &pdev->dev;
1337        info->last_jackdet = ~(ARIZONA_MICD_CLAMP_STS | ARIZONA_JD1_STS);
1338        INIT_DELAYED_WORK(&info->hpdet_work, arizona_hpdet_work);
1339        INIT_DELAYED_WORK(&info->micd_detect_work, arizona_micd_detect);
1340        INIT_DELAYED_WORK(&info->micd_timeout_work, arizona_micd_timeout_work);
1341        platform_set_drvdata(pdev, info);
1342
1343        switch (arizona->type) {
1344        case WM5102:
1345                switch (arizona->rev) {
1346                case 0:
1347                        info->micd_reva = true;
1348                        break;
1349                default:
1350                        info->micd_clamp = true;
1351                        info->hpdet_ip_version = 1;
1352                        break;
1353                }
1354                break;
1355        case WM5110:
1356        case WM8280:
1357                switch (arizona->rev) {
1358                case 0 ... 2:
1359                        break;
1360                default:
1361                        info->micd_clamp = true;
1362                        info->hpdet_ip_version = 2;
1363                        break;
1364                }
1365                break;
1366        case WM8998:
1367        case WM1814:
1368                info->micd_clamp = true;
1369                info->hpdet_ip_version = 2;
1370                break;
1371        default:
1372                break;
1373        }
1374
1375        info->edev = devm_extcon_dev_allocate(&pdev->dev, arizona_cable);
1376        if (IS_ERR(info->edev)) {
1377                dev_err(&pdev->dev, "failed to allocate extcon device\n");
1378                return -ENOMEM;
1379        }
1380
1381        ret = devm_extcon_dev_register(&pdev->dev, info->edev);
1382        if (ret < 0) {
1383                dev_err(arizona->dev, "extcon_dev_register() failed: %d\n",
1384                        ret);
1385                return ret;
1386        }
1387
1388        info->input = devm_input_allocate_device(&pdev->dev);
1389        if (!info->input) {
1390                dev_err(arizona->dev, "Can't allocate input dev\n");
1391                ret = -ENOMEM;
1392                goto err_register;
1393        }
1394
1395        info->input->name = "Headset";
1396        info->input->phys = "arizona/extcon";
1397
1398        if (pdata->num_micd_configs) {
1399                info->micd_modes = pdata->micd_configs;
1400                info->micd_num_modes = pdata->num_micd_configs;
1401        } else {
1402                info->micd_modes = micd_default_modes;
1403                info->micd_num_modes = ARRAY_SIZE(micd_default_modes);
1404        }
1405
1406        if (arizona->pdata.gpsw > 0)
1407                regmap_update_bits(arizona->regmap, ARIZONA_GP_SWITCH_1,
1408                                ARIZONA_SW1_MODE_MASK, arizona->pdata.gpsw);
1409
1410        if (arizona->pdata.micd_pol_gpio > 0) {
1411                if (info->micd_modes[0].gpio)
1412                        mode = GPIOF_OUT_INIT_HIGH;
1413                else
1414                        mode = GPIOF_OUT_INIT_LOW;
1415
1416                ret = devm_gpio_request_one(&pdev->dev,
1417                                            arizona->pdata.micd_pol_gpio,
1418                                            mode,
1419                                            "MICD polarity");
1420                if (ret != 0) {
1421                        dev_err(arizona->dev, "Failed to request GPIO%d: %d\n",
1422                                arizona->pdata.micd_pol_gpio, ret);
1423                        goto err_register;
1424                }
1425        } else {
1426                if (info->micd_modes[0].gpio)
1427                        mode = GPIOD_OUT_HIGH;
1428                else
1429                        mode = GPIOD_OUT_LOW;
1430
1431                /* We can't use devm here because we need to do the get
1432                 * against the MFD device, as that is where the of_node
1433                 * will reside, but if we devm against that the GPIO
1434                 * will not be freed if the extcon driver is unloaded.
1435                 */
1436                info->micd_pol_gpio = gpiod_get_optional(arizona->dev,
1437                                                         "wlf,micd-pol",
1438                                                         GPIOD_OUT_LOW);
1439                if (IS_ERR(info->micd_pol_gpio)) {
1440                        ret = PTR_ERR(info->micd_pol_gpio);
1441                        dev_err(arizona->dev,
1442                                "Failed to get microphone polarity GPIO: %d\n",
1443                                ret);
1444                        goto err_register;
1445                }
1446        }
1447
1448        if (arizona->pdata.hpdet_id_gpio > 0) {
1449                ret = devm_gpio_request_one(&pdev->dev,
1450                                            arizona->pdata.hpdet_id_gpio,
1451                                            GPIOF_OUT_INIT_LOW,
1452                                            "HPDET");
1453                if (ret != 0) {
1454                        dev_err(arizona->dev, "Failed to request GPIO%d: %d\n",
1455                                arizona->pdata.hpdet_id_gpio, ret);
1456                        goto err_gpio;
1457                }
1458        }
1459
1460        if (arizona->pdata.micd_bias_start_time)
1461                regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1462                                   ARIZONA_MICD_BIAS_STARTTIME_MASK,
1463                                   arizona->pdata.micd_bias_start_time
1464                                   << ARIZONA_MICD_BIAS_STARTTIME_SHIFT);
1465
1466        if (arizona->pdata.micd_rate)
1467                regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1468                                   ARIZONA_MICD_RATE_MASK,
1469                                   arizona->pdata.micd_rate
1470                                   << ARIZONA_MICD_RATE_SHIFT);
1471
1472        switch (arizona->pdata.micd_dbtime) {
1473        case MICD_DBTIME_FOUR_READINGS:
1474                regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1475                                   ARIZONA_MICD_DBTIME_MASK,
1476                                   ARIZONA_MICD_DBTIME);
1477                break;
1478        case MICD_DBTIME_TWO_READINGS:
1479                regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_1,
1480                                   ARIZONA_MICD_DBTIME_MASK, 0);
1481                break;
1482        default:
1483                break;
1484        }
1485
1486        BUILD_BUG_ON(ARRAY_SIZE(arizona_micd_levels) <
1487                     ARIZONA_NUM_MICD_BUTTON_LEVELS);
1488
1489        if (arizona->pdata.num_micd_ranges) {
1490                info->micd_ranges = pdata->micd_ranges;
1491                info->num_micd_ranges = pdata->num_micd_ranges;
1492        } else {
1493                info->micd_ranges = micd_default_ranges;
1494                info->num_micd_ranges = ARRAY_SIZE(micd_default_ranges);
1495        }
1496
1497        if (arizona->pdata.num_micd_ranges > ARIZONA_MAX_MICD_RANGE) {
1498                dev_err(arizona->dev, "Too many MICD ranges: %d\n",
1499                        arizona->pdata.num_micd_ranges);
1500        }
1501
1502        if (info->num_micd_ranges > 1) {
1503                for (i = 1; i < info->num_micd_ranges; i++) {
1504                        if (info->micd_ranges[i - 1].max >
1505                            info->micd_ranges[i].max) {
1506                                dev_err(arizona->dev,
1507                                        "MICD ranges must be sorted\n");
1508                                ret = -EINVAL;
1509                                goto err_gpio;
1510                        }
1511                }
1512        }
1513
1514        /* Disable all buttons by default */
1515        regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_2,
1516                           ARIZONA_MICD_LVL_SEL_MASK, 0x81);
1517
1518        /* Set up all the buttons the user specified */
1519        for (i = 0; i < info->num_micd_ranges; i++) {
1520                for (j = 0; j < ARIZONA_NUM_MICD_BUTTON_LEVELS; j++)
1521                        if (arizona_micd_levels[j] >= info->micd_ranges[i].max)
1522                                break;
1523
1524                if (j == ARIZONA_NUM_MICD_BUTTON_LEVELS) {
1525                        dev_err(arizona->dev, "Unsupported MICD level %d\n",
1526                                info->micd_ranges[i].max);
1527                        ret = -EINVAL;
1528                        goto err_gpio;
1529                }
1530
1531                dev_dbg(arizona->dev, "%d ohms for MICD threshold %d\n",
1532                        arizona_micd_levels[j], i);
1533
1534                arizona_micd_set_level(arizona, i, j);
1535                input_set_capability(info->input, EV_KEY,
1536                                     info->micd_ranges[i].key);
1537
1538                /* Enable reporting of that range */
1539                regmap_update_bits(arizona->regmap, ARIZONA_MIC_DETECT_2,
1540                                   1 << i, 1 << i);
1541        }
1542
1543        /* Set all the remaining keys to a maximum */
1544        for (; i < ARIZONA_MAX_MICD_RANGE; i++)
1545                arizona_micd_set_level(arizona, i, 0x3f);
1546
1547        /*
1548         * If we have a clamp use it, activating in conjunction with
1549         * GPIO5 if that is connected for jack detect operation.
1550         */
1551        if (info->micd_clamp) {
1552                if (arizona->pdata.jd_gpio5) {
1553                        /* Put the GPIO into input mode with optional pull */
1554                        val = 0xc101;
1555                        if (arizona->pdata.jd_gpio5_nopull)
1556                                val &= ~ARIZONA_GPN_PU;
1557
1558                        regmap_write(arizona->regmap, ARIZONA_GPIO5_CTRL,
1559                                     val);
1560
1561                        if (arizona->pdata.jd_invert)
1562                                clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDH_GP5H;
1563                        else
1564                                clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDL_GP5H;
1565                } else {
1566                        if (arizona->pdata.jd_invert)
1567                                clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDH;
1568                        else
1569                                clamp_mode = ARIZONA_MICD_CLAMP_MODE_JDL;
1570                }
1571
1572                regmap_update_bits(arizona->regmap,
1573                                   ARIZONA_MICD_CLAMP_CONTROL,
1574                                   ARIZONA_MICD_CLAMP_MODE_MASK, clamp_mode);
1575
1576                regmap_update_bits(arizona->regmap,
1577                                   ARIZONA_JACK_DETECT_DEBOUNCE,
1578                                   ARIZONA_MICD_CLAMP_DB,
1579                                   ARIZONA_MICD_CLAMP_DB);
1580        }
1581
1582        arizona_extcon_set_mode(info, 0);
1583
1584        pm_runtime_enable(&pdev->dev);
1585        pm_runtime_idle(&pdev->dev);
1586        pm_runtime_get_sync(&pdev->dev);
1587
1588        if (info->micd_clamp) {
1589                jack_irq_rise = ARIZONA_IRQ_MICD_CLAMP_RISE;
1590                jack_irq_fall = ARIZONA_IRQ_MICD_CLAMP_FALL;
1591        } else {
1592                jack_irq_rise = ARIZONA_IRQ_JD_RISE;
1593                jack_irq_fall = ARIZONA_IRQ_JD_FALL;
1594        }
1595
1596        ret = arizona_request_irq(arizona, jack_irq_rise,
1597                                  "JACKDET rise", arizona_jackdet, info);
1598        if (ret != 0) {
1599                dev_err(&pdev->dev, "Failed to get JACKDET rise IRQ: %d\n",
1600                        ret);
1601                goto err_gpio;
1602        }
1603
1604        ret = arizona_set_irq_wake(arizona, jack_irq_rise, 1);
1605        if (ret != 0) {
1606                dev_err(&pdev->dev, "Failed to set JD rise IRQ wake: %d\n",
1607                        ret);
1608                goto err_rise;
1609        }
1610
1611        ret = arizona_request_irq(arizona, jack_irq_fall,
1612                                  "JACKDET fall", arizona_jackdet, info);
1613        if (ret != 0) {
1614                dev_err(&pdev->dev, "Failed to get JD fall IRQ: %d\n", ret);
1615                goto err_rise_wake;
1616        }
1617
1618        ret = arizona_set_irq_wake(arizona, jack_irq_fall, 1);
1619        if (ret != 0) {
1620                dev_err(&pdev->dev, "Failed to set JD fall IRQ wake: %d\n",
1621                        ret);
1622                goto err_fall;
1623        }
1624
1625        ret = arizona_request_irq(arizona, ARIZONA_IRQ_MICDET,
1626                                  "MICDET", arizona_micdet, info);
1627        if (ret != 0) {
1628                dev_err(&pdev->dev, "Failed to get MICDET IRQ: %d\n", ret);
1629                goto err_fall_wake;
1630        }
1631
1632        ret = arizona_request_irq(arizona, ARIZONA_IRQ_HPDET,
1633                                  "HPDET", arizona_hpdet_irq, info);
1634        if (ret != 0) {
1635                dev_err(&pdev->dev, "Failed to get HPDET IRQ: %d\n", ret);
1636                goto err_micdet;
1637        }
1638
1639        arizona_clk32k_enable(arizona);
1640        regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_DEBOUNCE,
1641                           ARIZONA_JD1_DB, ARIZONA_JD1_DB);
1642        regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE,
1643                           ARIZONA_JD1_ENA, ARIZONA_JD1_ENA);
1644
1645        ret = regulator_allow_bypass(info->micvdd, true);
1646        if (ret != 0)
1647                dev_warn(arizona->dev, "Failed to set MICVDD to bypass: %d\n",
1648                         ret);
1649
1650        pm_runtime_put(&pdev->dev);
1651
1652        ret = input_register_device(info->input);
1653        if (ret) {
1654                dev_err(&pdev->dev, "Can't register input device: %d\n", ret);
1655                goto err_hpdet;
1656        }
1657
1658        return 0;
1659
1660err_hpdet:
1661        arizona_free_irq(arizona, ARIZONA_IRQ_HPDET, info);
1662err_micdet:
1663        arizona_free_irq(arizona, ARIZONA_IRQ_MICDET, info);
1664err_fall_wake:
1665        arizona_set_irq_wake(arizona, jack_irq_fall, 0);
1666err_fall:
1667        arizona_free_irq(arizona, jack_irq_fall, info);
1668err_rise_wake:
1669        arizona_set_irq_wake(arizona, jack_irq_rise, 0);
1670err_rise:
1671        arizona_free_irq(arizona, jack_irq_rise, info);
1672err_gpio:
1673        gpiod_put(info->micd_pol_gpio);
1674err_register:
1675        pm_runtime_disable(&pdev->dev);
1676        return ret;
1677}
1678
1679static int arizona_extcon_remove(struct platform_device *pdev)
1680{
1681        struct arizona_extcon_info *info = platform_get_drvdata(pdev);
1682        struct arizona *arizona = info->arizona;
1683        int jack_irq_rise, jack_irq_fall;
1684
1685        gpiod_put(info->micd_pol_gpio);
1686
1687        pm_runtime_disable(&pdev->dev);
1688
1689        regmap_update_bits(arizona->regmap,
1690                           ARIZONA_MICD_CLAMP_CONTROL,
1691                           ARIZONA_MICD_CLAMP_MODE_MASK, 0);
1692
1693        if (info->micd_clamp) {
1694                jack_irq_rise = ARIZONA_IRQ_MICD_CLAMP_RISE;
1695                jack_irq_fall = ARIZONA_IRQ_MICD_CLAMP_FALL;
1696        } else {
1697                jack_irq_rise = ARIZONA_IRQ_JD_RISE;
1698                jack_irq_fall = ARIZONA_IRQ_JD_FALL;
1699        }
1700
1701        arizona_set_irq_wake(arizona, jack_irq_rise, 0);
1702        arizona_set_irq_wake(arizona, jack_irq_fall, 0);
1703        arizona_free_irq(arizona, ARIZONA_IRQ_HPDET, info);
1704        arizona_free_irq(arizona, ARIZONA_IRQ_MICDET, info);
1705        arizona_free_irq(arizona, jack_irq_rise, info);
1706        arizona_free_irq(arizona, jack_irq_fall, info);
1707        cancel_delayed_work_sync(&info->hpdet_work);
1708        regmap_update_bits(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE,
1709                           ARIZONA_JD1_ENA, 0);
1710        arizona_clk32k_disable(arizona);
1711
1712        return 0;
1713}
1714
1715static struct platform_driver arizona_extcon_driver = {
1716        .driver         = {
1717                .name   = "arizona-extcon",
1718        },
1719        .probe          = arizona_extcon_probe,
1720        .remove         = arizona_extcon_remove,
1721};
1722
1723module_platform_driver(arizona_extcon_driver);
1724
1725MODULE_DESCRIPTION("Arizona Extcon driver");
1726MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
1727MODULE_LICENSE("GPL");
1728MODULE_ALIAS("platform:extcon-arizona");
1729
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.