1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * wm8994-core.c -- Device access for Wolfson WM8994 4 * 5 * Copyright 2009 Wolfson Microelectronics PLC. 6 * 7 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com> 8 */ 9 10 #include <linux/kernel.h> 11 #include <linux/module.h> 12 #include <linux/slab.h> 13 #include <linux/i2c.h> 14 #include <linux/err.h> 15 #include <linux/delay.h> 16 #include <linux/mfd/core.h> 17 #include <linux/of.h> 18 #include <linux/of_device.h> 19 #include <linux/pm_runtime.h> 20 #include <linux/regmap.h> 21 #include <linux/regulator/consumer.h> 22 #include <linux/regulator/machine.h> 23 24 #include <linux/mfd/wm8994/core.h> 25 #include <linux/mfd/wm8994/pdata.h> 26 #include <linux/mfd/wm8994/registers.h> 27 28 #include "wm8994.h" 29 30 static const struct mfd_cell wm8994_regulator_devs[] = { 31 { 32 .name = "wm8994-ldo", 33 .id = 0, 34 .pm_runtime_no_callbacks = true, 35 }, 36 { 37 .name = "wm8994-ldo", 38 .id = 1, 39 .pm_runtime_no_callbacks = true, 40 }, 41 }; 42 43 static struct resource wm8994_codec_resources[] = { 44 { 45 .start = WM8994_IRQ_TEMP_SHUT, 46 .end = WM8994_IRQ_TEMP_WARN, 47 .flags = IORESOURCE_IRQ, 48 }, 49 }; 50 51 static struct resource wm8994_gpio_resources[] = { 52 { 53 .start = WM8994_IRQ_GPIO(1), 54 .end = WM8994_IRQ_GPIO(11), 55 .flags = IORESOURCE_IRQ, 56 }, 57 }; 58 59 static const struct mfd_cell wm8994_devs[] = { 60 { 61 .name = "wm8994-codec", 62 .num_resources = ARRAY_SIZE(wm8994_codec_resources), 63 .resources = wm8994_codec_resources, 64 }, 65 66 { 67 .name = "wm8994-gpio", 68 .num_resources = ARRAY_SIZE(wm8994_gpio_resources), 69 .resources = wm8994_gpio_resources, 70 .pm_runtime_no_callbacks = true, 71 }, 72 }; 73 74 /* 75 * Supplies for the main bulk of CODEC; the LDO supplies are ignored 76 * and should be handled via the standard regulator API supply 77 * management. 78 */ 79 static const char *wm1811_main_supplies[] = { 80 "DBVDD1", 81 "DBVDD2", 82 "DBVDD3", 83 "DCVDD", 84 "AVDD1", 85 "AVDD2", 86 "CPVDD", 87 "SPKVDD1", 88 "SPKVDD2", 89 }; 90 91 static const char *wm8994_main_supplies[] = { 92 "DBVDD", 93 "DCVDD", 94 "AVDD1", 95 "AVDD2", 96 "CPVDD", 97 "SPKVDD1", 98 "SPKVDD2", 99 }; 100 101 static const char *wm8958_main_supplies[] = { 102 "DBVDD1", 103 "DBVDD2", 104 "DBVDD3", 105 "DCVDD", 106 "AVDD1", 107 "AVDD2", 108 "CPVDD", 109 "SPKVDD1", 110 "SPKVDD2", 111 }; 112 113 #ifdef CONFIG_PM 114 static int wm8994_suspend(struct device *dev) 115 { 116 struct wm8994 *wm8994 = dev_get_drvdata(dev); 117 int ret; 118 119 /* Don't actually go through with the suspend if the CODEC is 120 * still active for accessory detect. */ 121 switch (wm8994->type) { 122 case WM8958: 123 case WM1811: 124 ret = wm8994_reg_read(wm8994, WM8958_MIC_DETECT_1); 125 if (ret < 0) { 126 dev_err(dev, "Failed to read power status: %d\n", ret); 127 } else if (ret & WM8958_MICD_ENA) { 128 dev_dbg(dev, "CODEC still active, ignoring suspend\n"); 129 return 0; 130 } 131 break; 132 default: 133 break; 134 } 135 136 /* Disable LDO pulldowns while the device is suspended if we 137 * don't know that something will be driving them. */ 138 if (!wm8994->ldo_ena_always_driven) 139 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2, 140 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD, 141 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD); 142 143 /* Explicitly put the device into reset in case regulators 144 * don't get disabled in order to ensure consistent restart. 145 */ 146 wm8994_reg_write(wm8994, WM8994_SOFTWARE_RESET, 147 wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET)); 148 149 regcache_mark_dirty(wm8994->regmap); 150 151 /* Restore GPIO registers to prevent problems with mismatched 152 * pin configurations. 153 */ 154 ret = regcache_sync_region(wm8994->regmap, WM8994_GPIO_1, 155 WM8994_GPIO_11); 156 if (ret != 0) 157 dev_err(dev, "Failed to restore GPIO registers: %d\n", ret); 158 159 /* In case one of the GPIOs is used as a wake input. */ 160 ret = regcache_sync_region(wm8994->regmap, 161 WM8994_INTERRUPT_STATUS_1_MASK, 162 WM8994_INTERRUPT_STATUS_1_MASK); 163 if (ret != 0) 164 dev_err(dev, "Failed to restore interrupt mask: %d\n", ret); 165 166 regcache_cache_only(wm8994->regmap, true); 167 wm8994->suspended = true; 168 169 ret = regulator_bulk_disable(wm8994->num_supplies, 170 wm8994->supplies); 171 if (ret != 0) { 172 dev_err(dev, "Failed to disable supplies: %d\n", ret); 173 return ret; 174 } 175 176 return 0; 177 } 178 179 static int wm8994_resume(struct device *dev) 180 { 181 struct wm8994 *wm8994 = dev_get_drvdata(dev); 182 int ret; 183 184 /* We may have lied to the PM core about suspending */ 185 if (!wm8994->suspended) 186 return 0; 187 188 ret = regulator_bulk_enable(wm8994->num_supplies, 189 wm8994->supplies); 190 if (ret != 0) { 191 dev_err(dev, "Failed to enable supplies: %d\n", ret); 192 return ret; 193 } 194 195 regcache_cache_only(wm8994->regmap, false); 196 ret = regcache_sync(wm8994->regmap); 197 if (ret != 0) { 198 dev_err(dev, "Failed to restore register map: %d\n", ret); 199 goto err_enable; 200 } 201 202 /* Disable LDO pulldowns while the device is active */ 203 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2, 204 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD, 205 0); 206 207 wm8994->suspended = false; 208 209 return 0; 210 211 err_enable: 212 regulator_bulk_disable(wm8994->num_supplies, wm8994->supplies); 213 214 return ret; 215 } 216 #endif 217 218 #ifdef CONFIG_REGULATOR 219 static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo) 220 { 221 struct wm8994_ldo_pdata *ldo_pdata; 222 223 if (!pdata) 224 return 0; 225 226 ldo_pdata = &pdata->ldo[ldo]; 227 228 if (!ldo_pdata->init_data) 229 return 0; 230 231 return ldo_pdata->init_data->num_consumer_supplies != 0; 232 } 233 #else 234 static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo) 235 { 236 return 0; 237 } 238 #endif 239 240 static const struct reg_sequence wm8994_revc_patch[] = { 241 { 0x102, 0x3 }, 242 { 0x56, 0x3 }, 243 { 0x817, 0x0 }, 244 { 0x102, 0x0 }, 245 }; 246 247 static const struct reg_sequence wm8958_reva_patch[] = { 248 { 0x102, 0x3 }, 249 { 0xcb, 0x81 }, 250 { 0x817, 0x0 }, 251 { 0x102, 0x0 }, 252 }; 253 254 static const struct reg_sequence wm1811_reva_patch[] = { 255 { 0x102, 0x3 }, 256 { 0x56, 0xc07 }, 257 { 0x5d, 0x7e }, 258 { 0x5e, 0x0 }, 259 { 0x102, 0x0 }, 260 }; 261 262 #ifdef CONFIG_OF 263 static int wm8994_set_pdata_from_of(struct wm8994 *wm8994) 264 { 265 struct device_node *np = wm8994->dev->of_node; 266 struct wm8994_pdata *pdata = &wm8994->pdata; 267 int i; 268 269 if (!np) 270 return 0; 271 272 if (of_property_read_u32_array(np, "wlf,gpio-cfg", pdata->gpio_defaults, 273 ARRAY_SIZE(pdata->gpio_defaults)) >= 0) { 274 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) { 275 if (wm8994->pdata.gpio_defaults[i] == 0) 276 pdata->gpio_defaults[i] 277 = WM8994_CONFIGURE_GPIO; 278 } 279 } 280 281 of_property_read_u32_array(np, "wlf,micbias-cfg", pdata->micbias, 282 ARRAY_SIZE(pdata->micbias)); 283 284 pdata->lineout1_diff = true; 285 pdata->lineout2_diff = true; 286 if (of_find_property(np, "wlf,lineout1-se", NULL)) 287 pdata->lineout1_diff = false; 288 if (of_find_property(np, "wlf,lineout2-se", NULL)) 289 pdata->lineout2_diff = false; 290 291 if (of_find_property(np, "wlf,lineout1-feedback", NULL)) 292 pdata->lineout1fb = true; 293 if (of_find_property(np, "wlf,lineout2-feedback", NULL)) 294 pdata->lineout2fb = true; 295 296 if (of_find_property(np, "wlf,ldoena-always-driven", NULL)) 297 pdata->lineout2fb = true; 298 299 pdata->spkmode_pu = of_property_read_bool(np, "wlf,spkmode-pu"); 300 301 pdata->csnaddr_pd = of_property_read_bool(np, "wlf,csnaddr-pd"); 302 303 return 0; 304 } 305 #else 306 static int wm8994_set_pdata_from_of(struct wm8994 *wm8994) 307 { 308 return 0; 309 } 310 #endif 311 312 /* 313 * Instantiate the generic non-control parts of the device. 314 */ 315 static int wm8994_device_init(struct wm8994 *wm8994, int irq) 316 { 317 struct wm8994_pdata *pdata; 318 struct regmap_config *regmap_config; 319 const struct reg_sequence *regmap_patch = NULL; 320 const char *devname; 321 int ret, i, patch_regs = 0; 322 int pulls = 0; 323 324 if (dev_get_platdata(wm8994->dev)) { 325 pdata = dev_get_platdata(wm8994->dev); 326 wm8994->pdata = *pdata; 327 } 328 pdata = &wm8994->pdata; 329 330 ret = wm8994_set_pdata_from_of(wm8994); 331 if (ret != 0) 332 return ret; 333 334 dev_set_drvdata(wm8994->dev, wm8994); 335 336 /* Add the on-chip regulators first for bootstrapping */ 337 ret = mfd_add_devices(wm8994->dev, 0, 338 wm8994_regulator_devs, 339 ARRAY_SIZE(wm8994_regulator_devs), 340 NULL, 0, NULL); 341 if (ret != 0) { 342 dev_err(wm8994->dev, "Failed to add children: %d\n", ret); 343 goto err; 344 } 345 346 switch (wm8994->type) { 347 case WM1811: 348 wm8994->num_supplies = ARRAY_SIZE(wm1811_main_supplies); 349 break; 350 case WM8994: 351 wm8994->num_supplies = ARRAY_SIZE(wm8994_main_supplies); 352 break; 353 case WM8958: 354 wm8994->num_supplies = ARRAY_SIZE(wm8958_main_supplies); 355 break; 356 default: 357 BUG(); 358 goto err; 359 } 360 361 wm8994->supplies = devm_kcalloc(wm8994->dev, 362 wm8994->num_supplies, 363 sizeof(struct regulator_bulk_data), 364 GFP_KERNEL); 365 if (!wm8994->supplies) { 366 ret = -ENOMEM; 367 goto err; 368 } 369 370 switch (wm8994->type) { 371 case WM1811: 372 for (i = 0; i < ARRAY_SIZE(wm1811_main_supplies); i++) 373 wm8994->supplies[i].supply = wm1811_main_supplies[i]; 374 break; 375 case WM8994: 376 for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++) 377 wm8994->supplies[i].supply = wm8994_main_supplies[i]; 378 break; 379 case WM8958: 380 for (i = 0; i < ARRAY_SIZE(wm8958_main_supplies); i++) 381 wm8994->supplies[i].supply = wm8958_main_supplies[i]; 382 break; 383 default: 384 BUG(); 385 goto err; 386 } 387 388 /* 389 * Can't use devres helper here as some of the supplies are provided by 390 * wm8994->dev's children (regulators) and those regulators are 391 * unregistered by the devres core before the supplies are freed. 392 */ 393 ret = regulator_bulk_get(wm8994->dev, wm8994->num_supplies, 394 wm8994->supplies); 395 if (ret != 0) { 396 if (ret != -EPROBE_DEFER) 397 dev_err(wm8994->dev, "Failed to get supplies: %d\n", 398 ret); 399 goto err; 400 } 401 402 ret = regulator_bulk_enable(wm8994->num_supplies, wm8994->supplies); 403 if (ret != 0) { 404 dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret); 405 goto err_regulator_free; 406 } 407 408 ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET); 409 if (ret < 0) { 410 dev_err(wm8994->dev, "Failed to read ID register\n"); 411 goto err_enable; 412 } 413 switch (ret) { 414 case 0x1811: 415 devname = "WM1811"; 416 if (wm8994->type != WM1811) 417 dev_warn(wm8994->dev, "Device registered as type %d\n", 418 wm8994->type); 419 wm8994->type = WM1811; 420 break; 421 case 0x8994: 422 devname = "WM8994"; 423 if (wm8994->type != WM8994) 424 dev_warn(wm8994->dev, "Device registered as type %d\n", 425 wm8994->type); 426 wm8994->type = WM8994; 427 break; 428 case 0x8958: 429 devname = "WM8958"; 430 if (wm8994->type != WM8958) 431 dev_warn(wm8994->dev, "Device registered as type %d\n", 432 wm8994->type); 433 wm8994->type = WM8958; 434 break; 435 default: 436 dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n", 437 ret); 438 ret = -EINVAL; 439 goto err_enable; 440 } 441 442 ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION); 443 if (ret < 0) { 444 dev_err(wm8994->dev, "Failed to read revision register: %d\n", 445 ret); 446 goto err_enable; 447 } 448 wm8994->revision = ret & WM8994_CHIP_REV_MASK; 449 wm8994->cust_id = (ret & WM8994_CUST_ID_MASK) >> WM8994_CUST_ID_SHIFT; 450 451 switch (wm8994->type) { 452 case WM8994: 453 switch (wm8994->revision) { 454 case 0: 455 case 1: 456 dev_warn(wm8994->dev, 457 "revision %c not fully supported\n", 458 'A' + wm8994->revision); 459 break; 460 case 2: 461 case 3: 462 default: 463 regmap_patch = wm8994_revc_patch; 464 patch_regs = ARRAY_SIZE(wm8994_revc_patch); 465 break; 466 } 467 break; 468 469 case WM8958: 470 switch (wm8994->revision) { 471 case 0: 472 regmap_patch = wm8958_reva_patch; 473 patch_regs = ARRAY_SIZE(wm8958_reva_patch); 474 break; 475 default: 476 break; 477 } 478 break; 479 480 case WM1811: 481 /* Revision C did not change the relevant layer */ 482 if (wm8994->revision > 1) 483 wm8994->revision++; 484 485 regmap_patch = wm1811_reva_patch; 486 patch_regs = ARRAY_SIZE(wm1811_reva_patch); 487 break; 488 489 default: 490 break; 491 } 492 493 dev_info(wm8994->dev, "%s revision %c CUST_ID %02x\n", devname, 494 'A' + wm8994->revision, wm8994->cust_id); 495 496 switch (wm8994->type) { 497 case WM1811: 498 regmap_config = &wm1811_regmap_config; 499 break; 500 case WM8994: 501 regmap_config = &wm8994_regmap_config; 502 break; 503 case WM8958: 504 regmap_config = &wm8958_regmap_config; 505 break; 506 default: 507 dev_err(wm8994->dev, "Unknown device type %d\n", wm8994->type); 508 ret = -EINVAL; 509 goto err_enable; 510 } 511 512 ret = regmap_reinit_cache(wm8994->regmap, regmap_config); 513 if (ret != 0) { 514 dev_err(wm8994->dev, "Failed to reinit register cache: %d\n", 515 ret); 516 goto err_enable; 517 } 518 519 /* Explicitly put the device into reset in case regulators 520 * don't get disabled in order to ensure we know the device 521 * state. 522 */ 523 ret = wm8994_reg_write(wm8994, WM8994_SOFTWARE_RESET, 524 wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET)); 525 if (ret != 0) { 526 dev_err(wm8994->dev, "Failed to reset device: %d\n", ret); 527 goto err_enable; 528 } 529 530 if (regmap_patch) { 531 ret = regmap_register_patch(wm8994->regmap, regmap_patch, 532 patch_regs); 533 if (ret != 0) { 534 dev_err(wm8994->dev, "Failed to register patch: %d\n", 535 ret); 536 goto err_enable; 537 } 538 } 539 540 wm8994->irq_base = pdata->irq_base; 541 wm8994->gpio_base = pdata->gpio_base; 542 543 /* GPIO configuration is only applied if it's non-zero */ 544 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) { 545 if (pdata->gpio_defaults[i]) { 546 wm8994_set_bits(wm8994, WM8994_GPIO_1 + i, 547 0xffff, pdata->gpio_defaults[i]); 548 } 549 } 550 551 wm8994->ldo_ena_always_driven = pdata->ldo_ena_always_driven; 552 553 if (pdata->spkmode_pu) 554 pulls |= WM8994_SPKMODE_PU; 555 if (pdata->csnaddr_pd) 556 pulls |= WM8994_CSNADDR_PD; 557 558 /* Disable unneeded pulls */ 559 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2, 560 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD | 561 WM8994_SPKMODE_PU | WM8994_CSNADDR_PD, 562 pulls); 563 564 /* In some system designs where the regulators are not in use, 565 * we can achieve a small reduction in leakage currents by 566 * floating LDO outputs. This bit makes no difference if the 567 * LDOs are enabled, it only affects cases where the LDOs were 568 * in operation and are then disabled. 569 */ 570 for (i = 0; i < WM8994_NUM_LDO_REGS; i++) { 571 if (wm8994_ldo_in_use(pdata, i)) 572 wm8994_set_bits(wm8994, WM8994_LDO_1 + i, 573 WM8994_LDO1_DISCH, WM8994_LDO1_DISCH); 574 else 575 wm8994_set_bits(wm8994, WM8994_LDO_1 + i, 576 WM8994_LDO1_DISCH, 0); 577 } 578 579 wm8994_irq_init(wm8994); 580 581 ret = mfd_add_devices(wm8994->dev, -1, 582 wm8994_devs, ARRAY_SIZE(wm8994_devs), 583 NULL, 0, NULL); 584 if (ret != 0) { 585 dev_err(wm8994->dev, "Failed to add children: %d\n", ret); 586 goto err_irq; 587 } 588 589 pm_runtime_set_active(wm8994->dev); 590 pm_runtime_enable(wm8994->dev); 591 pm_runtime_idle(wm8994->dev); 592 593 return 0; 594 595 err_irq: 596 wm8994_irq_exit(wm8994); 597 err_enable: 598 regulator_bulk_disable(wm8994->num_supplies, 599 wm8994->supplies); 600 err_regulator_free: 601 regulator_bulk_free(wm8994->num_supplies, wm8994->supplies); 602 err: 603 mfd_remove_devices(wm8994->dev); 604 return ret; 605 } 606 607 static void wm8994_device_exit(struct wm8994 *wm8994) 608 { 609 pm_runtime_get_sync(wm8994->dev); 610 pm_runtime_disable(wm8994->dev); 611 pm_runtime_put_noidle(wm8994->dev); 612 wm8994_irq_exit(wm8994); 613 regulator_bulk_disable(wm8994->num_supplies, wm8994->supplies); 614 regulator_bulk_free(wm8994->num_supplies, wm8994->supplies); 615 mfd_remove_devices(wm8994->dev); 616 } 617 618 static const struct of_device_id wm8994_of_match[] = { 619 { .compatible = "wlf,wm1811", .data = (void *)WM1811 }, 620 { .compatible = "wlf,wm8994", .data = (void *)WM8994 }, 621 { .compatible = "wlf,wm8958", .data = (void *)WM8958 }, 622 { } 623 }; 624 MODULE_DEVICE_TABLE(of, wm8994_of_match); 625 626 static int wm8994_i2c_probe(struct i2c_client *i2c, 627 const struct i2c_device_id *id) 628 { 629 const struct of_device_id *of_id; 630 struct wm8994 *wm8994; 631 int ret; 632 633 wm8994 = devm_kzalloc(&i2c->dev, sizeof(struct wm8994), GFP_KERNEL); 634 if (wm8994 == NULL) 635 return -ENOMEM; 636 637 i2c_set_clientdata(i2c, wm8994); 638 wm8994->dev = &i2c->dev; 639 wm8994->irq = i2c->irq; 640 641 if (i2c->dev.of_node) { 642 of_id = of_match_device(wm8994_of_match, &i2c->dev); 643 if (of_id) 644 wm8994->type = (enum wm8994_type)of_id->data; 645 } else { 646 wm8994->type = id->driver_data; 647 } 648 649 wm8994->regmap = devm_regmap_init_i2c(i2c, &wm8994_base_regmap_config); 650 if (IS_ERR(wm8994->regmap)) { 651 ret = PTR_ERR(wm8994->regmap); 652 dev_err(wm8994->dev, "Failed to allocate register map: %d\n", 653 ret); 654 return ret; 655 } 656 657 return wm8994_device_init(wm8994, i2c->irq); 658 } 659 660 static int wm8994_i2c_remove(struct i2c_client *i2c) 661 { 662 struct wm8994 *wm8994 = i2c_get_clientdata(i2c); 663 664 wm8994_device_exit(wm8994); 665 666 return 0; 667 } 668 669 static const struct i2c_device_id wm8994_i2c_id[] = { 670 { "wm1811", WM1811 }, 671 { "wm1811a", WM1811 }, 672 { "wm8994", WM8994 }, 673 { "wm8958", WM8958 }, 674 { } 675 }; 676 MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id); 677 678 static const struct dev_pm_ops wm8994_pm_ops = { 679 SET_RUNTIME_PM_OPS(wm8994_suspend, wm8994_resume, NULL) 680 }; 681 682 static struct i2c_driver wm8994_i2c_driver = { 683 .driver = { 684 .name = "wm8994", 685 .pm = &wm8994_pm_ops, 686 .of_match_table = of_match_ptr(wm8994_of_match), 687 }, 688 .probe = wm8994_i2c_probe, 689 .remove = wm8994_i2c_remove, 690 .id_table = wm8994_i2c_id, 691 }; 692 693 module_i2c_driver(wm8994_i2c_driver); 694 695 MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC"); 696 MODULE_LICENSE("GPL"); 697 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>"); 698 MODULE_SOFTDEP("pre: wm8994_regulator"); 699