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 dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret); 397 goto err; 398 } 399 400 ret = regulator_bulk_enable(wm8994->num_supplies, wm8994->supplies); 401 if (ret != 0) { 402 dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret); 403 goto err_regulator_free; 404 } 405 406 ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET); 407 if (ret < 0) { 408 dev_err(wm8994->dev, "Failed to read ID register\n"); 409 goto err_enable; 410 } 411 switch (ret) { 412 case 0x1811: 413 devname = "WM1811"; 414 if (wm8994->type != WM1811) 415 dev_warn(wm8994->dev, "Device registered as type %d\n", 416 wm8994->type); 417 wm8994->type = WM1811; 418 break; 419 case 0x8994: 420 devname = "WM8994"; 421 if (wm8994->type != WM8994) 422 dev_warn(wm8994->dev, "Device registered as type %d\n", 423 wm8994->type); 424 wm8994->type = WM8994; 425 break; 426 case 0x8958: 427 devname = "WM8958"; 428 if (wm8994->type != WM8958) 429 dev_warn(wm8994->dev, "Device registered as type %d\n", 430 wm8994->type); 431 wm8994->type = WM8958; 432 break; 433 default: 434 dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n", 435 ret); 436 ret = -EINVAL; 437 goto err_enable; 438 } 439 440 ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION); 441 if (ret < 0) { 442 dev_err(wm8994->dev, "Failed to read revision register: %d\n", 443 ret); 444 goto err_enable; 445 } 446 wm8994->revision = ret & WM8994_CHIP_REV_MASK; 447 wm8994->cust_id = (ret & WM8994_CUST_ID_MASK) >> WM8994_CUST_ID_SHIFT; 448 449 switch (wm8994->type) { 450 case WM8994: 451 switch (wm8994->revision) { 452 case 0: 453 case 1: 454 dev_warn(wm8994->dev, 455 "revision %c not fully supported\n", 456 'A' + wm8994->revision); 457 break; 458 case 2: 459 case 3: 460 default: 461 regmap_patch = wm8994_revc_patch; 462 patch_regs = ARRAY_SIZE(wm8994_revc_patch); 463 break; 464 } 465 break; 466 467 case WM8958: 468 switch (wm8994->revision) { 469 case 0: 470 regmap_patch = wm8958_reva_patch; 471 patch_regs = ARRAY_SIZE(wm8958_reva_patch); 472 break; 473 default: 474 break; 475 } 476 break; 477 478 case WM1811: 479 /* Revision C did not change the relevant layer */ 480 if (wm8994->revision > 1) 481 wm8994->revision++; 482 483 regmap_patch = wm1811_reva_patch; 484 patch_regs = ARRAY_SIZE(wm1811_reva_patch); 485 break; 486 487 default: 488 break; 489 } 490 491 dev_info(wm8994->dev, "%s revision %c CUST_ID %02x\n", devname, 492 'A' + wm8994->revision, wm8994->cust_id); 493 494 switch (wm8994->type) { 495 case WM1811: 496 regmap_config = &wm1811_regmap_config; 497 break; 498 case WM8994: 499 regmap_config = &wm8994_regmap_config; 500 break; 501 case WM8958: 502 regmap_config = &wm8958_regmap_config; 503 break; 504 default: 505 dev_err(wm8994->dev, "Unknown device type %d\n", wm8994->type); 506 ret = -EINVAL; 507 goto err_enable; 508 } 509 510 ret = regmap_reinit_cache(wm8994->regmap, regmap_config); 511 if (ret != 0) { 512 dev_err(wm8994->dev, "Failed to reinit register cache: %d\n", 513 ret); 514 goto err_enable; 515 } 516 517 /* Explicitly put the device into reset in case regulators 518 * don't get disabled in order to ensure we know the device 519 * state. 520 */ 521 ret = wm8994_reg_write(wm8994, WM8994_SOFTWARE_RESET, 522 wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET)); 523 if (ret != 0) { 524 dev_err(wm8994->dev, "Failed to reset device: %d\n", ret); 525 goto err_enable; 526 } 527 528 if (regmap_patch) { 529 ret = regmap_register_patch(wm8994->regmap, regmap_patch, 530 patch_regs); 531 if (ret != 0) { 532 dev_err(wm8994->dev, "Failed to register patch: %d\n", 533 ret); 534 goto err_enable; 535 } 536 } 537 538 wm8994->irq_base = pdata->irq_base; 539 wm8994->gpio_base = pdata->gpio_base; 540 541 /* GPIO configuration is only applied if it's non-zero */ 542 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) { 543 if (pdata->gpio_defaults[i]) { 544 wm8994_set_bits(wm8994, WM8994_GPIO_1 + i, 545 0xffff, pdata->gpio_defaults[i]); 546 } 547 } 548 549 wm8994->ldo_ena_always_driven = pdata->ldo_ena_always_driven; 550 551 if (pdata->spkmode_pu) 552 pulls |= WM8994_SPKMODE_PU; 553 if (pdata->csnaddr_pd) 554 pulls |= WM8994_CSNADDR_PD; 555 556 /* Disable unneeded pulls */ 557 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2, 558 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD | 559 WM8994_SPKMODE_PU | WM8994_CSNADDR_PD, 560 pulls); 561 562 /* In some system designs where the regulators are not in use, 563 * we can achieve a small reduction in leakage currents by 564 * floating LDO outputs. This bit makes no difference if the 565 * LDOs are enabled, it only affects cases where the LDOs were 566 * in operation and are then disabled. 567 */ 568 for (i = 0; i < WM8994_NUM_LDO_REGS; i++) { 569 if (wm8994_ldo_in_use(pdata, i)) 570 wm8994_set_bits(wm8994, WM8994_LDO_1 + i, 571 WM8994_LDO1_DISCH, WM8994_LDO1_DISCH); 572 else 573 wm8994_set_bits(wm8994, WM8994_LDO_1 + i, 574 WM8994_LDO1_DISCH, 0); 575 } 576 577 wm8994_irq_init(wm8994); 578 579 ret = mfd_add_devices(wm8994->dev, -1, 580 wm8994_devs, ARRAY_SIZE(wm8994_devs), 581 NULL, 0, NULL); 582 if (ret != 0) { 583 dev_err(wm8994->dev, "Failed to add children: %d\n", ret); 584 goto err_irq; 585 } 586 587 pm_runtime_enable(wm8994->dev); 588 pm_runtime_idle(wm8994->dev); 589 590 return 0; 591 592 err_irq: 593 wm8994_irq_exit(wm8994); 594 err_enable: 595 regulator_bulk_disable(wm8994->num_supplies, 596 wm8994->supplies); 597 err_regulator_free: 598 regulator_bulk_free(wm8994->num_supplies, wm8994->supplies); 599 err: 600 mfd_remove_devices(wm8994->dev); 601 return ret; 602 } 603 604 static void wm8994_device_exit(struct wm8994 *wm8994) 605 { 606 pm_runtime_disable(wm8994->dev); 607 wm8994_irq_exit(wm8994); 608 regulator_bulk_disable(wm8994->num_supplies, wm8994->supplies); 609 regulator_bulk_free(wm8994->num_supplies, wm8994->supplies); 610 mfd_remove_devices(wm8994->dev); 611 } 612 613 static const struct of_device_id wm8994_of_match[] = { 614 { .compatible = "wlf,wm1811", .data = (void *)WM1811 }, 615 { .compatible = "wlf,wm8994", .data = (void *)WM8994 }, 616 { .compatible = "wlf,wm8958", .data = (void *)WM8958 }, 617 { } 618 }; 619 MODULE_DEVICE_TABLE(of, wm8994_of_match); 620 621 static int wm8994_i2c_probe(struct i2c_client *i2c, 622 const struct i2c_device_id *id) 623 { 624 const struct of_device_id *of_id; 625 struct wm8994 *wm8994; 626 int ret; 627 628 wm8994 = devm_kzalloc(&i2c->dev, sizeof(struct wm8994), GFP_KERNEL); 629 if (wm8994 == NULL) 630 return -ENOMEM; 631 632 i2c_set_clientdata(i2c, wm8994); 633 wm8994->dev = &i2c->dev; 634 wm8994->irq = i2c->irq; 635 636 if (i2c->dev.of_node) { 637 of_id = of_match_device(wm8994_of_match, &i2c->dev); 638 if (of_id) 639 wm8994->type = (enum wm8994_type)of_id->data; 640 } else { 641 wm8994->type = id->driver_data; 642 } 643 644 wm8994->regmap = devm_regmap_init_i2c(i2c, &wm8994_base_regmap_config); 645 if (IS_ERR(wm8994->regmap)) { 646 ret = PTR_ERR(wm8994->regmap); 647 dev_err(wm8994->dev, "Failed to allocate register map: %d\n", 648 ret); 649 return ret; 650 } 651 652 return wm8994_device_init(wm8994, i2c->irq); 653 } 654 655 static int wm8994_i2c_remove(struct i2c_client *i2c) 656 { 657 struct wm8994 *wm8994 = i2c_get_clientdata(i2c); 658 659 wm8994_device_exit(wm8994); 660 661 return 0; 662 } 663 664 static const struct i2c_device_id wm8994_i2c_id[] = { 665 { "wm1811", WM1811 }, 666 { "wm1811a", WM1811 }, 667 { "wm8994", WM8994 }, 668 { "wm8958", WM8958 }, 669 { } 670 }; 671 MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id); 672 673 static const struct dev_pm_ops wm8994_pm_ops = { 674 SET_RUNTIME_PM_OPS(wm8994_suspend, wm8994_resume, NULL) 675 }; 676 677 static struct i2c_driver wm8994_i2c_driver = { 678 .driver = { 679 .name = "wm8994", 680 .pm = &wm8994_pm_ops, 681 .of_match_table = of_match_ptr(wm8994_of_match), 682 }, 683 .probe = wm8994_i2c_probe, 684 .remove = wm8994_i2c_remove, 685 .id_table = wm8994_i2c_id, 686 }; 687 688 module_i2c_driver(wm8994_i2c_driver); 689 690 MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC"); 691 MODULE_LICENSE("GPL"); 692 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>"); 693