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/consumer.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/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/ktime.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 pm_runtime_put_sync(arizona->dev); 57 goto err_ref; 58 } 59 break; 60 case ARIZONA_32KZ_MCLK2: 61 ret = clk_prepare_enable(arizona->mclk[ARIZONA_MCLK2]); 62 if (ret != 0) 63 goto err_ref; 64 break; 65 } 66 67 ret = regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1, 68 ARIZONA_CLK_32K_ENA, 69 ARIZONA_CLK_32K_ENA); 70 } 71 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 inline bool arizona_poll_reg_delay(ktime_t timeout) 241 { 242 if (ktime_compare(ktime_get(), timeout) > 0) 243 return false; 244 245 usleep_range(ARIZONA_REG_POLL_DELAY_US / 2, ARIZONA_REG_POLL_DELAY_US); 246 247 return true; 248 } 249 250 static int arizona_poll_reg(struct arizona *arizona, 251 int timeout_ms, unsigned int reg, 252 unsigned int mask, unsigned int target) 253 { 254 ktime_t timeout = ktime_add_us(ktime_get(), timeout_ms * USEC_PER_MSEC); 255 unsigned int val = 0; 256 int ret; 257 258 do { 259 ret = regmap_read(arizona->regmap, reg, &val); 260 261 if ((val & mask) == target) 262 return 0; 263 } while (arizona_poll_reg_delay(timeout)); 264 265 if (ret) { 266 dev_err(arizona->dev, "Failed polling reg 0x%x: %d\n", 267 reg, ret); 268 return ret; 269 } 270 271 dev_err(arizona->dev, "Polling reg 0x%x timed out: %x\n", reg, val); 272 return -ETIMEDOUT; 273 } 274 275 static int arizona_wait_for_boot(struct arizona *arizona) 276 { 277 int ret; 278 279 /* 280 * We can't use an interrupt as we need to runtime resume to do so, 281 * we won't race with the interrupt handler as it'll be blocked on 282 * runtime resume. 283 */ 284 ret = arizona_poll_reg(arizona, 30, ARIZONA_INTERRUPT_RAW_STATUS_5, 285 ARIZONA_BOOT_DONE_STS, ARIZONA_BOOT_DONE_STS); 286 287 if (!ret) 288 regmap_write(arizona->regmap, ARIZONA_INTERRUPT_STATUS_5, 289 ARIZONA_BOOT_DONE_STS); 290 291 pm_runtime_mark_last_busy(arizona->dev); 292 293 return ret; 294 } 295 296 static inline void arizona_enable_reset(struct arizona *arizona) 297 { 298 if (arizona->pdata.reset) 299 gpiod_set_raw_value_cansleep(arizona->pdata.reset, 0); 300 } 301 302 static void arizona_disable_reset(struct arizona *arizona) 303 { 304 if (arizona->pdata.reset) { 305 switch (arizona->type) { 306 case WM5110: 307 case WM8280: 308 /* Meet requirements for minimum reset duration */ 309 usleep_range(5000, 10000); 310 break; 311 default: 312 break; 313 } 314 315 gpiod_set_raw_value_cansleep(arizona->pdata.reset, 1); 316 usleep_range(1000, 5000); 317 } 318 } 319 320 struct arizona_sysclk_state { 321 unsigned int fll; 322 unsigned int sysclk; 323 }; 324 325 static int arizona_enable_freerun_sysclk(struct arizona *arizona, 326 struct arizona_sysclk_state *state) 327 { 328 int ret, err; 329 330 /* Cache existing FLL and SYSCLK settings */ 331 ret = regmap_read(arizona->regmap, ARIZONA_FLL1_CONTROL_1, &state->fll); 332 if (ret) { 333 dev_err(arizona->dev, "Failed to cache FLL settings: %d\n", 334 ret); 335 return ret; 336 } 337 ret = regmap_read(arizona->regmap, ARIZONA_SYSTEM_CLOCK_1, 338 &state->sysclk); 339 if (ret) { 340 dev_err(arizona->dev, "Failed to cache SYSCLK settings: %d\n", 341 ret); 342 return ret; 343 } 344 345 /* Start up SYSCLK using the FLL in free running mode */ 346 ret = regmap_write(arizona->regmap, ARIZONA_FLL1_CONTROL_1, 347 ARIZONA_FLL1_ENA | ARIZONA_FLL1_FREERUN); 348 if (ret) { 349 dev_err(arizona->dev, 350 "Failed to start FLL in freerunning mode: %d\n", 351 ret); 352 return ret; 353 } 354 ret = arizona_poll_reg(arizona, 180, ARIZONA_INTERRUPT_RAW_STATUS_5, 355 ARIZONA_FLL1_CLOCK_OK_STS, 356 ARIZONA_FLL1_CLOCK_OK_STS); 357 if (ret) 358 goto err_fll; 359 360 ret = regmap_write(arizona->regmap, ARIZONA_SYSTEM_CLOCK_1, 0x0144); 361 if (ret) { 362 dev_err(arizona->dev, "Failed to start SYSCLK: %d\n", ret); 363 goto err_fll; 364 } 365 366 return 0; 367 368 err_fll: 369 err = regmap_write(arizona->regmap, ARIZONA_FLL1_CONTROL_1, state->fll); 370 if (err) 371 dev_err(arizona->dev, 372 "Failed to re-apply old FLL settings: %d\n", err); 373 374 return ret; 375 } 376 377 static int arizona_disable_freerun_sysclk(struct arizona *arizona, 378 struct arizona_sysclk_state *state) 379 { 380 int ret; 381 382 ret = regmap_write(arizona->regmap, ARIZONA_SYSTEM_CLOCK_1, 383 state->sysclk); 384 if (ret) { 385 dev_err(arizona->dev, 386 "Failed to re-apply old SYSCLK settings: %d\n", ret); 387 return ret; 388 } 389 390 ret = regmap_write(arizona->regmap, ARIZONA_FLL1_CONTROL_1, state->fll); 391 if (ret) { 392 dev_err(arizona->dev, 393 "Failed to re-apply old FLL settings: %d\n", ret); 394 return ret; 395 } 396 397 return 0; 398 } 399 400 static int wm5102_apply_hardware_patch(struct arizona *arizona) 401 { 402 struct arizona_sysclk_state state; 403 int err, ret; 404 405 ret = arizona_enable_freerun_sysclk(arizona, &state); 406 if (ret) 407 return ret; 408 409 /* Start the write sequencer and wait for it to finish */ 410 ret = regmap_write(arizona->regmap, ARIZONA_WRITE_SEQUENCER_CTRL_0, 411 ARIZONA_WSEQ_ENA | ARIZONA_WSEQ_START | 160); 412 if (ret) { 413 dev_err(arizona->dev, "Failed to start write sequencer: %d\n", 414 ret); 415 goto err; 416 } 417 418 ret = arizona_poll_reg(arizona, 30, ARIZONA_WRITE_SEQUENCER_CTRL_1, 419 ARIZONA_WSEQ_BUSY, 0); 420 if (ret) 421 regmap_write(arizona->regmap, ARIZONA_WRITE_SEQUENCER_CTRL_0, 422 ARIZONA_WSEQ_ABORT); 423 424 err: 425 err = arizona_disable_freerun_sysclk(arizona, &state); 426 427 return ret ?: err; 428 } 429 430 /* 431 * Register patch to some of the CODECs internal write sequences 432 * to ensure a clean exit from the low power sleep state. 433 */ 434 static const struct reg_sequence wm5110_sleep_patch[] = { 435 { 0x337A, 0xC100 }, 436 { 0x337B, 0x0041 }, 437 { 0x3300, 0xA210 }, 438 { 0x3301, 0x050C }, 439 }; 440 441 static int wm5110_apply_sleep_patch(struct arizona *arizona) 442 { 443 struct arizona_sysclk_state state; 444 int err, ret; 445 446 ret = arizona_enable_freerun_sysclk(arizona, &state); 447 if (ret) 448 return ret; 449 450 ret = regmap_multi_reg_write_bypassed(arizona->regmap, 451 wm5110_sleep_patch, 452 ARRAY_SIZE(wm5110_sleep_patch)); 453 454 err = arizona_disable_freerun_sysclk(arizona, &state); 455 456 return ret ?: err; 457 } 458 459 static int wm5102_clear_write_sequencer(struct arizona *arizona) 460 { 461 int ret; 462 463 ret = regmap_write(arizona->regmap, ARIZONA_WRITE_SEQUENCER_CTRL_3, 464 0x0); 465 if (ret) { 466 dev_err(arizona->dev, 467 "Failed to clear write sequencer state: %d\n", ret); 468 return ret; 469 } 470 471 arizona_enable_reset(arizona); 472 regulator_disable(arizona->dcvdd); 473 474 msleep(20); 475 476 ret = regulator_enable(arizona->dcvdd); 477 if (ret) { 478 dev_err(arizona->dev, "Failed to re-enable DCVDD: %d\n", ret); 479 return ret; 480 } 481 arizona_disable_reset(arizona); 482 483 return 0; 484 } 485 486 #ifdef CONFIG_PM 487 static int arizona_isolate_dcvdd(struct arizona *arizona) 488 { 489 int ret; 490 491 ret = regmap_update_bits(arizona->regmap, 492 ARIZONA_ISOLATION_CONTROL, 493 ARIZONA_ISOLATE_DCVDD1, 494 ARIZONA_ISOLATE_DCVDD1); 495 if (ret != 0) 496 dev_err(arizona->dev, "Failed to isolate DCVDD: %d\n", ret); 497 498 return ret; 499 } 500 501 static int arizona_connect_dcvdd(struct arizona *arizona) 502 { 503 int ret; 504 505 ret = regmap_update_bits(arizona->regmap, 506 ARIZONA_ISOLATION_CONTROL, 507 ARIZONA_ISOLATE_DCVDD1, 0); 508 if (ret != 0) 509 dev_err(arizona->dev, "Failed to connect DCVDD: %d\n", ret); 510 511 return ret; 512 } 513 514 static int arizona_is_jack_det_active(struct arizona *arizona) 515 { 516 unsigned int val; 517 int ret; 518 519 ret = regmap_read(arizona->regmap, ARIZONA_JACK_DETECT_ANALOGUE, &val); 520 if (ret) { 521 dev_err(arizona->dev, 522 "Failed to check jack det status: %d\n", ret); 523 return ret; 524 } else if (val & ARIZONA_JD1_ENA) { 525 return 1; 526 } else { 527 return 0; 528 } 529 } 530 531 static int arizona_runtime_resume(struct device *dev) 532 { 533 struct arizona *arizona = dev_get_drvdata(dev); 534 int ret; 535 536 dev_dbg(arizona->dev, "Leaving AoD mode\n"); 537 538 if (arizona->has_fully_powered_off) { 539 dev_dbg(arizona->dev, "Re-enabling core supplies\n"); 540 541 ret = regulator_bulk_enable(arizona->num_core_supplies, 542 arizona->core_supplies); 543 if (ret) { 544 dev_err(dev, "Failed to enable core supplies: %d\n", 545 ret); 546 return ret; 547 } 548 } 549 550 ret = regulator_enable(arizona->dcvdd); 551 if (ret != 0) { 552 dev_err(arizona->dev, "Failed to enable DCVDD: %d\n", ret); 553 if (arizona->has_fully_powered_off) 554 regulator_bulk_disable(arizona->num_core_supplies, 555 arizona->core_supplies); 556 return ret; 557 } 558 559 if (arizona->has_fully_powered_off) { 560 arizona_disable_reset(arizona); 561 enable_irq(arizona->irq); 562 arizona->has_fully_powered_off = false; 563 } 564 565 regcache_cache_only(arizona->regmap, false); 566 567 switch (arizona->type) { 568 case WM5102: 569 if (arizona->external_dcvdd) { 570 ret = arizona_connect_dcvdd(arizona); 571 if (ret != 0) 572 goto err; 573 } 574 575 ret = wm5102_patch(arizona); 576 if (ret != 0) { 577 dev_err(arizona->dev, "Failed to apply patch: %d\n", 578 ret); 579 goto err; 580 } 581 582 ret = wm5102_apply_hardware_patch(arizona); 583 if (ret) { 584 dev_err(arizona->dev, 585 "Failed to apply hardware patch: %d\n", 586 ret); 587 goto err; 588 } 589 break; 590 case WM5110: 591 case WM8280: 592 ret = arizona_wait_for_boot(arizona); 593 if (ret) 594 goto err; 595 596 if (arizona->external_dcvdd) { 597 ret = arizona_connect_dcvdd(arizona); 598 if (ret != 0) 599 goto err; 600 } else { 601 /* 602 * As this is only called for the internal regulator 603 * (where we know voltage ranges available) it is ok 604 * to request an exact range. 605 */ 606 ret = regulator_set_voltage(arizona->dcvdd, 607 1200000, 1200000); 608 if (ret < 0) { 609 dev_err(arizona->dev, 610 "Failed to set resume voltage: %d\n", 611 ret); 612 goto err; 613 } 614 } 615 616 ret = wm5110_apply_sleep_patch(arizona); 617 if (ret) { 618 dev_err(arizona->dev, 619 "Failed to re-apply sleep patch: %d\n", 620 ret); 621 goto err; 622 } 623 break; 624 case WM1831: 625 case CS47L24: 626 ret = arizona_wait_for_boot(arizona); 627 if (ret != 0) 628 goto err; 629 break; 630 default: 631 ret = arizona_wait_for_boot(arizona); 632 if (ret != 0) 633 goto err; 634 635 if (arizona->external_dcvdd) { 636 ret = arizona_connect_dcvdd(arizona); 637 if (ret != 0) 638 goto err; 639 } 640 break; 641 } 642 643 ret = regcache_sync(arizona->regmap); 644 if (ret != 0) { 645 dev_err(arizona->dev, "Failed to restore register cache\n"); 646 goto err; 647 } 648 649 return 0; 650 651 err: 652 regcache_cache_only(arizona->regmap, true); 653 regulator_disable(arizona->dcvdd); 654 return ret; 655 } 656 657 static int arizona_runtime_suspend(struct device *dev) 658 { 659 struct arizona *arizona = dev_get_drvdata(dev); 660 int jd_active = 0; 661 int ret; 662 663 dev_dbg(arizona->dev, "Entering AoD mode\n"); 664 665 switch (arizona->type) { 666 case WM5110: 667 case WM8280: 668 jd_active = arizona_is_jack_det_active(arizona); 669 if (jd_active < 0) 670 return jd_active; 671 672 if (arizona->external_dcvdd) { 673 ret = arizona_isolate_dcvdd(arizona); 674 if (ret != 0) 675 return ret; 676 } else { 677 /* 678 * As this is only called for the internal regulator 679 * (where we know voltage ranges available) it is ok 680 * to request an exact range. 681 */ 682 ret = regulator_set_voltage(arizona->dcvdd, 683 1175000, 1175000); 684 if (ret < 0) { 685 dev_err(arizona->dev, 686 "Failed to set suspend voltage: %d\n", 687 ret); 688 return ret; 689 } 690 } 691 break; 692 case WM5102: 693 jd_active = arizona_is_jack_det_active(arizona); 694 if (jd_active < 0) 695 return jd_active; 696 697 if (arizona->external_dcvdd) { 698 ret = arizona_isolate_dcvdd(arizona); 699 if (ret != 0) 700 return ret; 701 } 702 703 if (!jd_active) { 704 ret = regmap_write(arizona->regmap, 705 ARIZONA_WRITE_SEQUENCER_CTRL_3, 0x0); 706 if (ret) { 707 dev_err(arizona->dev, 708 "Failed to clear write sequencer: %d\n", 709 ret); 710 return ret; 711 } 712 } 713 break; 714 case WM1831: 715 case CS47L24: 716 break; 717 default: 718 jd_active = arizona_is_jack_det_active(arizona); 719 if (jd_active < 0) 720 return jd_active; 721 722 if (arizona->external_dcvdd) { 723 ret = arizona_isolate_dcvdd(arizona); 724 if (ret != 0) 725 return ret; 726 } 727 break; 728 } 729 730 regcache_cache_only(arizona->regmap, true); 731 regcache_mark_dirty(arizona->regmap); 732 regulator_disable(arizona->dcvdd); 733 734 /* Allow us to completely power down if no jack detection */ 735 if (!jd_active) { 736 dev_dbg(arizona->dev, "Fully powering off\n"); 737 738 arizona->has_fully_powered_off = true; 739 740 disable_irq_nosync(arizona->irq); 741 arizona_enable_reset(arizona); 742 regulator_bulk_disable(arizona->num_core_supplies, 743 arizona->core_supplies); 744 } 745 746 return 0; 747 } 748 #endif 749 750 #ifdef CONFIG_PM_SLEEP 751 static int arizona_suspend(struct device *dev) 752 { 753 struct arizona *arizona = dev_get_drvdata(dev); 754 755 dev_dbg(arizona->dev, "Suspend, disabling IRQ\n"); 756 disable_irq(arizona->irq); 757 758 return 0; 759 } 760 761 static int arizona_suspend_noirq(struct device *dev) 762 { 763 struct arizona *arizona = dev_get_drvdata(dev); 764 765 dev_dbg(arizona->dev, "Late suspend, reenabling IRQ\n"); 766 enable_irq(arizona->irq); 767 768 return 0; 769 } 770 771 static int arizona_resume_noirq(struct device *dev) 772 { 773 struct arizona *arizona = dev_get_drvdata(dev); 774 775 dev_dbg(arizona->dev, "Early resume, disabling IRQ\n"); 776 disable_irq(arizona->irq); 777 778 return 0; 779 } 780 781 static int arizona_resume(struct device *dev) 782 { 783 struct arizona *arizona = dev_get_drvdata(dev); 784 785 dev_dbg(arizona->dev, "Resume, reenabling IRQ\n"); 786 enable_irq(arizona->irq); 787 788 return 0; 789 } 790 #endif 791 792 const struct dev_pm_ops arizona_pm_ops = { 793 SET_RUNTIME_PM_OPS(arizona_runtime_suspend, 794 arizona_runtime_resume, 795 NULL) 796 SET_SYSTEM_SLEEP_PM_OPS(arizona_suspend, arizona_resume) 797 SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(arizona_suspend_noirq, 798 arizona_resume_noirq) 799 }; 800 EXPORT_SYMBOL_GPL(arizona_pm_ops); 801 802 #ifdef CONFIG_OF 803 unsigned long arizona_of_get_type(struct device *dev) 804 { 805 const struct of_device_id *id = of_match_device(arizona_of_match, dev); 806 807 if (id) 808 return (unsigned long)id->data; 809 else 810 return 0; 811 } 812 EXPORT_SYMBOL_GPL(arizona_of_get_type); 813 814 static int arizona_of_get_core_pdata(struct arizona *arizona) 815 { 816 struct arizona_pdata *pdata = &arizona->pdata; 817 int ret, i; 818 819 /* Handle old non-standard DT binding */ 820 pdata->reset = devm_gpiod_get_from_of_node(arizona->dev, 821 arizona->dev->of_node, 822 "wlf,reset", 0, 823 GPIOD_OUT_LOW, 824 "arizona /RESET"); 825 if (IS_ERR(pdata->reset)) { 826 ret = PTR_ERR(pdata->reset); 827 828 /* 829 * Reset missing will be caught when other binding is read 830 * but all other errors imply this binding is in use but has 831 * encountered a problem so should be handled. 832 */ 833 if (ret == -EPROBE_DEFER) 834 return ret; 835 else if (ret != -ENOENT && ret != -ENOSYS) 836 dev_err(arizona->dev, "Reset GPIO malformed: %d\n", 837 ret); 838 839 pdata->reset = NULL; 840 } 841 842 ret = of_property_read_u32_array(arizona->dev->of_node, 843 "wlf,gpio-defaults", 844 pdata->gpio_defaults, 845 ARRAY_SIZE(pdata->gpio_defaults)); 846 if (ret >= 0) { 847 /* 848 * All values are literal except out of range values 849 * which are chip default, translate into platform 850 * data which uses 0 as chip default and out of range 851 * as zero. 852 */ 853 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) { 854 if (pdata->gpio_defaults[i] > 0xffff) 855 pdata->gpio_defaults[i] = 0; 856 else if (pdata->gpio_defaults[i] == 0) 857 pdata->gpio_defaults[i] = 0x10000; 858 } 859 } else { 860 dev_err(arizona->dev, "Failed to parse GPIO defaults: %d\n", 861 ret); 862 } 863 864 return 0; 865 } 866 867 const struct of_device_id arizona_of_match[] = { 868 { .compatible = "wlf,wm5102", .data = (void *)WM5102 }, 869 { .compatible = "wlf,wm5110", .data = (void *)WM5110 }, 870 { .compatible = "wlf,wm8280", .data = (void *)WM8280 }, 871 { .compatible = "wlf,wm8997", .data = (void *)WM8997 }, 872 { .compatible = "wlf,wm8998", .data = (void *)WM8998 }, 873 { .compatible = "wlf,wm1814", .data = (void *)WM1814 }, 874 { .compatible = "wlf,wm1831", .data = (void *)WM1831 }, 875 { .compatible = "cirrus,cs47l24", .data = (void *)CS47L24 }, 876 {}, 877 }; 878 EXPORT_SYMBOL_GPL(arizona_of_match); 879 #else 880 static inline int arizona_of_get_core_pdata(struct arizona *arizona) 881 { 882 return 0; 883 } 884 #endif 885 886 static const struct mfd_cell early_devs[] = { 887 { .name = "arizona-ldo1" }, 888 }; 889 890 static const char * const wm5102_supplies[] = { 891 "MICVDD", 892 "DBVDD2", 893 "DBVDD3", 894 "CPVDD", 895 "SPKVDDL", 896 "SPKVDDR", 897 }; 898 899 static const struct mfd_cell wm5102_devs[] = { 900 { .name = "arizona-micsupp" }, 901 { .name = "arizona-gpio" }, 902 { 903 .name = "arizona-extcon", 904 .parent_supplies = wm5102_supplies, 905 .num_parent_supplies = 1, /* We only need MICVDD */ 906 }, 907 { .name = "arizona-haptics" }, 908 { .name = "arizona-pwm" }, 909 { 910 .name = "wm5102-codec", 911 .parent_supplies = wm5102_supplies, 912 .num_parent_supplies = ARRAY_SIZE(wm5102_supplies), 913 }, 914 }; 915 916 static const struct mfd_cell wm5110_devs[] = { 917 { .name = "arizona-micsupp" }, 918 { .name = "arizona-gpio" }, 919 { 920 .name = "arizona-extcon", 921 .parent_supplies = wm5102_supplies, 922 .num_parent_supplies = 1, /* We only need MICVDD */ 923 }, 924 { .name = "arizona-haptics" }, 925 { .name = "arizona-pwm" }, 926 { 927 .name = "wm5110-codec", 928 .parent_supplies = wm5102_supplies, 929 .num_parent_supplies = ARRAY_SIZE(wm5102_supplies), 930 }, 931 }; 932 933 static const char * const cs47l24_supplies[] = { 934 "MICVDD", 935 "CPVDD", 936 "SPKVDD", 937 }; 938 939 static const struct mfd_cell cs47l24_devs[] = { 940 { .name = "arizona-gpio" }, 941 { .name = "arizona-haptics" }, 942 { .name = "arizona-pwm" }, 943 { 944 .name = "cs47l24-codec", 945 .parent_supplies = cs47l24_supplies, 946 .num_parent_supplies = ARRAY_SIZE(cs47l24_supplies), 947 }, 948 }; 949 950 static const char * const wm8997_supplies[] = { 951 "MICVDD", 952 "DBVDD2", 953 "CPVDD", 954 "SPKVDD", 955 }; 956 957 static const struct mfd_cell wm8997_devs[] = { 958 { .name = "arizona-micsupp" }, 959 { .name = "arizona-gpio" }, 960 { 961 .name = "arizona-extcon", 962 .parent_supplies = wm8997_supplies, 963 .num_parent_supplies = 1, /* We only need MICVDD */ 964 }, 965 { .name = "arizona-haptics" }, 966 { .name = "arizona-pwm" }, 967 { 968 .name = "wm8997-codec", 969 .parent_supplies = wm8997_supplies, 970 .num_parent_supplies = ARRAY_SIZE(wm8997_supplies), 971 }, 972 }; 973 974 static const struct mfd_cell wm8998_devs[] = { 975 { .name = "arizona-micsupp" }, 976 { .name = "arizona-gpio" }, 977 { 978 .name = "arizona-extcon", 979 .parent_supplies = wm5102_supplies, 980 .num_parent_supplies = 1, /* We only need MICVDD */ 981 }, 982 { .name = "arizona-haptics" }, 983 { .name = "arizona-pwm" }, 984 { 985 .name = "wm8998-codec", 986 .parent_supplies = wm5102_supplies, 987 .num_parent_supplies = ARRAY_SIZE(wm5102_supplies), 988 }, 989 }; 990 991 int arizona_dev_init(struct arizona *arizona) 992 { 993 static const char * const mclk_name[] = { "mclk1", "mclk2" }; 994 struct device *dev = arizona->dev; 995 const char *type_name = NULL; 996 unsigned int reg, val; 997 int (*apply_patch)(struct arizona *) = NULL; 998 const struct mfd_cell *subdevs = NULL; 999 int n_subdevs, ret, i; 1000 1001 dev_set_drvdata(arizona->dev, arizona); 1002 mutex_init(&arizona->clk_lock); 1003 1004 if (dev_get_platdata(arizona->dev)) { 1005 memcpy(&arizona->pdata, dev_get_platdata(arizona->dev), 1006 sizeof(arizona->pdata)); 1007 } else { 1008 ret = arizona_of_get_core_pdata(arizona); 1009 if (ret < 0) 1010 return ret; 1011 } 1012 1013 BUILD_BUG_ON(ARRAY_SIZE(arizona->mclk) != ARRAY_SIZE(mclk_name)); 1014 for (i = 0; i < ARRAY_SIZE(arizona->mclk); i++) { 1015 arizona->mclk[i] = devm_clk_get(arizona->dev, mclk_name[i]); 1016 if (IS_ERR(arizona->mclk[i])) { 1017 dev_info(arizona->dev, "Failed to get %s: %ld\n", 1018 mclk_name[i], PTR_ERR(arizona->mclk[i])); 1019 arizona->mclk[i] = NULL; 1020 } 1021 } 1022 1023 regcache_cache_only(arizona->regmap, true); 1024 1025 switch (arizona->type) { 1026 case WM5102: 1027 case WM5110: 1028 case WM8280: 1029 case WM8997: 1030 case WM8998: 1031 case WM1814: 1032 case WM1831: 1033 case CS47L24: 1034 for (i = 0; i < ARRAY_SIZE(wm5102_core_supplies); i++) 1035 arizona->core_supplies[i].supply 1036 = wm5102_core_supplies[i]; 1037 arizona->num_core_supplies = ARRAY_SIZE(wm5102_core_supplies); 1038 break; 1039 default: 1040 dev_err(arizona->dev, "Unknown device type %d\n", 1041 arizona->type); 1042 return -ENODEV; 1043 } 1044 1045 /* Mark DCVDD as external, LDO1 driver will clear if internal */ 1046 arizona->external_dcvdd = true; 1047 1048 switch (arizona->type) { 1049 case WM1831: 1050 case CS47L24: 1051 break; /* No LDO1 regulator */ 1052 default: 1053 ret = mfd_add_devices(arizona->dev, -1, early_devs, 1054 ARRAY_SIZE(early_devs), NULL, 0, NULL); 1055 if (ret != 0) { 1056 dev_err(dev, "Failed to add early children: %d\n", ret); 1057 return ret; 1058 } 1059 break; 1060 } 1061 1062 ret = devm_regulator_bulk_get(dev, arizona->num_core_supplies, 1063 arizona->core_supplies); 1064 if (ret != 0) { 1065 dev_err(dev, "Failed to request core supplies: %d\n", 1066 ret); 1067 goto err_early; 1068 } 1069 1070 /** 1071 * Don't use devres here because the only device we have to get 1072 * against is the MFD device and DCVDD will likely be supplied by 1073 * one of its children. Meaning that the regulator will be 1074 * destroyed by the time devres calls regulator put. 1075 */ 1076 arizona->dcvdd = regulator_get(arizona->dev, "DCVDD"); 1077 if (IS_ERR(arizona->dcvdd)) { 1078 ret = PTR_ERR(arizona->dcvdd); 1079 dev_err(dev, "Failed to request DCVDD: %d\n", ret); 1080 goto err_early; 1081 } 1082 1083 if (!arizona->pdata.reset) { 1084 /* Start out with /RESET low to put the chip into reset */ 1085 arizona->pdata.reset = devm_gpiod_get(arizona->dev, "reset", 1086 GPIOD_OUT_LOW); 1087 if (IS_ERR(arizona->pdata.reset)) { 1088 ret = PTR_ERR(arizona->pdata.reset); 1089 if (ret == -EPROBE_DEFER) 1090 goto err_dcvdd; 1091 1092 dev_err(arizona->dev, 1093 "Reset GPIO missing/malformed: %d\n", ret); 1094 1095 arizona->pdata.reset = NULL; 1096 } 1097 } 1098 1099 ret = regulator_bulk_enable(arizona->num_core_supplies, 1100 arizona->core_supplies); 1101 if (ret != 0) { 1102 dev_err(dev, "Failed to enable core supplies: %d\n", 1103 ret); 1104 goto err_dcvdd; 1105 } 1106 1107 ret = regulator_enable(arizona->dcvdd); 1108 if (ret != 0) { 1109 dev_err(dev, "Failed to enable DCVDD: %d\n", ret); 1110 goto err_enable; 1111 } 1112 1113 arizona_disable_reset(arizona); 1114 1115 regcache_cache_only(arizona->regmap, false); 1116 1117 /* Verify that this is a chip we know about */ 1118 ret = regmap_read(arizona->regmap, ARIZONA_SOFTWARE_RESET, ®); 1119 if (ret != 0) { 1120 dev_err(dev, "Failed to read ID register: %d\n", ret); 1121 goto err_reset; 1122 } 1123 1124 switch (reg) { 1125 case 0x5102: 1126 case 0x5110: 1127 case 0x6349: 1128 case 0x6363: 1129 case 0x8997: 1130 break; 1131 default: 1132 dev_err(arizona->dev, "Unknown device ID: %x\n", reg); 1133 ret = -ENODEV; 1134 goto err_reset; 1135 } 1136 1137 /* If we have a /RESET GPIO we'll already be reset */ 1138 if (!arizona->pdata.reset) { 1139 ret = regmap_write(arizona->regmap, ARIZONA_SOFTWARE_RESET, 0); 1140 if (ret != 0) { 1141 dev_err(dev, "Failed to reset device: %d\n", ret); 1142 goto err_reset; 1143 } 1144 1145 usleep_range(1000, 5000); 1146 } 1147 1148 /* Ensure device startup is complete */ 1149 switch (arizona->type) { 1150 case WM5102: 1151 ret = regmap_read(arizona->regmap, 1152 ARIZONA_WRITE_SEQUENCER_CTRL_3, &val); 1153 if (ret) { 1154 dev_err(dev, 1155 "Failed to check write sequencer state: %d\n", 1156 ret); 1157 } else if (val & 0x01) { 1158 ret = wm5102_clear_write_sequencer(arizona); 1159 if (ret) 1160 return ret; 1161 } 1162 break; 1163 default: 1164 break; 1165 } 1166 1167 ret = arizona_wait_for_boot(arizona); 1168 if (ret) { 1169 dev_err(arizona->dev, "Device failed initial boot: %d\n", ret); 1170 goto err_reset; 1171 } 1172 1173 /* Read the device ID information & do device specific stuff */ 1174 ret = regmap_read(arizona->regmap, ARIZONA_SOFTWARE_RESET, ®); 1175 if (ret != 0) { 1176 dev_err(dev, "Failed to read ID register: %d\n", ret); 1177 goto err_reset; 1178 } 1179 1180 ret = regmap_read(arizona->regmap, ARIZONA_DEVICE_REVISION, 1181 &arizona->rev); 1182 if (ret != 0) { 1183 dev_err(dev, "Failed to read revision register: %d\n", ret); 1184 goto err_reset; 1185 } 1186 arizona->rev &= ARIZONA_DEVICE_REVISION_MASK; 1187 1188 switch (reg) { 1189 case 0x5102: 1190 if (IS_ENABLED(CONFIG_MFD_WM5102)) { 1191 type_name = "WM5102"; 1192 if (arizona->type != WM5102) { 1193 dev_warn(arizona->dev, 1194 "WM5102 registered as %d\n", 1195 arizona->type); 1196 arizona->type = WM5102; 1197 } 1198 1199 apply_patch = wm5102_patch; 1200 arizona->rev &= 0x7; 1201 subdevs = wm5102_devs; 1202 n_subdevs = ARRAY_SIZE(wm5102_devs); 1203 } 1204 break; 1205 case 0x5110: 1206 if (IS_ENABLED(CONFIG_MFD_WM5110)) { 1207 switch (arizona->type) { 1208 case WM5110: 1209 type_name = "WM5110"; 1210 break; 1211 case WM8280: 1212 type_name = "WM8280"; 1213 break; 1214 default: 1215 type_name = "WM5110"; 1216 dev_warn(arizona->dev, 1217 "WM5110 registered as %d\n", 1218 arizona->type); 1219 arizona->type = WM5110; 1220 break; 1221 } 1222 1223 apply_patch = wm5110_patch; 1224 subdevs = wm5110_devs; 1225 n_subdevs = ARRAY_SIZE(wm5110_devs); 1226 } 1227 break; 1228 case 0x6363: 1229 if (IS_ENABLED(CONFIG_MFD_CS47L24)) { 1230 switch (arizona->type) { 1231 case CS47L24: 1232 type_name = "CS47L24"; 1233 break; 1234 1235 case WM1831: 1236 type_name = "WM1831"; 1237 break; 1238 1239 default: 1240 dev_warn(arizona->dev, 1241 "CS47L24 registered as %d\n", 1242 arizona->type); 1243 arizona->type = CS47L24; 1244 break; 1245 } 1246 1247 apply_patch = cs47l24_patch; 1248 subdevs = cs47l24_devs; 1249 n_subdevs = ARRAY_SIZE(cs47l24_devs); 1250 } 1251 break; 1252 case 0x8997: 1253 if (IS_ENABLED(CONFIG_MFD_WM8997)) { 1254 type_name = "WM8997"; 1255 if (arizona->type != WM8997) { 1256 dev_warn(arizona->dev, 1257 "WM8997 registered as %d\n", 1258 arizona->type); 1259 arizona->type = WM8997; 1260 } 1261 1262 apply_patch = wm8997_patch; 1263 subdevs = wm8997_devs; 1264 n_subdevs = ARRAY_SIZE(wm8997_devs); 1265 } 1266 break; 1267 case 0x6349: 1268 if (IS_ENABLED(CONFIG_MFD_WM8998)) { 1269 switch (arizona->type) { 1270 case WM8998: 1271 type_name = "WM8998"; 1272 break; 1273 1274 case WM1814: 1275 type_name = "WM1814"; 1276 break; 1277 1278 default: 1279 type_name = "WM8998"; 1280 dev_warn(arizona->dev, 1281 "WM8998 registered as %d\n", 1282 arizona->type); 1283 arizona->type = WM8998; 1284 } 1285 1286 apply_patch = wm8998_patch; 1287 subdevs = wm8998_devs; 1288 n_subdevs = ARRAY_SIZE(wm8998_devs); 1289 } 1290 break; 1291 default: 1292 dev_err(arizona->dev, "Unknown device ID %x\n", reg); 1293 ret = -ENODEV; 1294 goto err_reset; 1295 } 1296 1297 if (!subdevs) { 1298 dev_err(arizona->dev, 1299 "No kernel support for device ID %x\n", reg); 1300 ret = -ENODEV; 1301 goto err_reset; 1302 } 1303 1304 dev_info(dev, "%s revision %c\n", type_name, arizona->rev + 'A'); 1305 1306 if (apply_patch) { 1307 ret = apply_patch(arizona); 1308 if (ret != 0) { 1309 dev_err(arizona->dev, "Failed to apply patch: %d\n", 1310 ret); 1311 goto err_reset; 1312 } 1313 1314 switch (arizona->type) { 1315 case WM5102: 1316 ret = wm5102_apply_hardware_patch(arizona); 1317 if (ret) { 1318 dev_err(arizona->dev, 1319 "Failed to apply hardware patch: %d\n", 1320 ret); 1321 goto err_reset; 1322 } 1323 break; 1324 case WM5110: 1325 case WM8280: 1326 ret = wm5110_apply_sleep_patch(arizona); 1327 if (ret) { 1328 dev_err(arizona->dev, 1329 "Failed to apply sleep patch: %d\n", 1330 ret); 1331 goto err_reset; 1332 } 1333 break; 1334 default: 1335 break; 1336 } 1337 } 1338 1339 for (i = 0; i < ARRAY_SIZE(arizona->pdata.gpio_defaults); i++) { 1340 if (!arizona->pdata.gpio_defaults[i]) 1341 continue; 1342 1343 regmap_write(arizona->regmap, ARIZONA_GPIO1_CTRL + i, 1344 arizona->pdata.gpio_defaults[i]); 1345 } 1346 1347 /* Chip default */ 1348 if (!arizona->pdata.clk32k_src) 1349 arizona->pdata.clk32k_src = ARIZONA_32KZ_MCLK2; 1350 1351 switch (arizona->pdata.clk32k_src) { 1352 case ARIZONA_32KZ_MCLK1: 1353 case ARIZONA_32KZ_MCLK2: 1354 regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1, 1355 ARIZONA_CLK_32K_SRC_MASK, 1356 arizona->pdata.clk32k_src - 1); 1357 arizona_clk32k_enable(arizona); 1358 break; 1359 case ARIZONA_32KZ_NONE: 1360 regmap_update_bits(arizona->regmap, ARIZONA_CLOCK_32K_1, 1361 ARIZONA_CLK_32K_SRC_MASK, 2); 1362 break; 1363 default: 1364 dev_err(arizona->dev, "Invalid 32kHz clock source: %d\n", 1365 arizona->pdata.clk32k_src); 1366 ret = -EINVAL; 1367 goto err_reset; 1368 } 1369 1370 for (i = 0; i < ARIZONA_MAX_MICBIAS; i++) { 1371 if (!arizona->pdata.micbias[i].mV && 1372 !arizona->pdata.micbias[i].bypass) 1373 continue; 1374 1375 /* Apply default for bypass mode */ 1376 if (!arizona->pdata.micbias[i].mV) 1377 arizona->pdata.micbias[i].mV = 2800; 1378 1379 val = (arizona->pdata.micbias[i].mV - 1500) / 100; 1380 1381 val <<= ARIZONA_MICB1_LVL_SHIFT; 1382 1383 if (arizona->pdata.micbias[i].ext_cap) 1384 val |= ARIZONA_MICB1_EXT_CAP; 1385 1386 if (arizona->pdata.micbias[i].discharge) 1387 val |= ARIZONA_MICB1_DISCH; 1388 1389 if (arizona->pdata.micbias[i].soft_start) 1390 val |= ARIZONA_MICB1_RATE; 1391 1392 if (arizona->pdata.micbias[i].bypass) 1393 val |= ARIZONA_MICB1_BYPASS; 1394 1395 regmap_update_bits(arizona->regmap, 1396 ARIZONA_MIC_BIAS_CTRL_1 + i, 1397 ARIZONA_MICB1_LVL_MASK | 1398 ARIZONA_MICB1_EXT_CAP | 1399 ARIZONA_MICB1_DISCH | 1400 ARIZONA_MICB1_BYPASS | 1401 ARIZONA_MICB1_RATE, val); 1402 } 1403 1404 pm_runtime_set_active(arizona->dev); 1405 pm_runtime_enable(arizona->dev); 1406 1407 /* Set up for interrupts */ 1408 ret = arizona_irq_init(arizona); 1409 if (ret != 0) 1410 goto err_pm; 1411 1412 pm_runtime_set_autosuspend_delay(arizona->dev, 100); 1413 pm_runtime_use_autosuspend(arizona->dev); 1414 1415 arizona_request_irq(arizona, ARIZONA_IRQ_CLKGEN_ERR, "CLKGEN error", 1416 arizona_clkgen_err, arizona); 1417 arizona_request_irq(arizona, ARIZONA_IRQ_OVERCLOCKED, "Overclocked", 1418 arizona_overclocked, arizona); 1419 arizona_request_irq(arizona, ARIZONA_IRQ_UNDERCLOCKED, "Underclocked", 1420 arizona_underclocked, arizona); 1421 1422 ret = mfd_add_devices(arizona->dev, PLATFORM_DEVID_NONE, 1423 subdevs, n_subdevs, NULL, 0, NULL); 1424 1425 if (ret) { 1426 dev_err(arizona->dev, "Failed to add subdevices: %d\n", ret); 1427 goto err_irq; 1428 } 1429 1430 return 0; 1431 1432 err_irq: 1433 arizona_irq_exit(arizona); 1434 err_pm: 1435 pm_runtime_disable(arizona->dev); 1436 err_reset: 1437 arizona_enable_reset(arizona); 1438 regulator_disable(arizona->dcvdd); 1439 err_enable: 1440 regulator_bulk_disable(arizona->num_core_supplies, 1441 arizona->core_supplies); 1442 err_dcvdd: 1443 regulator_put(arizona->dcvdd); 1444 err_early: 1445 mfd_remove_devices(dev); 1446 return ret; 1447 } 1448 EXPORT_SYMBOL_GPL(arizona_dev_init); 1449 1450 int arizona_dev_exit(struct arizona *arizona) 1451 { 1452 disable_irq(arizona->irq); 1453 pm_runtime_disable(arizona->dev); 1454 1455 regulator_disable(arizona->dcvdd); 1456 regulator_put(arizona->dcvdd); 1457 1458 mfd_remove_devices(arizona->dev); 1459 arizona_free_irq(arizona, ARIZONA_IRQ_UNDERCLOCKED, arizona); 1460 arizona_free_irq(arizona, ARIZONA_IRQ_OVERCLOCKED, arizona); 1461 arizona_free_irq(arizona, ARIZONA_IRQ_CLKGEN_ERR, arizona); 1462 arizona_irq_exit(arizona); 1463 arizona_enable_reset(arizona); 1464 1465 regulator_bulk_disable(arizona->num_core_supplies, 1466 arizona->core_supplies); 1467 return 0; 1468 } 1469 EXPORT_SYMBOL_GPL(arizona_dev_exit); 1470