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 = true; 283 pdata->lineout2_diff = true; 284 if (of_find_property(np, "wlf,lineout1-se", NULL)) 285 pdata->lineout1_diff = false; 286 if (of_find_property(np, "wlf,lineout2-se", NULL)) 287 pdata->lineout2_diff = false; 288 289 if (of_find_property(np, "wlf,lineout1-feedback", NULL)) 290 pdata->lineout1fb = true; 291 if (of_find_property(np, "wlf,lineout2-feedback", NULL)) 292 pdata->lineout2fb = true; 293 294 if (of_find_property(np, "wlf,ldoena-always-driven", NULL)) 295 pdata->lineout2fb = true; 296 297 pdata->spkmode_pu = of_property_read_bool(np, "wlf,spkmode-pu"); 298 299 pdata->csnaddr_pd = of_property_read_bool(np, "wlf,csnaddr-pd"); 300 301 return 0; 302 } 303 #else 304 static int wm8994_set_pdata_from_of(struct wm8994 *wm8994) 305 { 306 return 0; 307 } 308 #endif 309 310 /* 311 * Instantiate the generic non-control parts of the device. 312 */ 313 static int wm8994_device_init(struct wm8994 *wm8994, int irq) 314 { 315 struct wm8994_pdata *pdata; 316 struct regmap_config *regmap_config; 317 const struct reg_sequence *regmap_patch = NULL; 318 const char *devname; 319 int ret, i, patch_regs = 0; 320 int pulls = 0; 321 322 if (dev_get_platdata(wm8994->dev)) { 323 pdata = dev_get_platdata(wm8994->dev); 324 wm8994->pdata = *pdata; 325 } 326 pdata = &wm8994->pdata; 327 328 ret = wm8994_set_pdata_from_of(wm8994); 329 if (ret != 0) 330 return ret; 331 332 dev_set_drvdata(wm8994->dev, wm8994); 333 334 /* Add the on-chip regulators first for bootstrapping */ 335 ret = mfd_add_devices(wm8994->dev, 0, 336 wm8994_regulator_devs, 337 ARRAY_SIZE(wm8994_regulator_devs), 338 NULL, 0, NULL); 339 if (ret != 0) { 340 dev_err(wm8994->dev, "Failed to add children: %d\n", ret); 341 goto err; 342 } 343 344 switch (wm8994->type) { 345 case WM1811: 346 wm8994->num_supplies = ARRAY_SIZE(wm1811_main_supplies); 347 break; 348 case WM8994: 349 wm8994->num_supplies = ARRAY_SIZE(wm8994_main_supplies); 350 break; 351 case WM8958: 352 wm8994->num_supplies = ARRAY_SIZE(wm8958_main_supplies); 353 break; 354 default: 355 BUG(); 356 goto err; 357 } 358 359 wm8994->supplies = devm_kcalloc(wm8994->dev, 360 wm8994->num_supplies, 361 sizeof(struct regulator_bulk_data), 362 GFP_KERNEL); 363 if (!wm8994->supplies) { 364 ret = -ENOMEM; 365 goto err; 366 } 367 368 switch (wm8994->type) { 369 case WM1811: 370 for (i = 0; i < ARRAY_SIZE(wm1811_main_supplies); i++) 371 wm8994->supplies[i].supply = wm1811_main_supplies[i]; 372 break; 373 case WM8994: 374 for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++) 375 wm8994->supplies[i].supply = wm8994_main_supplies[i]; 376 break; 377 case WM8958: 378 for (i = 0; i < ARRAY_SIZE(wm8958_main_supplies); i++) 379 wm8994->supplies[i].supply = wm8958_main_supplies[i]; 380 break; 381 default: 382 BUG(); 383 goto err; 384 } 385 386 /* 387 * Can't use devres helper here as some of the supplies are provided by 388 * wm8994->dev's children (regulators) and those regulators are 389 * unregistered by the devres core before the supplies are freed. 390 */ 391 ret = regulator_bulk_get(wm8994->dev, wm8994->num_supplies, 392 wm8994->supplies); 393 if (ret != 0) { 394 if (ret != -EPROBE_DEFER) 395 dev_err(wm8994->dev, "Failed to get supplies: %d\n", 396 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_set_active(wm8994->dev); 588 pm_runtime_enable(wm8994->dev); 589 pm_runtime_idle(wm8994->dev); 590 591 return 0; 592 593 err_irq: 594 wm8994_irq_exit(wm8994); 595 err_enable: 596 regulator_bulk_disable(wm8994->num_supplies, 597 wm8994->supplies); 598 err_regulator_free: 599 regulator_bulk_free(wm8994->num_supplies, wm8994->supplies); 600 err: 601 mfd_remove_devices(wm8994->dev); 602 return ret; 603 } 604 605 static void wm8994_device_exit(struct wm8994 *wm8994) 606 { 607 pm_runtime_get_sync(wm8994->dev); 608 pm_runtime_disable(wm8994->dev); 609 pm_runtime_put_noidle(wm8994->dev); 610 wm8994_irq_exit(wm8994); 611 regulator_bulk_disable(wm8994->num_supplies, wm8994->supplies); 612 regulator_bulk_free(wm8994->num_supplies, wm8994->supplies); 613 mfd_remove_devices(wm8994->dev); 614 } 615 616 static const struct of_device_id wm8994_of_match[] = { 617 { .compatible = "wlf,wm1811", .data = (void *)WM1811 }, 618 { .compatible = "wlf,wm8994", .data = (void *)WM8994 }, 619 { .compatible = "wlf,wm8958", .data = (void *)WM8958 }, 620 { } 621 }; 622 MODULE_DEVICE_TABLE(of, wm8994_of_match); 623 624 static int wm8994_i2c_probe(struct i2c_client *i2c) 625 { 626 const struct i2c_device_id *id = i2c_client_get_device_id(i2c); 627 const struct of_device_id *of_id; 628 struct wm8994 *wm8994; 629 int ret; 630 631 wm8994 = devm_kzalloc(&i2c->dev, sizeof(struct wm8994), GFP_KERNEL); 632 if (wm8994 == NULL) 633 return -ENOMEM; 634 635 i2c_set_clientdata(i2c, wm8994); 636 wm8994->dev = &i2c->dev; 637 wm8994->irq = i2c->irq; 638 639 if (i2c->dev.of_node) { 640 of_id = of_match_device(wm8994_of_match, &i2c->dev); 641 if (of_id) 642 wm8994->type = (enum wm8994_type)of_id->data; 643 } else { 644 wm8994->type = id->driver_data; 645 } 646 647 wm8994->regmap = devm_regmap_init_i2c(i2c, &wm8994_base_regmap_config); 648 if (IS_ERR(wm8994->regmap)) { 649 ret = PTR_ERR(wm8994->regmap); 650 dev_err(wm8994->dev, "Failed to allocate register map: %d\n", 651 ret); 652 return ret; 653 } 654 655 return wm8994_device_init(wm8994, i2c->irq); 656 } 657 658 static void wm8994_i2c_remove(struct i2c_client *i2c) 659 { 660 struct wm8994 *wm8994 = i2c_get_clientdata(i2c); 661 662 wm8994_device_exit(wm8994); 663 } 664 665 static const struct i2c_device_id wm8994_i2c_id[] = { 666 { "wm1811", WM1811 }, 667 { "wm1811a", WM1811 }, 668 { "wm8994", WM8994 }, 669 { "wm8958", WM8958 }, 670 { } 671 }; 672 MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id); 673 674 static const struct dev_pm_ops wm8994_pm_ops = { 675 RUNTIME_PM_OPS(wm8994_suspend, wm8994_resume, NULL) 676 }; 677 678 static struct i2c_driver wm8994_i2c_driver = { 679 .driver = { 680 .name = "wm8994", 681 .pm = pm_ptr(&wm8994_pm_ops), 682 .of_match_table = wm8994_of_match, 683 }, 684 .probe_new = wm8994_i2c_probe, 685 .remove = wm8994_i2c_remove, 686 .id_table = wm8994_i2c_id, 687 }; 688 689 module_i2c_driver(wm8994_i2c_driver); 690 691 MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC"); 692 MODULE_LICENSE("GPL"); 693 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>"); 694 MODULE_SOFTDEP("pre: wm8994_regulator"); 695