root/drivers/extcon/extcon-arizona.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. arizona_extcon_hp_clamp
  2. arizona_extcon_set_mode
  3. arizona_extcon_get_micbias
  4. arizona_extcon_pulse_micbias
  5. arizona_start_mic
  6. arizona_stop_mic
  7. arizona_hpdet_read
  8. arizona_hpdet_do_id
  9. arizona_hpdet_irq
  10. arizona_identify_headphone
  11. arizona_start_hpdet_acc_id
  12. arizona_micd_timeout_work
  13. arizona_micd_detect
  14. arizona_micdet
  15. arizona_hpdet_work
  16. arizona_hpdet_wait
  17. arizona_jackdet
  18. arizona_micd_set_level
  19. arizona_extcon_get_micd_configs
  20. arizona_extcon_device_get_pdata
  21. arizona_extcon_probe
  22. arizona_extcon_remove

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

/* [<][>][^][v][top][bottom][index][help] */