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