1 /* 2 * Arizona core driver 3 * 4 * Copyright 2012 Wolfson Microelectronics plc 5 * 6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License version 2 as 10 * published by the Free Software Foundation. 11 */ 12 13 #include <linux/clk.h> 14 #include <linux/delay.h> 15 #include <linux/err.h> 16 #include <linux/gpio.h> 17 #include <linux/interrupt.h> 18 #include <linux/mfd/core.h> 19 #include <linux/module.h> 20 #include <linux/of.h> 21 #include <linux/of_device.h> 22 #include <linux/of_gpio.h> 23 #include <linux/pm_runtime.h> 24 #include <linux/regmap.h> 25 #include <linux/regulator/consumer.h> 26 #include <linux/regulator/machine.h> 27 #include <linux/slab.h> 28 #include <linux/platform_device.h> 29 30 #include <linux/mfd/arizona/core.h> 31 #include <linux/mfd/arizona/registers.h> 32 33 #include "arizona.h" 34 35 static const char * const wm5102_core_supplies[] = { 36 "AVDD", 37 "DBVDD1", 38 }; 39 40 int arizona_clk32k_enable(struct arizona *arizona) 41 { 42 int ret = 0; 43 44 mutex_lock(&arizona->clk_lock); 45 46 arizona->clk32k_ref++; 47 48 if (arizona->clk32k_ref == 1) { 49 switch (arizona->pdata.clk32k_src) { 50 case ARIZONA_32KZ_MCLK1: 51 ret = pm_runtime_get_sync(arizona->dev); 52 if (ret != 0) 53 goto err_ref; 54 ret = clk_prepare_enable(arizona->mclk[ARIZONA_MCLK1]); 55 if (ret != 0) 56 goto err_pm; 57 break; 58 case ARIZONA_32KZ_MCLK2: 59 ret = clk_prepare_enable(arizona->mclk[ARIZONA_MCLK2]); 60 if (ret != 0) 61 goto err_ref; 62 break; 63 } 64 65 ret = regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1, 66 ARIZONA_CLK_32K_ENA, 67 ARIZONA_CLK_32K_ENA); 68 } 69 70 err_pm: 71 pm_runtime_put_sync(arizona->dev); 72 err_ref: 73 if (ret != 0) 74 arizona->clk32k_ref--; 75 76 mutex_unlock(&arizona->clk_lock); 77 78 return ret; 79 } 80 EXPORT_SYMBOL_GPL(arizona_clk32k_enable); 81 82 int arizona_clk32k_disable(struct arizona *arizona) 83 { 84 mutex_lock(&arizona->clk_lock); 85 86 BUG_ON(arizona->clk32k_ref <= 0); 87 88 arizona->clk32k_ref--; 89 90 if (arizona->clk32k_ref == 0) { 91 regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1, 92 ARIZONA_CLK_32K_ENA, 0); 93 94 switch (arizona->pdata.clk32k_src) { 95 case ARIZONA_32KZ_MCLK1: 96 pm_runtime_put_sync(arizona->dev); 97 clk_disable_unprepare(arizona->mclk[ARIZONA_MCLK1]); 98 break; 99 case ARIZONA_32KZ_MCLK2: 100 clk_disable_unprepare(arizona->mclk[ARIZONA_MCLK2]); 101 break; 102 } 103 } 104 105 mutex_unlock(&arizona->clk_lock); 106 107 return 0; 108 } 109 EXPORT_SYMBOL_GPL(arizona_clk32k_disable); 110 111 static irqreturn_t arizona_clkgen_err(int irq, void *data) 112 { 113 struct arizona *arizona = data; 114 115 dev_err(arizona->dev, "CLKGEN error\n"); 116 117 return IRQ_HANDLED; 118 } 119 120 static irqreturn_t arizona_underclocked(int irq, void *data) 121 { 122 struct arizona *arizona = data; 123 unsigned int val; 124 int ret; 125 126 ret = regmap_read(arizona->regmap, ARIZONA_INTERRUPT_RAW_STATUS_8, 127 &val); 128 if (ret != 0) { 129 dev_err(arizona->dev, "Failed to read underclock status: %d\n", 130 ret); 131 return IRQ_NONE; 132 } 133 134 if (val & ARIZONA_AIF3_UNDERCLOCKED_STS) 135 dev_err(arizona->dev, "AIF3 underclocked\n"); 136 if (val & ARIZONA_AIF2_UNDERCLOCKED_STS) 137 dev_err(arizona->dev, "AIF2 underclocked\n"); 138 if (val & ARIZONA_AIF1_UNDERCLOCKED_STS) 139 dev_err(arizona->dev, "AIF1 underclocked\n"); 140 if (val & ARIZONA_ISRC3_UNDERCLOCKED_STS) 141 dev_err(arizona->dev, "ISRC3 underclocked\n"); 142 if (val & ARIZONA_ISRC2_UNDERCLOCKED_STS) 143 dev_err(arizona->dev, "ISRC2 underclocked\n"); 144 if (val & ARIZONA_ISRC1_UNDERCLOCKED_STS) 145 dev_err(arizona->dev, "ISRC1 underclocked\n"); 146 if (val & ARIZONA_FX_UNDERCLOCKED_STS) 147 dev_err(arizona->dev, "FX underclocked\n"); 148 if (val & ARIZONA_ASRC_UNDERCLOCKED_STS) 149 dev_err(arizona->dev, "ASRC underclocked\n"); 150 if (val & ARIZONA_DAC_UNDERCLOCKED_STS) 151 dev_err(arizona->dev, "DAC underclocked\n"); 152 if (val & ARIZONA_ADC_UNDERCLOCKED_STS) 153 dev_err(arizona->dev, "ADC underclocked\n"); 154 if (val & ARIZONA_MIXER_UNDERCLOCKED_STS) 155 dev_err(arizona->dev, "Mixer dropped sample\n"); 156 157 return IRQ_HANDLED; 158 } 159 160 static irqreturn_t arizona_overclocked(int irq, void *data) 161 { 162 struct arizona *arizona = data; 163 unsigned int val[3]; 164 int ret; 165 166 ret = regmap_bulk_read(arizona->regmap, ARIZONA_INTERRUPT_RAW_STATUS_6, 167 &val[0], 3); 168 if (ret != 0) { 169 dev_err(arizona->dev, "Failed to read overclock status: %d\n", 170 ret); 171 return IRQ_NONE; 172 } 173 174 switch (arizona->type) { 175 case WM8998: 176 case WM1814: 177 /* Some bits are shifted on WM8998, 178 * rearrange to match the standard bit layout 179 */ 180 val[0] = ((val[0] & 0x60e0) >> 1) | 181 ((val[0] & 0x1e00) >> 2) | 182 (val[0] & 0x000f); 183 break; 184 default: 185 break; 186 } 187 188 if (val[0] & ARIZONA_PWM_OVERCLOCKED_STS) 189 dev_err(arizona->dev, "PWM overclocked\n"); 190 if (val[0] & ARIZONA_FX_CORE_OVERCLOCKED_STS) 191 dev_err(arizona->dev, "FX core overclocked\n"); 192 if (val[0] & ARIZONA_DAC_SYS_OVERCLOCKED_STS) 193 dev_err(arizona->dev, "DAC SYS overclocked\n"); 194 if (val[0] & ARIZONA_DAC_WARP_OVERCLOCKED_STS) 195 dev_err(arizona->dev, "DAC WARP overclocked\n"); 196 if (val[0] & ARIZONA_ADC_OVERCLOCKED_STS) 197 dev_err(arizona->dev, "ADC overclocked\n"); 198 if (val[0] & ARIZONA_MIXER_OVERCLOCKED_STS) 199 dev_err(arizona->dev, "Mixer overclocked\n"); 200 if (val[0] & ARIZONA_AIF3_SYNC_OVERCLOCKED_STS) 201 dev_err(arizona->dev, "AIF3 overclocked\n"); 202 if (val[0] & ARIZONA_AIF2_SYNC_OVERCLOCKED_STS) 203 dev_err(arizona->dev, "AIF2 overclocked\n"); 204 if (val[0] & ARIZONA_AIF1_SYNC_OVERCLOCKED_STS) 205 dev_err(arizona->dev, "AIF1 overclocked\n"); 206 if (val[0] & ARIZONA_PAD_CTRL_OVERCLOCKED_STS) 207 dev_err(arizona->dev, "Pad control overclocked\n"); 208 209 if (val[1] & ARIZONA_SLIMBUS_SUBSYS_OVERCLOCKED_STS) 210 dev_err(arizona->dev, "Slimbus subsystem overclocked\n"); 211 if (val[1] & ARIZONA_SLIMBUS_ASYNC_OVERCLOCKED_STS) 212 dev_err(arizona->dev, "Slimbus async overclocked\n"); 213 if (val[1] & ARIZONA_SLIMBUS_SYNC_OVERCLOCKED_STS) 214 dev_err(arizona->dev, "Slimbus sync overclocked\n"); 215 if (val[1] & ARIZONA_ASRC_ASYNC_SYS_OVERCLOCKED_STS) 216 dev_err(arizona->dev, "ASRC async system overclocked\n"); 217 if (val[1] & ARIZONA_ASRC_ASYNC_WARP_OVERCLOCKED_STS) 218 dev_err(arizona->dev, "ASRC async WARP overclocked\n"); 219 if (val[1] & ARIZONA_ASRC_SYNC_SYS_OVERCLOCKED_STS) 220 dev_err(arizona->dev, "ASRC sync system overclocked\n"); 221 if (val[1] & ARIZONA_ASRC_SYNC_WARP_OVERCLOCKED_STS) 222 dev_err(arizona->dev, "ASRC sync WARP overclocked\n"); 223 if (val[1] & ARIZONA_ADSP2_1_OVERCLOCKED_STS) 224 dev_err(arizona->dev, "DSP1 overclocked\n"); 225 if (val[1] & ARIZONA_ISRC3_OVERCLOCKED_STS) 226 dev_err(arizona->dev, "ISRC3 overclocked\n"); 227 if (val[1] & ARIZONA_ISRC2_OVERCLOCKED_STS) 228 dev_err(arizona->dev, "ISRC2 overclocked\n"); 229 if (val[1] & ARIZONA_ISRC1_OVERCLOCKED_STS) 230 dev_err(arizona->dev, "ISRC1 overclocked\n"); 231 232 if (val[2] & ARIZONA_SPDIF_OVERCLOCKED_STS) 233 dev_err(arizona->dev, "SPDIF overclocked\n"); 234 235 return IRQ_HANDLED; 236 } 237 238 #define ARIZONA_REG_POLL_DELAY_US 7500 239 240 static int arizona_poll_reg(struct arizona *arizona, 241 int timeout_ms, unsigned int reg, 242 unsigned int mask, unsigned int target) 243 { 244 unsigned int val = 0; 245 int ret; 246 247 ret = regmap_read_poll_timeout(arizona->regmap, 248 reg, val, ((val & mask) == target), 249 ARIZONA_REG_POLL_DELAY_US, 250 timeout_ms * 1000); 251 if (ret) 252 dev_err(arizona->dev, "Polling reg 0x%x timed out: %x\n", 253 reg, val); 254 255 return ret; 256 } 257 258 static int arizona_wait_for_boot(struct arizona *arizona) 259 { 260 int ret; 261 262 /* 263 * We can't use an interrupt as we need to runtime resume to do so, 264 * we won't race with the interrupt handler as it'll be blocked on 265 * runtime resume. 266 */ 267 ret = arizona_poll_reg(arizona, 30, ARIZONA_INTERRUPT_RAW_STATUS_5, 268 ARIZONA_BOOT_DONE_STS, ARIZONA_BOOT_DONE_STS); 269 270 if (!ret) 271 regmap_write(arizona->regmap, ARIZONA_INTERRUPT_STATUS_5, 272 ARIZONA_BOOT_DONE_STS); 273 274 pm_runtime_mark_last_busy(arizona->dev); 275 276 return ret; 277 } 278 279 static inline void arizona_enable_reset(struct arizona *arizona) 280 { 281 if (arizona->pdata.reset) 282 gpio_set_value_cansleep(arizona->pdata.reset, 0); 283 } 284 285 static void arizona_disable_reset(struct arizona *arizona) 286 { 287 if (arizona->pdata.reset) { 288 switch (arizona->type) { 289 case WM5110: 290 case WM8280: 291 /* Meet requirements for minimum reset duration */ 292 usleep_range(5000, 10000); 293 break; 294 default: 295 break; 296 } 297 298 gpio_set_value_cansleep(arizona->pdata.reset, 1); 299 usleep_range(1000, 5000); 300 } 301 } 302 303 struct arizona_sysclk_state { 304 unsigned int fll; 305 unsigned int sysclk; 306 }; 307 308 static int arizona_enable_freerun_sysclk(struct arizona *arizona, 309 struct arizona_sysclk_state *state) 310 { 311 int ret, err; 312 313 /* Cache existing FLL and SYSCLK settings */ 314 ret = regmap_read(arizona->regmap, ARIZONA_FLL1_CONTROL_1, &state->fll); 315 if (ret) { 316 dev_err(arizona->dev, "Failed to cache FLL settings: %d\n", 317 ret); 318 return ret; 319 } 320 ret = regmap_read(arizona->regmap, ARIZONA_SYSTEM_CLOCK_1, 321 &state->sysclk); 322 if (ret) { 323 dev_err(arizona->dev, "Failed to cache SYSCLK settings: %d\n", 324 ret); 325 return ret; 326 } 327 328 /* Start up SYSCLK using the FLL in free running mode */ 329 ret = regmap_write(arizona->regmap, ARIZONA_FLL1_CONTROL_1, 330 ARIZONA_FLL1_ENA | ARIZONA_FLL1_FREERUN); 331 if (ret) { 332 dev_err(arizona->dev, 333 "Failed to start FLL in freerunning mode: %d\n", 334 ret); 335 return ret; 336 } 337 ret = arizona_poll_reg(arizona, 180, ARIZONA_INTERRUPT_RAW_STATUS_5, 338 ARIZONA_FLL1_CLOCK_OK_STS, 339 ARIZONA_FLL1_CLOCK_OK_STS); 340 if (ret) 341 goto err_fll; 342 343 ret = regmap_write(arizona->regmap, ARIZONA_SYSTEM_CLOCK_1, 0x0144); 344 if (ret) { 345 dev_err(arizona->dev, "Failed to start SYSCLK: %d\n", ret); 346 goto err_fll; 347 } 348 349 return 0; 350 351 err_fll: 352 err = regmap_write(arizona->regmap, ARIZONA_FLL1_CONTROL_1, state->fll); 353 if (err) 354 dev_err(arizona->dev, 355 "Failed to re-apply old FLL settings: %d\n", err); 356 357 return ret; 358 } 359 360 static int arizona_disable_freerun_sysclk(struct arizona *arizona, 361 struct arizona_sysclk_state *state) 362 { 363 int ret; 364 365 ret = regmap_write(arizona->regmap, ARIZONA_SYSTEM_CLOCK_1, 366 state->sysclk); 367 if (ret) { 368 dev_err(arizona->dev, 369 "Failed to re-apply old SYSCLK settings: %d\n", ret); 370 return ret; 371 } 372 373 ret = regmap_write(arizona->regmap, ARIZONA_FLL1_CONTROL_1, state->fll); 374 if (ret) { 375 dev_err(arizona->dev, 376 "Failed to re-apply old FLL settings: %d\n", ret); 377 return ret; 378 } 379 380 return 0; 381 } 382 383 static int wm5102_apply_hardware_patch(struct arizona *arizona) 384 { 385 struct arizona_sysclk_state state; 386 int err, ret; 387 388 ret = arizona_enable_freerun_sysclk(arizona, &state); 389 if (ret) 390 return ret; 391 392 /* Start the write sequencer and wait for it to finish */ 393 ret = regmap_write(arizona->regmap, ARIZONA_WRITE_SEQUENCER_CTRL_0, 394 ARIZONA_WSEQ_ENA | ARIZONA_WSEQ_START | 160); 395 if (ret) { 396 dev_err(arizona->dev, "Failed to start write sequencer: %d\n", 397 ret); 398 goto err; 399 } 400 401 ret = arizona_poll_reg(arizona, 30, ARIZONA_WRITE_SEQUENCER_CTRL_1, 402 ARIZONA_WSEQ_BUSY, 0); 403 if (ret) 404 regmap_write(arizona->regmap, ARIZONA_WRITE_SEQUENCER_CTRL_0, 405 ARIZONA_WSEQ_ABORT); 406 407 err: 408 err = arizona_disable_freerun_sysclk(arizona, &state); 409 410 return ret ?: err; 411 } 412 413 /* 414 * Register patch to some of the CODECs internal write sequences 415 * to ensure a clean exit from the low power sleep state. 416 */ 417 static const struct reg_sequence wm5110_sleep_patch[] = { 418 { 0x337A, 0xC100 }, 419 { 0x337B, 0x0041 }, 420 { 0x3300, 0xA210 }, 421 { 0x3301, 0x050C }, 422 }; 423 424 static int wm5110_apply_sleep_patch(struct arizona *arizona) 425 { 426 struct arizona_sysclk_state state; 427 int err, ret; 428 429 ret = arizona_enable_freerun_sysclk(arizona, &state); 430 if (ret) 431 return ret; 432 433 ret = regmap_multi_reg_write_bypassed(arizona->regmap, 434 wm5110_sleep_patch, 435 ARRAY_SIZE(wm5110_sleep_patch)); 436 437 err = arizona_disable_freerun_sysclk(arizona, &state); 438 439 return ret ?: err; 440 } 441 442 static int wm5102_clear_write_sequencer(struct arizona *arizona) 443 { 444 int ret; 445 446 ret = regmap_write(arizona->regmap, ARIZONA_WRITE_SEQUENCER_CTRL_3, 447 0x0); 448 if (ret) { 449 dev_err(arizona->dev, 450 "Failed to clear write sequencer state: %d\n", ret); 451 return ret; 452 } 453 454 arizona_enable_reset(arizona); 455 regulator_disable(arizona->dcvdd); 456 457 msleep(20); 458 459 ret = regulator_enable(arizona->dcvdd); 460 if (ret) { 461 dev_err(arizona->dev, "Failed to re-enable DCVDD: %d\n", ret); 462 return ret; 463 } 464 arizona_disable_reset(arizona); 465 466 return 0; 467 } 468 469 #ifdef CONFIG_PM 470 static int arizona_isolate_dcvdd(struct arizona *arizona) 471 { 472 int ret; 473 474 ret = regmap_update_bits(arizona->regmap, 475 ARIZONA_ISOLATION_CONTROL, 476 ARIZONA_ISOLATE_DCVDD1, 477 ARIZONA_ISOLATE_DCVDD1); 478 if (ret != 0) 479 dev_err(arizona->dev, "Failed to isolate DCVDD: %d\n", ret); 480 481 return ret; 482 } 483 484 static int arizona_connect_dcvdd(struct arizona *arizona) 485 { 486 int ret; 487 488 ret = regmap_update_bits(arizona->regmap, 489 ARIZONA_ISOLATION_CONTROL, 490 ARIZONA_ISOLATE_DCVDD1, 0); 491 if (ret != 0) 492 dev_err(arizona->dev, "Failed to connect DCVDD: %d\n", ret); 493 494 return ret; 495 } 496 497 static int arizona_is_jack_det_active(struct arizona *arizona) 498 { 499 unsigned int val; 500 int ret; 501 502 ret = regmap_read(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE, &val); 503 if (ret) { 504 dev_err(arizona->dev, 505 "Failed to check jack det status: %d\n", ret); 506 return ret; 507 } else if (val & ARIZONA_JD1_ENA) { 508 return 1; 509 } else { 510 return 0; 511 } 512 } 513 514 static int arizona_runtime_resume(struct device *dev) 515 { 516 struct arizona *arizona = dev_get_drvdata(dev); 517 int ret; 518 519 dev_dbg(arizona->dev, "Leaving AoD mode\n"); 520 521 if (arizona->has_fully_powered_off) { 522 dev_dbg(arizona->dev, "Re-enabling core supplies\n"); 523 524 ret = regulator_bulk_enable(arizona->num_core_supplies, 525 arizona->core_supplies); 526 if (ret) { 527 dev_err(dev, "Failed to enable core supplies: %d\n", 528 ret); 529 return ret; 530 } 531 } 532 533 ret = regulator_enable(arizona->dcvdd); 534 if (ret != 0) { 535 dev_err(arizona->dev, "Failed to enable DCVDD: %d\n", ret); 536 if (arizona->has_fully_powered_off) 537 regulator_bulk_disable(arizona->num_core_supplies, 538 arizona->core_supplies); 539 return ret; 540 } 541 542 if (arizona->has_fully_powered_off) { 543 arizona_disable_reset(arizona); 544 enable_irq(arizona->irq); 545 arizona->has_fully_powered_off = false; 546 } 547 548 regcache_cache_only(arizona->regmap, false); 549 550 switch (arizona->type) { 551 case WM5102: 552 if (arizona->external_dcvdd) { 553 ret = arizona_connect_dcvdd(arizona); 554 if (ret != 0) 555 goto err; 556 } 557 558 ret = wm5102_patch(arizona); 559 if (ret != 0) { 560 dev_err(arizona->dev, "Failed to apply patch: %d\n", 561 ret); 562 goto err; 563 } 564 565 ret = wm5102_apply_hardware_patch(arizona); 566 if (ret) { 567 dev_err(arizona->dev, 568 "Failed to apply hardware patch: %d\n", 569 ret); 570 goto err; 571 } 572 break; 573 case WM5110: 574 case WM8280: 575 ret = arizona_wait_for_boot(arizona); 576 if (ret) 577 goto err; 578 579 if (arizona->external_dcvdd) { 580 ret = arizona_connect_dcvdd(arizona); 581 if (ret != 0) 582 goto err; 583 } else { 584 /* 585 * As this is only called for the internal regulator 586 * (where we know voltage ranges available) it is ok 587 * to request an exact range. 588 */ 589 ret = regulator_set_voltage(arizona->dcvdd, 590 1200000, 1200000); 591 if (ret < 0) { 592 dev_err(arizona->dev, 593 "Failed to set resume voltage: %d\n", 594 ret); 595 goto err; 596 } 597 } 598 599 ret = wm5110_apply_sleep_patch(arizona); 600 if (ret) { 601 dev_err(arizona->dev, 602 "Failed to re-apply sleep patch: %d\n", 603 ret); 604 goto err; 605 } 606 break; 607 case WM1831: 608 case CS47L24: 609 ret = arizona_wait_for_boot(arizona); 610 if (ret != 0) 611 goto err; 612 break; 613 default: 614 ret = arizona_wait_for_boot(arizona); 615 if (ret != 0) 616 goto err; 617 618 if (arizona->external_dcvdd) { 619 ret = arizona_connect_dcvdd(arizona); 620 if (ret != 0) 621 goto err; 622 } 623 break; 624 } 625 626 ret = regcache_sync(arizona->regmap); 627 if (ret != 0) { 628 dev_err(arizona->dev, "Failed to restore register cache\n"); 629 goto err; 630 } 631 632 return 0; 633 634 err: 635 regcache_cache_only(arizona->regmap, true); 636 regulator_disable(arizona->dcvdd); 637 return ret; 638 } 639 640 static int arizona_runtime_suspend(struct device *dev) 641 { 642 struct arizona *arizona = dev_get_drvdata(dev); 643 int jd_active = 0; 644 int ret; 645 646 dev_dbg(arizona->dev, "Entering AoD mode\n"); 647 648 switch (arizona->type) { 649 case WM5110: 650 case WM8280: 651 jd_active = arizona_is_jack_det_active(arizona); 652 if (jd_active < 0) 653 return jd_active; 654 655 if (arizona->external_dcvdd) { 656 ret = arizona_isolate_dcvdd(arizona); 657 if (ret != 0) 658 return ret; 659 } else { 660 /* 661 * As this is only called for the internal regulator 662 * (where we know voltage ranges available) it is ok 663 * to request an exact range. 664 */ 665 ret = regulator_set_voltage(arizona->dcvdd, 666 1175000, 1175000); 667 if (ret < 0) { 668 dev_err(arizona->dev, 669 "Failed to set suspend voltage: %d\n", 670 ret); 671 return ret; 672 } 673 } 674 break; 675 case WM5102: 676 jd_active = arizona_is_jack_det_active(arizona); 677 if (jd_active < 0) 678 return jd_active; 679 680 if (arizona->external_dcvdd) { 681 ret = arizona_isolate_dcvdd(arizona); 682 if (ret != 0) 683 return ret; 684 } 685 686 if (!jd_active) { 687 ret = regmap_write(arizona->regmap, 688 ARIZONA_WRITE_SEQUENCER_CTRL_3, 0x0); 689 if (ret) { 690 dev_err(arizona->dev, 691 "Failed to clear write sequencer: %d\n", 692 ret); 693 return ret; 694 } 695 } 696 break; 697 case WM1831: 698 case CS47L24: 699 break; 700 default: 701 jd_active = arizona_is_jack_det_active(arizona); 702 if (jd_active < 0) 703 return jd_active; 704 705 if (arizona->external_dcvdd) { 706 ret = arizona_isolate_dcvdd(arizona); 707 if (ret != 0) 708 return ret; 709 } 710 break; 711 } 712 713 regcache_cache_only(arizona->regmap, true); 714 regcache_mark_dirty(arizona->regmap); 715 regulator_disable(arizona->dcvdd); 716 717 /* Allow us to completely power down if no jack detection */ 718 if (!jd_active) { 719 dev_dbg(arizona->dev, "Fully powering off\n"); 720 721 arizona->has_fully_powered_off = true; 722 723 disable_irq_nosync(arizona->irq); 724 arizona_enable_reset(arizona); 725 regulator_bulk_disable(arizona->num_core_supplies, 726 arizona->core_supplies); 727 } 728 729 return 0; 730 } 731 #endif 732 733 #ifdef CONFIG_PM_SLEEP 734 static int arizona_suspend(struct device *dev) 735 { 736 struct arizona *arizona = dev_get_drvdata(dev); 737 738 dev_dbg(arizona->dev, "Suspend, disabling IRQ\n"); 739 disable_irq(arizona->irq); 740 741 return 0; 742 } 743 744 static int arizona_suspend_noirq(struct device *dev) 745 { 746 struct arizona *arizona = dev_get_drvdata(dev); 747 748 dev_dbg(arizona->dev, "Late suspend, reenabling IRQ\n"); 749 enable_irq(arizona->irq); 750 751 return 0; 752 } 753 754 static int arizona_resume_noirq(struct device *dev) 755 { 756 struct arizona *arizona = dev_get_drvdata(dev); 757 758 dev_dbg(arizona->dev, "Early resume, disabling IRQ\n"); 759 disable_irq(arizona->irq); 760 761 return 0; 762 } 763 764 static int arizona_resume(struct device *dev) 765 { 766 struct arizona *arizona = dev_get_drvdata(dev); 767 768 dev_dbg(arizona->dev, "Resume, reenabling IRQ\n"); 769 enable_irq(arizona->irq); 770 771 return 0; 772 } 773 #endif 774 775 const struct dev_pm_ops arizona_pm_ops = { 776 SET_RUNTIME_PM_OPS(arizona_runtime_suspend, 777 arizona_runtime_resume, 778 NULL) 779 SET_SYSTEM_SLEEP_PM_OPS(arizona_suspend, arizona_resume) 780 SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(arizona_suspend_noirq, 781 arizona_resume_noirq) 782 }; 783 EXPORT_SYMBOL_GPL(arizona_pm_ops); 784 785 #ifdef CONFIG_OF 786 unsigned long arizona_of_get_type(struct device *dev) 787 { 788 const struct of_device_id *id = of_match_device(arizona_of_match, dev); 789 790 if (id) 791 return (unsigned long)id->data; 792 else 793 return 0; 794 } 795 EXPORT_SYMBOL_GPL(arizona_of_get_type); 796 797 static int arizona_of_get_core_pdata(struct arizona *arizona) 798 { 799 struct arizona_pdata *pdata = &arizona->pdata; 800 struct property *prop; 801 const __be32 *cur; 802 u32 val; 803 u32 pdm_val[ARIZONA_MAX_PDM_SPK]; 804 int ret, i; 805 int count = 0; 806 807 pdata->reset = of_get_named_gpio(arizona->dev->of_node, "wlf,reset", 0); 808 if (pdata->reset == -EPROBE_DEFER) { 809 return pdata->reset; 810 } else if (pdata->reset < 0) { 811 dev_err(arizona->dev, "Reset GPIO missing/malformed: %d\n", 812 pdata->reset); 813 814 pdata->reset = 0; 815 } 816 817 ret = of_property_read_u32_array(arizona->dev->of_node, 818 "wlf,gpio-defaults", 819 pdata->gpio_defaults, 820 ARRAY_SIZE(pdata->gpio_defaults)); 821 if (ret >= 0) { 822 /* 823 * All values are literal except out of range values 824 * which are chip default, translate into platform 825 * data which uses 0 as chip default and out of range 826 * as zero. 827 */ 828 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) { 829 if (pdata->gpio_defaults[i] > 0xffff) 830 pdata->gpio_defaults[i] = 0; 831 else if (pdata->gpio_defaults[i] == 0) 832 pdata->gpio_defaults[i] = 0x10000; 833 } 834 } else { 835 dev_err(arizona->dev, "Failed to parse GPIO defaults: %d\n", 836 ret); 837 } 838 839 of_property_for_each_u32(arizona->dev->of_node, "wlf,inmode", prop, 840 cur, val) { 841 if (count == ARRAY_SIZE(pdata->inmode)) 842 break; 843 844 pdata->inmode[count] = val; 845 count++; 846 } 847 848 count = 0; 849 of_property_for_each_u32(arizona->dev->of_node, "wlf,dmic-ref", prop, 850 cur, val) { 851 if (count == ARRAY_SIZE(pdata->dmic_ref)) 852 break; 853 854 pdata->dmic_ref[count] = val; 855 count++; 856 } 857 858 count = 0; 859 of_property_for_each_u32(arizona->dev->of_node, "wlf,out-mono", prop, 860 cur, val) { 861 if (count == ARRAY_SIZE(pdata->out_mono)) 862 break; 863 864 pdata->out_mono[count] = !!val; 865 count++; 866 } 867 868 count = 0; 869 of_property_for_each_u32(arizona->dev->of_node, 870 "wlf,max-channels-clocked", 871 prop, cur, val) { 872 if (count == ARRAY_SIZE(pdata->max_channels_clocked)) 873 break; 874 875 pdata->max_channels_clocked[count] = val; 876 count++; 877 } 878 879 ret = of_property_read_u32_array(arizona->dev->of_node, 880 "wlf,spk-fmt", 881 pdm_val, 882 ARRAY_SIZE(pdm_val)); 883 884 if (ret >= 0) 885 for (count = 0; count < ARRAY_SIZE(pdata->spk_fmt); ++count) 886 pdata->spk_fmt[count] = pdm_val[count]; 887 888 ret = of_property_read_u32_array(arizona->dev->of_node, 889 "wlf,spk-mute", 890 pdm_val, 891 ARRAY_SIZE(pdm_val)); 892 893 if (ret >= 0) 894 for (count = 0; count < ARRAY_SIZE(pdata->spk_mute); ++count) 895 pdata->spk_mute[count] = pdm_val[count]; 896 897 return 0; 898 } 899 900 const struct of_device_id arizona_of_match[] = { 901 { .compatible = "wlf,wm5102", .data = (void *)WM5102 }, 902 { .compatible = "wlf,wm5110", .data = (void *)WM5110 }, 903 { .compatible = "wlf,wm8280", .data = (void *)WM8280 }, 904 { .compatible = "wlf,wm8997", .data = (void *)WM8997 }, 905 { .compatible = "wlf,wm8998", .data = (void *)WM8998 }, 906 { .compatible = "wlf,wm1814", .data = (void *)WM1814 }, 907 { .compatible = "wlf,wm1831", .data = (void *)WM1831 }, 908 { .compatible = "cirrus,cs47l24", .data = (void *)CS47L24 }, 909 {}, 910 }; 911 EXPORT_SYMBOL_GPL(arizona_of_match); 912 #else 913 static inline int arizona_of_get_core_pdata(struct arizona *arizona) 914 { 915 return 0; 916 } 917 #endif 918 919 static const struct mfd_cell early_devs[] = { 920 { .name = "arizona-ldo1" }, 921 }; 922 923 static const char * const wm5102_supplies[] = { 924 "MICVDD", 925 "DBVDD2", 926 "DBVDD3", 927 "CPVDD", 928 "SPKVDDL", 929 "SPKVDDR", 930 }; 931 932 static const struct mfd_cell wm5102_devs[] = { 933 { .name = "arizona-micsupp" }, 934 { .name = "arizona-gpio" }, 935 { 936 .name = "arizona-extcon", 937 .parent_supplies = wm5102_supplies, 938 .num_parent_supplies = 1, /* We only need MICVDD */ 939 }, 940 { .name = "arizona-haptics" }, 941 { .name = "arizona-pwm" }, 942 { 943 .name = "wm5102-codec", 944 .parent_supplies = wm5102_supplies, 945 .num_parent_supplies = ARRAY_SIZE(wm5102_supplies), 946 }, 947 }; 948 949 static const struct mfd_cell wm5110_devs[] = { 950 { .name = "arizona-micsupp" }, 951 { .name = "arizona-gpio" }, 952 { 953 .name = "arizona-extcon", 954 .parent_supplies = wm5102_supplies, 955 .num_parent_supplies = 1, /* We only need MICVDD */ 956 }, 957 { .name = "arizona-haptics" }, 958 { .name = "arizona-pwm" }, 959 { 960 .name = "wm5110-codec", 961 .parent_supplies = wm5102_supplies, 962 .num_parent_supplies = ARRAY_SIZE(wm5102_supplies), 963 }, 964 }; 965 966 static const char * const cs47l24_supplies[] = { 967 "MICVDD", 968 "CPVDD", 969 "SPKVDD", 970 }; 971 972 static const struct mfd_cell cs47l24_devs[] = { 973 { .name = "arizona-gpio" }, 974 { .name = "arizona-haptics" }, 975 { .name = "arizona-pwm" }, 976 { 977 .name = "cs47l24-codec", 978 .parent_supplies = cs47l24_supplies, 979 .num_parent_supplies = ARRAY_SIZE(cs47l24_supplies), 980 }, 981 }; 982 983 static const char * const wm8997_supplies[] = { 984 "MICVDD", 985 "DBVDD2", 986 "CPVDD", 987 "SPKVDD", 988 }; 989 990 static const struct mfd_cell wm8997_devs[] = { 991 { .name = "arizona-micsupp" }, 992 { .name = "arizona-gpio" }, 993 { 994 .name = "arizona-extcon", 995 .parent_supplies = wm8997_supplies, 996 .num_parent_supplies = 1, /* We only need MICVDD */ 997 }, 998 { .name = "arizona-haptics" }, 999 { .name = "arizona-pwm" }, 1000 { 1001 .name = "wm8997-codec", 1002 .parent_supplies = wm8997_supplies, 1003 .num_parent_supplies = ARRAY_SIZE(wm8997_supplies), 1004 }, 1005 }; 1006 1007 static const struct mfd_cell wm8998_devs[] = { 1008 { .name = "arizona-micsupp" }, 1009 { .name = "arizona-gpio" }, 1010 { 1011 .name = "arizona-extcon", 1012 .parent_supplies = wm5102_supplies, 1013 .num_parent_supplies = 1, /* We only need MICVDD */ 1014 }, 1015 { .name = "arizona-haptics" }, 1016 { .name = "arizona-pwm" }, 1017 { 1018 .name = "wm8998-codec", 1019 .parent_supplies = wm5102_supplies, 1020 .num_parent_supplies = ARRAY_SIZE(wm5102_supplies), 1021 }, 1022 }; 1023 1024 int arizona_dev_init(struct arizona *arizona) 1025 { 1026 const char * const mclk_name[] = { "mclk1", "mclk2" }; 1027 struct device *dev = arizona->dev; 1028 const char *type_name = NULL; 1029 unsigned int reg, val, mask; 1030 int (*apply_patch)(struct arizona *) = NULL; 1031 const struct mfd_cell *subdevs = NULL; 1032 int n_subdevs, ret, i; 1033 1034 dev_set_drvdata(arizona->dev, arizona); 1035 mutex_init(&arizona->clk_lock); 1036 1037 if (dev_get_platdata(arizona->dev)) { 1038 memcpy(&arizona->pdata, dev_get_platdata(arizona->dev), 1039 sizeof(arizona->pdata)); 1040 } else { 1041 ret = arizona_of_get_core_pdata(arizona); 1042 if (ret < 0) 1043 return ret; 1044 } 1045 1046 BUILD_BUG_ON(ARRAY_SIZE(arizona->mclk) != ARRAY_SIZE(mclk_name)); 1047 for (i = 0; i < ARRAY_SIZE(arizona->mclk); i++) { 1048 arizona->mclk[i] = devm_clk_get(arizona->dev, mclk_name[i]); 1049 if (IS_ERR(arizona->mclk[i])) { 1050 dev_info(arizona->dev, "Failed to get %s: %ld\n", 1051 mclk_name[i], PTR_ERR(arizona->mclk[i])); 1052 arizona->mclk[i] = NULL; 1053 } 1054 } 1055 1056 regcache_cache_only(arizona->regmap, true); 1057 1058 switch (arizona->type) { 1059 case WM5102: 1060 case WM5110: 1061 case WM8280: 1062 case WM8997: 1063 case WM8998: 1064 case WM1814: 1065 case WM1831: 1066 case CS47L24: 1067 for (i = 0; i < ARRAY_SIZE(wm5102_core_supplies); i++) 1068 arizona->core_supplies[i].supply 1069 = wm5102_core_supplies[i]; 1070 arizona->num_core_supplies = ARRAY_SIZE(wm5102_core_supplies); 1071 break; 1072 default: 1073 dev_err(arizona->dev, "Unknown device type %d\n", 1074 arizona->type); 1075 return -ENODEV; 1076 } 1077 1078 /* Mark DCVDD as external, LDO1 driver will clear if internal */ 1079 arizona->external_dcvdd = true; 1080 1081 switch (arizona->type) { 1082 case WM1831: 1083 case CS47L24: 1084 break; /* No LDO1 regulator */ 1085 default: 1086 ret = mfd_add_devices(arizona->dev, -1, early_devs, 1087 ARRAY_SIZE(early_devs), NULL, 0, NULL); 1088 if (ret != 0) { 1089 dev_err(dev, "Failed to add early children: %d\n", ret); 1090 return ret; 1091 } 1092 break; 1093 } 1094 1095 ret = devm_regulator_bulk_get(dev, arizona->num_core_supplies, 1096 arizona->core_supplies); 1097 if (ret != 0) { 1098 dev_err(dev, "Failed to request core supplies: %d\n", 1099 ret); 1100 goto err_early; 1101 } 1102 1103 /** 1104 * Don't use devres here because the only device we have to get 1105 * against is the MFD device and DCVDD will likely be supplied by 1106 * one of its children. Meaning that the regulator will be 1107 * destroyed by the time devres calls regulator put. 1108 */ 1109 arizona->dcvdd = regulator_get(arizona->dev, "DCVDD"); 1110 if (IS_ERR(arizona->dcvdd)) { 1111 ret = PTR_ERR(arizona->dcvdd); 1112 dev_err(dev, "Failed to request DCVDD: %d\n", ret); 1113 goto err_early; 1114 } 1115 1116 if (arizona->pdata.reset) { 1117 /* Start out with /RESET low to put the chip into reset */ 1118 ret = devm_gpio_request_one(arizona->dev, arizona->pdata.reset, 1119 GPIOF_DIR_OUT | GPIOF_INIT_LOW, 1120 "arizona /RESET"); 1121 if (ret != 0) { 1122 dev_err(dev, "Failed to request /RESET: %d\n", ret); 1123 goto err_dcvdd; 1124 } 1125 } 1126 1127 ret = regulator_bulk_enable(arizona->num_core_supplies, 1128 arizona->core_supplies); 1129 if (ret != 0) { 1130 dev_err(dev, "Failed to enable core supplies: %d\n", 1131 ret); 1132 goto err_dcvdd; 1133 } 1134 1135 ret = regulator_enable(arizona->dcvdd); 1136 if (ret != 0) { 1137 dev_err(dev, "Failed to enable DCVDD: %d\n", ret); 1138 goto err_enable; 1139 } 1140 1141 arizona_disable_reset(arizona); 1142 1143 regcache_cache_only(arizona->regmap, false); 1144 1145 /* Verify that this is a chip we know about */ 1146 ret = regmap_read(arizona->regmap, ARIZONA_SOFTWARE_RESET, ®); 1147 if (ret != 0) { 1148 dev_err(dev, "Failed to read ID register: %d\n", ret); 1149 goto err_reset; 1150 } 1151 1152 switch (reg) { 1153 case 0x5102: 1154 case 0x5110: 1155 case 0x6349: 1156 case 0x6363: 1157 case 0x8997: 1158 break; 1159 default: 1160 dev_err(arizona->dev, "Unknown device ID: %x\n", reg); 1161 ret = -ENODEV; 1162 goto err_reset; 1163 } 1164 1165 /* If we have a /RESET GPIO we'll already be reset */ 1166 if (!arizona->pdata.reset) { 1167 ret = regmap_write(arizona->regmap, ARIZONA_SOFTWARE_RESET, 0); 1168 if (ret != 0) { 1169 dev_err(dev, "Failed to reset device: %d\n", ret); 1170 goto err_reset; 1171 } 1172 1173 usleep_range(1000, 5000); 1174 } 1175 1176 /* Ensure device startup is complete */ 1177 switch (arizona->type) { 1178 case WM5102: 1179 ret = regmap_read(arizona->regmap, 1180 ARIZONA_WRITE_SEQUENCER_CTRL_3, &val); 1181 if (ret) { 1182 dev_err(dev, 1183 "Failed to check write sequencer state: %d\n", 1184 ret); 1185 } else if (val & 0x01) { 1186 ret = wm5102_clear_write_sequencer(arizona); 1187 if (ret) 1188 return ret; 1189 } 1190 break; 1191 default: 1192 break; 1193 } 1194 1195 ret = arizona_wait_for_boot(arizona); 1196 if (ret) { 1197 dev_err(arizona->dev, "Device failed initial boot: %d\n", ret); 1198 goto err_reset; 1199 } 1200 1201 /* Read the device ID information & do device specific stuff */ 1202 ret = regmap_read(arizona->regmap, ARIZONA_SOFTWARE_RESET, ®); 1203 if (ret != 0) { 1204 dev_err(dev, "Failed to read ID register: %d\n", ret); 1205 goto err_reset; 1206 } 1207 1208 ret = regmap_read(arizona->regmap, ARIZONA_DEVICE_REVISION, 1209 &arizona->rev); 1210 if (ret != 0) { 1211 dev_err(dev, "Failed to read revision register: %d\n", ret); 1212 goto err_reset; 1213 } 1214 arizona->rev &= ARIZONA_DEVICE_REVISION_MASK; 1215 1216 switch (reg) { 1217 case 0x5102: 1218 if (IS_ENABLED(CONFIG_MFD_WM5102)) { 1219 type_name = "WM5102"; 1220 if (arizona->type != WM5102) { 1221 dev_warn(arizona->dev, 1222 "WM5102 registered as %d\n", 1223 arizona->type); 1224 arizona->type = WM5102; 1225 } 1226 1227 apply_patch = wm5102_patch; 1228 arizona->rev &= 0x7; 1229 subdevs = wm5102_devs; 1230 n_subdevs = ARRAY_SIZE(wm5102_devs); 1231 } 1232 break; 1233 case 0x5110: 1234 if (IS_ENABLED(CONFIG_MFD_WM5110)) { 1235 switch (arizona->type) { 1236 case WM5110: 1237 type_name = "WM5110"; 1238 break; 1239 case WM8280: 1240 type_name = "WM8280"; 1241 break; 1242 default: 1243 type_name = "WM5110"; 1244 dev_warn(arizona->dev, 1245 "WM5110 registered as %d\n", 1246 arizona->type); 1247 arizona->type = WM5110; 1248 break; 1249 } 1250 1251 apply_patch = wm5110_patch; 1252 subdevs = wm5110_devs; 1253 n_subdevs = ARRAY_SIZE(wm5110_devs); 1254 } 1255 break; 1256 case 0x6363: 1257 if (IS_ENABLED(CONFIG_MFD_CS47L24)) { 1258 switch (arizona->type) { 1259 case CS47L24: 1260 type_name = "CS47L24"; 1261 break; 1262 1263 case WM1831: 1264 type_name = "WM1831"; 1265 break; 1266 1267 default: 1268 dev_warn(arizona->dev, 1269 "CS47L24 registered as %d\n", 1270 arizona->type); 1271 arizona->type = CS47L24; 1272 break; 1273 } 1274 1275 apply_patch = cs47l24_patch; 1276 subdevs = cs47l24_devs; 1277 n_subdevs = ARRAY_SIZE(cs47l24_devs); 1278 } 1279 break; 1280 case 0x8997: 1281 if (IS_ENABLED(CONFIG_MFD_WM8997)) { 1282 type_name = "WM8997"; 1283 if (arizona->type != WM8997) { 1284 dev_warn(arizona->dev, 1285 "WM8997 registered as %d\n", 1286 arizona->type); 1287 arizona->type = WM8997; 1288 } 1289 1290 apply_patch = wm8997_patch; 1291 subdevs = wm8997_devs; 1292 n_subdevs = ARRAY_SIZE(wm8997_devs); 1293 } 1294 break; 1295 case 0x6349: 1296 if (IS_ENABLED(CONFIG_MFD_WM8998)) { 1297 switch (arizona->type) { 1298 case WM8998: 1299 type_name = "WM8998"; 1300 break; 1301 1302 case WM1814: 1303 type_name = "WM1814"; 1304 break; 1305 1306 default: 1307 type_name = "WM8998"; 1308 dev_warn(arizona->dev, 1309 "WM8998 registered as %d\n", 1310 arizona->type); 1311 arizona->type = WM8998; 1312 } 1313 1314 apply_patch = wm8998_patch; 1315 subdevs = wm8998_devs; 1316 n_subdevs = ARRAY_SIZE(wm8998_devs); 1317 } 1318 break; 1319 default: 1320 dev_err(arizona->dev, "Unknown device ID %x\n", reg); 1321 ret = -ENODEV; 1322 goto err_reset; 1323 } 1324 1325 if (!subdevs) { 1326 dev_err(arizona->dev, 1327 "No kernel support for device ID %x\n", reg); 1328 ret = -ENODEV; 1329 goto err_reset; 1330 } 1331 1332 dev_info(dev, "%s revision %c\n", type_name, arizona->rev + 'A'); 1333 1334 if (apply_patch) { 1335 ret = apply_patch(arizona); 1336 if (ret != 0) { 1337 dev_err(arizona->dev, "Failed to apply patch: %d\n", 1338 ret); 1339 goto err_reset; 1340 } 1341 1342 switch (arizona->type) { 1343 case WM5102: 1344 ret = wm5102_apply_hardware_patch(arizona); 1345 if (ret) { 1346 dev_err(arizona->dev, 1347 "Failed to apply hardware patch: %d\n", 1348 ret); 1349 goto err_reset; 1350 } 1351 break; 1352 case WM5110: 1353 case WM8280: 1354 ret = wm5110_apply_sleep_patch(arizona); 1355 if (ret) { 1356 dev_err(arizona->dev, 1357 "Failed to apply sleep patch: %d\n", 1358 ret); 1359 goto err_reset; 1360 } 1361 break; 1362 default: 1363 break; 1364 } 1365 } 1366 1367 for (i = 0; i < ARRAY_SIZE(arizona->pdata.gpio_defaults); i++) { 1368 if (!arizona->pdata.gpio_defaults[i]) 1369 continue; 1370 1371 regmap_write(arizona->regmap, ARIZONA_GPIO1_CTRL + i, 1372 arizona->pdata.gpio_defaults[i]); 1373 } 1374 1375 /* Chip default */ 1376 if (!arizona->pdata.clk32k_src) 1377 arizona->pdata.clk32k_src = ARIZONA_32KZ_MCLK2; 1378 1379 switch (arizona->pdata.clk32k_src) { 1380 case ARIZONA_32KZ_MCLK1: 1381 case ARIZONA_32KZ_MCLK2: 1382 regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1, 1383 ARIZONA_CLK_32K_SRC_MASK, 1384 arizona->pdata.clk32k_src - 1); 1385 arizona_clk32k_enable(arizona); 1386 break; 1387 case ARIZONA_32KZ_NONE: 1388 regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1, 1389 ARIZONA_CLK_32K_SRC_MASK, 2); 1390 break; 1391 default: 1392 dev_err(arizona->dev, "Invalid 32kHz clock source: %d\n", 1393 arizona->pdata.clk32k_src); 1394 ret = -EINVAL; 1395 goto err_reset; 1396 } 1397 1398 for (i = 0; i < ARIZONA_MAX_MICBIAS; i++) { 1399 if (!arizona->pdata.micbias[i].mV && 1400 !arizona->pdata.micbias[i].bypass) 1401 continue; 1402 1403 /* Apply default for bypass mode */ 1404 if (!arizona->pdata.micbias[i].mV) 1405 arizona->pdata.micbias[i].mV = 2800; 1406 1407 val = (arizona->pdata.micbias[i].mV - 1500) / 100; 1408 1409 val <<= ARIZONA_MICB1_LVL_SHIFT; 1410 1411 if (arizona->pdata.micbias[i].ext_cap) 1412 val |= ARIZONA_MICB1_EXT_CAP; 1413 1414 if (arizona->pdata.micbias[i].discharge) 1415 val |= ARIZONA_MICB1_DISCH; 1416 1417 if (arizona->pdata.micbias[i].soft_start) 1418 val |= ARIZONA_MICB1_RATE; 1419 1420 if (arizona->pdata.micbias[i].bypass) 1421 val |= ARIZONA_MICB1_BYPASS; 1422 1423 regmap_update_bits(arizona->regmap, 1424 ARIZONA_MIC_BIAS_CTRL_1 + i, 1425 ARIZONA_MICB1_LVL_MASK | 1426 ARIZONA_MICB1_EXT_CAP | 1427 ARIZONA_MICB1_DISCH | 1428 ARIZONA_MICB1_BYPASS | 1429 ARIZONA_MICB1_RATE, val); 1430 } 1431 1432 for (i = 0; i < ARIZONA_MAX_INPUT; i++) { 1433 /* Default for both is 0 so noop with defaults */ 1434 val = arizona->pdata.dmic_ref[i] 1435 << ARIZONA_IN1_DMIC_SUP_SHIFT; 1436 if (arizona->pdata.inmode[i] & ARIZONA_INMODE_DMIC) 1437 val |= 1 << ARIZONA_IN1_MODE_SHIFT; 1438 1439 switch (arizona->type) { 1440 case WM8998: 1441 case WM1814: 1442 regmap_update_bits(arizona->regmap, 1443 ARIZONA_ADC_DIGITAL_VOLUME_1L + (i * 8), 1444 ARIZONA_IN1L_SRC_SE_MASK, 1445 (arizona->pdata.inmode[i] & ARIZONA_INMODE_SE) 1446 << ARIZONA_IN1L_SRC_SE_SHIFT); 1447 1448 regmap_update_bits(arizona->regmap, 1449 ARIZONA_ADC_DIGITAL_VOLUME_1R + (i * 8), 1450 ARIZONA_IN1R_SRC_SE_MASK, 1451 (arizona->pdata.inmode[i] & ARIZONA_INMODE_SE) 1452 << ARIZONA_IN1R_SRC_SE_SHIFT); 1453 1454 mask = ARIZONA_IN1_DMIC_SUP_MASK | 1455 ARIZONA_IN1_MODE_MASK; 1456 break; 1457 default: 1458 if (arizona->pdata.inmode[i] & ARIZONA_INMODE_SE) 1459 val |= 1 << ARIZONA_IN1_SINGLE_ENDED_SHIFT; 1460 1461 mask = ARIZONA_IN1_DMIC_SUP_MASK | 1462 ARIZONA_IN1_MODE_MASK | 1463 ARIZONA_IN1_SINGLE_ENDED_MASK; 1464 break; 1465 } 1466 1467 regmap_update_bits(arizona->regmap, 1468 ARIZONA_IN1L_CONTROL + (i * 8), 1469 mask, val); 1470 } 1471 1472 for (i = 0; i < ARIZONA_MAX_OUTPUT; i++) { 1473 /* Default is 0 so noop with defaults */ 1474 if (arizona->pdata.out_mono[i]) 1475 val = ARIZONA_OUT1_MONO; 1476 else 1477 val = 0; 1478 1479 regmap_update_bits(arizona->regmap, 1480 ARIZONA_OUTPUT_PATH_CONFIG_1L + (i * 8), 1481 ARIZONA_OUT1_MONO, val); 1482 } 1483 1484 for (i = 0; i < ARIZONA_MAX_PDM_SPK; i++) { 1485 if (arizona->pdata.spk_mute[i]) 1486 regmap_update_bits(arizona->regmap, 1487 ARIZONA_PDM_SPK1_CTRL_1 + (i * 2), 1488 ARIZONA_SPK1_MUTE_ENDIAN_MASK | 1489 ARIZONA_SPK1_MUTE_SEQ1_MASK, 1490 arizona->pdata.spk_mute[i]); 1491 1492 if (arizona->pdata.spk_fmt[i]) 1493 regmap_update_bits(arizona->regmap, 1494 ARIZONA_PDM_SPK1_CTRL_2 + (i * 2), 1495 ARIZONA_SPK1_FMT_MASK, 1496 arizona->pdata.spk_fmt[i]); 1497 } 1498 1499 pm_runtime_set_active(arizona->dev); 1500 pm_runtime_enable(arizona->dev); 1501 1502 /* Set up for interrupts */ 1503 ret = arizona_irq_init(arizona); 1504 if (ret != 0) 1505 goto err_pm; 1506 1507 pm_runtime_set_autosuspend_delay(arizona->dev, 100); 1508 pm_runtime_use_autosuspend(arizona->dev); 1509 1510 arizona_request_irq(arizona, ARIZONA_IRQ_CLKGEN_ERR, "CLKGEN error", 1511 arizona_clkgen_err, arizona); 1512 arizona_request_irq(arizona, ARIZONA_IRQ_OVERCLOCKED, "Overclocked", 1513 arizona_overclocked, arizona); 1514 arizona_request_irq(arizona, ARIZONA_IRQ_UNDERCLOCKED, "Underclocked", 1515 arizona_underclocked, arizona); 1516 1517 ret = mfd_add_devices(arizona->dev, PLATFORM_DEVID_NONE, 1518 subdevs, n_subdevs, NULL, 0, NULL); 1519 1520 if (ret) { 1521 dev_err(arizona->dev, "Failed to add subdevices: %d\n", ret); 1522 goto err_irq; 1523 } 1524 1525 return 0; 1526 1527 err_irq: 1528 arizona_irq_exit(arizona); 1529 err_pm: 1530 pm_runtime_disable(arizona->dev); 1531 err_reset: 1532 arizona_enable_reset(arizona); 1533 regulator_disable(arizona->dcvdd); 1534 err_enable: 1535 regulator_bulk_disable(arizona->num_core_supplies, 1536 arizona->core_supplies); 1537 err_dcvdd: 1538 regulator_put(arizona->dcvdd); 1539 err_early: 1540 mfd_remove_devices(dev); 1541 return ret; 1542 } 1543 EXPORT_SYMBOL_GPL(arizona_dev_init); 1544 1545 int arizona_dev_exit(struct arizona *arizona) 1546 { 1547 disable_irq(arizona->irq); 1548 pm_runtime_disable(arizona->dev); 1549 1550 regulator_disable(arizona->dcvdd); 1551 regulator_put(arizona->dcvdd); 1552 1553 mfd_remove_devices(arizona->dev); 1554 arizona_free_irq(arizona, ARIZONA_IRQ_UNDERCLOCKED, arizona); 1555 arizona_free_irq(arizona, ARIZONA_IRQ_OVERCLOCKED, arizona); 1556 arizona_free_irq(arizona, ARIZONA_IRQ_CLKGEN_ERR, arizona); 1557 arizona_irq_exit(arizona); 1558 arizona_enable_reset(arizona); 1559 1560 regulator_bulk_disable(arizona->num_core_supplies, 1561 arizona->core_supplies); 1562 return 0; 1563 } 1564 EXPORT_SYMBOL_GPL(arizona_dev_exit); 1565