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