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