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