1 // SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause) 2 // Copyright(c) 2015-22 Intel Corporation. 3 4 /* 5 * Soundwire Intel Manager Driver 6 */ 7 8 #include <linux/acpi.h> 9 #include <linux/debugfs.h> 10 #include <linux/delay.h> 11 #include <linux/module.h> 12 #include <linux/interrupt.h> 13 #include <linux/io.h> 14 #include <linux/auxiliary_bus.h> 15 #include <sound/pcm_params.h> 16 #include <linux/pm_runtime.h> 17 #include <sound/soc.h> 18 #include <linux/soundwire/sdw_registers.h> 19 #include <linux/soundwire/sdw.h> 20 #include <linux/soundwire/sdw_intel.h> 21 #include "cadence_master.h" 22 #include "bus.h" 23 #include "intel.h" 24 #include "intel_auxdevice.h" 25 26 #define INTEL_MASTER_SUSPEND_DELAY_MS 3000 27 28 /* 29 * debug/config flags for the Intel SoundWire Master. 30 * 31 * Since we may have multiple masters active, we can have up to 8 32 * flags reused in each byte, with master0 using the ls-byte, etc. 33 */ 34 35 #define SDW_INTEL_MASTER_DISABLE_PM_RUNTIME BIT(0) 36 #define SDW_INTEL_MASTER_DISABLE_CLOCK_STOP BIT(1) 37 #define SDW_INTEL_MASTER_DISABLE_PM_RUNTIME_IDLE BIT(2) 38 #define SDW_INTEL_MASTER_DISABLE_MULTI_LINK BIT(3) 39 40 static int md_flags; 41 module_param_named(sdw_md_flags, md_flags, int, 0444); 42 MODULE_PARM_DESC(sdw_md_flags, "SoundWire Intel Master device flags (0x0 all off)"); 43 44 static int mclk_divider; 45 module_param_named(sdw_mclk_divider, mclk_divider, int, 0444); 46 MODULE_PARM_DESC(sdw_mclk_divider, "SoundWire Intel mclk divider"); 47 48 struct wake_capable_part { 49 const u16 mfg_id; 50 const u16 part_id; 51 }; 52 53 static struct wake_capable_part wake_capable_list[] = { 54 {0x01fa, 0x4243}, 55 {0x025d, 0x5682}, 56 {0x025d, 0x700}, 57 {0x025d, 0x711}, 58 {0x025d, 0x1712}, 59 {0x025d, 0x1713}, 60 {0x025d, 0x1716}, 61 {0x025d, 0x1717}, 62 {0x025d, 0x712}, 63 {0x025d, 0x713}, 64 {0x025d, 0x714}, 65 {0x025d, 0x715}, 66 {0x025d, 0x716}, 67 {0x025d, 0x717}, 68 {0x025d, 0x722}, 69 }; 70 71 static bool is_wake_capable(struct sdw_slave *slave) 72 { 73 int i; 74 75 for (i = 0; i < ARRAY_SIZE(wake_capable_list); i++) 76 if (slave->id.part_id == wake_capable_list[i].part_id && 77 slave->id.mfg_id == wake_capable_list[i].mfg_id) 78 return true; 79 return false; 80 } 81 82 static int generic_pre_bank_switch(struct sdw_bus *bus) 83 { 84 struct sdw_cdns *cdns = bus_to_cdns(bus); 85 struct sdw_intel *sdw = cdns_to_intel(cdns); 86 87 return sdw->link_res->hw_ops->pre_bank_switch(sdw); 88 } 89 90 static int generic_post_bank_switch(struct sdw_bus *bus) 91 { 92 struct sdw_cdns *cdns = bus_to_cdns(bus); 93 struct sdw_intel *sdw = cdns_to_intel(cdns); 94 95 return sdw->link_res->hw_ops->post_bank_switch(sdw); 96 } 97 98 static void generic_new_peripheral_assigned(struct sdw_bus *bus, 99 struct sdw_slave *slave, 100 int dev_num) 101 { 102 struct sdw_cdns *cdns = bus_to_cdns(bus); 103 struct sdw_intel *sdw = cdns_to_intel(cdns); 104 int dev_num_min; 105 int dev_num_max; 106 bool wake_capable = slave->prop.wake_capable || is_wake_capable(slave); 107 108 if (wake_capable) { 109 dev_num_min = SDW_INTEL_DEV_NUM_IDA_MIN; 110 dev_num_max = SDW_MAX_DEVICES; 111 } else { 112 dev_num_min = 1; 113 dev_num_max = SDW_INTEL_DEV_NUM_IDA_MIN - 1; 114 } 115 116 /* paranoia check, this should never happen */ 117 if (dev_num < dev_num_min || dev_num > dev_num_max) { 118 dev_err(bus->dev, "%s: invalid dev_num %d, wake supported %d\n", 119 __func__, dev_num, slave->prop.wake_capable); 120 return; 121 } 122 123 if (sdw->link_res->hw_ops->program_sdi && wake_capable) 124 sdw->link_res->hw_ops->program_sdi(sdw, dev_num); 125 } 126 127 static int sdw_master_read_intel_prop(struct sdw_bus *bus) 128 { 129 struct sdw_master_prop *prop = &bus->prop; 130 struct sdw_intel_prop *intel_prop; 131 struct fwnode_handle *link; 132 char name[32]; 133 u32 quirk_mask; 134 135 /* Find master handle */ 136 snprintf(name, sizeof(name), 137 "mipi-sdw-link-%d-subproperties", bus->link_id); 138 139 link = device_get_named_child_node(bus->dev, name); 140 if (!link) { 141 dev_err(bus->dev, "Master node %s not found\n", name); 142 return -EIO; 143 } 144 145 fwnode_property_read_u32(link, 146 "intel-sdw-ip-clock", 147 &prop->mclk_freq); 148 149 if (mclk_divider) 150 /* use kernel parameter for BIOS or board work-arounds */ 151 prop->mclk_freq /= mclk_divider; 152 else 153 /* the values reported by BIOS are the 2x clock, not the bus clock */ 154 prop->mclk_freq /= 2; 155 156 fwnode_property_read_u32(link, 157 "intel-quirk-mask", 158 &quirk_mask); 159 160 if (quirk_mask & SDW_INTEL_QUIRK_MASK_BUS_DISABLE) 161 prop->hw_disabled = true; 162 163 prop->quirks = SDW_MASTER_QUIRKS_CLEAR_INITIAL_CLASH | 164 SDW_MASTER_QUIRKS_CLEAR_INITIAL_PARITY; 165 166 intel_prop = devm_kzalloc(bus->dev, sizeof(*intel_prop), GFP_KERNEL); 167 if (!intel_prop) { 168 fwnode_handle_put(link); 169 return -ENOMEM; 170 } 171 172 /* initialize with hardware defaults, in case the properties are not found */ 173 intel_prop->clde = 0x0; 174 intel_prop->doaise2 = 0x0; 175 intel_prop->dodse2 = 0x0; 176 intel_prop->clds = 0x0; 177 intel_prop->clss = 0x0; 178 intel_prop->doaise = 0x1; 179 intel_prop->doais = 0x3; 180 intel_prop->dodse = 0x0; 181 intel_prop->dods = 0x1; 182 183 fwnode_property_read_u16(link, 184 "intel-sdw-clde", 185 &intel_prop->clde); 186 fwnode_property_read_u16(link, 187 "intel-sdw-doaise2", 188 &intel_prop->doaise2); 189 fwnode_property_read_u16(link, 190 "intel-sdw-dodse2", 191 &intel_prop->dodse2); 192 fwnode_property_read_u16(link, 193 "intel-sdw-clds", 194 &intel_prop->clds); 195 fwnode_property_read_u16(link, 196 "intel-sdw-clss", 197 &intel_prop->clss); 198 fwnode_property_read_u16(link, 199 "intel-sdw-doaise", 200 &intel_prop->doaise); 201 fwnode_property_read_u16(link, 202 "intel-sdw-doais", 203 &intel_prop->doais); 204 fwnode_property_read_u16(link, 205 "intel-sdw-dodse", 206 &intel_prop->dodse); 207 fwnode_property_read_u16(link, 208 "intel-sdw-dods", 209 &intel_prop->dods); 210 bus->vendor_specific_prop = intel_prop; 211 212 dev_dbg(bus->dev, "doaise %#x doais %#x dodse %#x dods %#x\n", 213 intel_prop->doaise, 214 intel_prop->doais, 215 intel_prop->dodse, 216 intel_prop->dods); 217 218 fwnode_handle_put(link); 219 220 return 0; 221 } 222 223 static int intel_prop_read(struct sdw_bus *bus) 224 { 225 struct sdw_master_prop *prop; 226 227 /* Initialize with default handler to read all DisCo properties */ 228 sdw_master_read_prop(bus); 229 230 /* 231 * Only one bus frequency is supported so far, filter 232 * frequencies reported in the DSDT 233 */ 234 prop = &bus->prop; 235 if (prop->clk_freq && prop->num_clk_freq > 1) { 236 unsigned int default_bus_frequency; 237 238 default_bus_frequency = 239 prop->default_frame_rate * 240 prop->default_row * 241 prop->default_col / 242 SDW_DOUBLE_RATE_FACTOR; 243 244 prop->num_clk_freq = 1; 245 prop->clk_freq[0] = default_bus_frequency; 246 prop->max_clk_freq = default_bus_frequency; 247 } 248 249 /* read Intel-specific properties */ 250 sdw_master_read_intel_prop(bus); 251 252 return 0; 253 } 254 255 static DEFINE_IDA(intel_peripheral_ida); 256 257 static int intel_get_device_num_ida(struct sdw_bus *bus, struct sdw_slave *slave) 258 { 259 int bit; 260 261 if (slave->prop.wake_capable || is_wake_capable(slave)) 262 return ida_alloc_range(&intel_peripheral_ida, 263 SDW_INTEL_DEV_NUM_IDA_MIN, SDW_MAX_DEVICES, 264 GFP_KERNEL); 265 266 bit = find_first_zero_bit(slave->bus->assigned, SDW_MAX_DEVICES); 267 if (bit == SDW_MAX_DEVICES) 268 return -ENODEV; 269 270 return bit; 271 } 272 273 static void intel_put_device_num_ida(struct sdw_bus *bus, struct sdw_slave *slave) 274 { 275 if (slave->prop.wake_capable || is_wake_capable(slave)) 276 ida_free(&intel_peripheral_ida, slave->dev_num); 277 } 278 279 static struct sdw_master_ops sdw_intel_ops = { 280 .read_prop = intel_prop_read, 281 .override_adr = sdw_dmi_override_adr, 282 .xfer_msg = cdns_xfer_msg, 283 .xfer_msg_defer = cdns_xfer_msg_defer, 284 .set_bus_conf = cdns_bus_conf, 285 .pre_bank_switch = generic_pre_bank_switch, 286 .post_bank_switch = generic_post_bank_switch, 287 .read_ping_status = cdns_read_ping_status, 288 .get_device_num = intel_get_device_num_ida, 289 .put_device_num = intel_put_device_num_ida, 290 .new_peripheral_assigned = generic_new_peripheral_assigned, 291 }; 292 293 /* 294 * probe and init (aux_dev_id argument is required by function prototype but not used) 295 */ 296 static int intel_link_probe(struct auxiliary_device *auxdev, 297 const struct auxiliary_device_id *aux_dev_id) 298 299 { 300 struct device *dev = &auxdev->dev; 301 struct sdw_intel_link_dev *ldev = auxiliary_dev_to_sdw_intel_link_dev(auxdev); 302 struct sdw_intel *sdw; 303 struct sdw_cdns *cdns; 304 struct sdw_bus *bus; 305 int ret; 306 307 sdw = devm_kzalloc(dev, sizeof(*sdw), GFP_KERNEL); 308 if (!sdw) 309 return -ENOMEM; 310 311 cdns = &sdw->cdns; 312 bus = &cdns->bus; 313 314 sdw->instance = auxdev->id; 315 sdw->link_res = &ldev->link_res; 316 cdns->dev = dev; 317 cdns->registers = sdw->link_res->registers; 318 cdns->ip_offset = sdw->link_res->ip_offset; 319 cdns->instance = sdw->instance; 320 cdns->msg_count = 0; 321 322 /* single controller for all SoundWire links */ 323 bus->controller_id = 0; 324 325 bus->link_id = auxdev->id; 326 bus->clk_stop_timeout = 1; 327 328 /* 329 * paranoia check: make sure ACPI-reported number of links is aligned with 330 * hardware capabilities. 331 */ 332 ret = sdw_intel_get_link_count(sdw); 333 if (ret < 0) { 334 dev_err(dev, "%s: sdw_intel_get_link_count failed: %d\n", __func__, ret); 335 return ret; 336 } 337 if (ret <= sdw->instance) { 338 dev_err(dev, "%s: invalid link id %d, link count %d\n", __func__, auxdev->id, ret); 339 return -EINVAL; 340 } 341 342 sdw_cdns_probe(cdns); 343 344 /* Set ops */ 345 bus->ops = &sdw_intel_ops; 346 347 /* set driver data, accessed by snd_soc_dai_get_drvdata() */ 348 auxiliary_set_drvdata(auxdev, cdns); 349 350 /* use generic bandwidth allocation algorithm */ 351 sdw->cdns.bus.compute_params = sdw_compute_params; 352 353 /* avoid resuming from pm_runtime suspend if it's not required */ 354 dev_pm_set_driver_flags(dev, DPM_FLAG_SMART_SUSPEND); 355 356 ret = sdw_bus_master_add(bus, dev, dev->fwnode); 357 if (ret) { 358 dev_err(dev, "sdw_bus_master_add fail: %d\n", ret); 359 return ret; 360 } 361 362 if (bus->prop.hw_disabled) 363 dev_info(dev, 364 "SoundWire master %d is disabled, will be ignored\n", 365 bus->link_id); 366 /* 367 * Ignore BIOS err_threshold, it's a really bad idea when dealing 368 * with multiple hardware synchronized links 369 */ 370 bus->prop.err_threshold = 0; 371 372 return 0; 373 } 374 375 int intel_link_startup(struct auxiliary_device *auxdev) 376 { 377 struct device *dev = &auxdev->dev; 378 struct sdw_cdns *cdns = auxiliary_get_drvdata(auxdev); 379 struct sdw_intel *sdw = cdns_to_intel(cdns); 380 struct sdw_bus *bus = &cdns->bus; 381 int link_flags; 382 bool multi_link; 383 u32 clock_stop_quirks; 384 int ret; 385 386 if (bus->prop.hw_disabled) { 387 dev_info(dev, 388 "SoundWire master %d is disabled, ignoring\n", 389 sdw->instance); 390 return 0; 391 } 392 393 link_flags = md_flags >> (bus->link_id * 8); 394 multi_link = !(link_flags & SDW_INTEL_MASTER_DISABLE_MULTI_LINK); 395 if (!multi_link) { 396 dev_dbg(dev, "Multi-link is disabled\n"); 397 } else { 398 /* 399 * hardware-based synchronization is required regardless 400 * of the number of segments used by a stream: SSP-based 401 * synchronization is gated by gsync when the multi-master 402 * mode is set. 403 */ 404 bus->hw_sync_min_links = 1; 405 } 406 bus->multi_link = multi_link; 407 408 /* Initialize shim, controller */ 409 ret = sdw_intel_link_power_up(sdw); 410 if (ret) 411 goto err_init; 412 413 /* Register DAIs */ 414 ret = sdw_intel_register_dai(sdw); 415 if (ret) { 416 dev_err(dev, "DAI registration failed: %d\n", ret); 417 goto err_power_up; 418 } 419 420 sdw_intel_debugfs_init(sdw); 421 422 /* Enable runtime PM */ 423 if (!(link_flags & SDW_INTEL_MASTER_DISABLE_PM_RUNTIME)) { 424 pm_runtime_set_autosuspend_delay(dev, 425 INTEL_MASTER_SUSPEND_DELAY_MS); 426 pm_runtime_use_autosuspend(dev); 427 pm_runtime_mark_last_busy(dev); 428 429 pm_runtime_set_active(dev); 430 pm_runtime_enable(dev); 431 432 pm_runtime_resume(bus->dev); 433 } 434 435 /* start bus */ 436 ret = sdw_intel_start_bus(sdw); 437 if (ret) { 438 dev_err(dev, "bus start failed: %d\n", ret); 439 goto err_pm_runtime; 440 } 441 442 clock_stop_quirks = sdw->link_res->clock_stop_quirks; 443 if (clock_stop_quirks & SDW_INTEL_CLK_STOP_NOT_ALLOWED) { 444 /* 445 * To keep the clock running we need to prevent 446 * pm_runtime suspend from happening by increasing the 447 * reference count. 448 * This quirk is specified by the parent PCI device in 449 * case of specific latency requirements. It will have 450 * no effect if pm_runtime is disabled by the user via 451 * a module parameter for testing purposes. 452 */ 453 pm_runtime_get_noresume(dev); 454 } 455 456 /* 457 * The runtime PM status of Slave devices is "Unsupported" 458 * until they report as ATTACHED. If they don't, e.g. because 459 * there are no Slave devices populated or if the power-on is 460 * delayed or dependent on a power switch, the Master will 461 * remain active and prevent its parent from suspending. 462 * 463 * Conditionally force the pm_runtime core to re-evaluate the 464 * Master status in the absence of any Slave activity. A quirk 465 * is provided to e.g. deal with Slaves that may be powered on 466 * with a delay. A more complete solution would require the 467 * definition of Master properties. 468 */ 469 if (!(link_flags & SDW_INTEL_MASTER_DISABLE_PM_RUNTIME_IDLE)) { 470 pm_runtime_mark_last_busy(bus->dev); 471 pm_runtime_mark_last_busy(dev); 472 pm_runtime_idle(dev); 473 } 474 475 sdw->startup_done = true; 476 return 0; 477 478 err_pm_runtime: 479 if (!(link_flags & SDW_INTEL_MASTER_DISABLE_PM_RUNTIME)) 480 pm_runtime_disable(dev); 481 err_power_up: 482 sdw_intel_link_power_down(sdw); 483 err_init: 484 return ret; 485 } 486 487 static void intel_link_remove(struct auxiliary_device *auxdev) 488 { 489 struct sdw_cdns *cdns = auxiliary_get_drvdata(auxdev); 490 struct sdw_intel *sdw = cdns_to_intel(cdns); 491 struct sdw_bus *bus = &cdns->bus; 492 493 /* 494 * Since pm_runtime is already disabled, we don't decrease 495 * the refcount when the clock_stop_quirk is 496 * SDW_INTEL_CLK_STOP_NOT_ALLOWED 497 */ 498 if (!bus->prop.hw_disabled) { 499 sdw_intel_debugfs_exit(sdw); 500 cancel_delayed_work_sync(&cdns->attach_dwork); 501 sdw_cdns_enable_interrupt(cdns, false); 502 } 503 sdw_bus_master_delete(bus); 504 } 505 506 int intel_link_process_wakeen_event(struct auxiliary_device *auxdev) 507 { 508 struct device *dev = &auxdev->dev; 509 struct sdw_intel *sdw; 510 struct sdw_bus *bus; 511 512 sdw = auxiliary_get_drvdata(auxdev); 513 bus = &sdw->cdns.bus; 514 515 if (bus->prop.hw_disabled || !sdw->startup_done) { 516 dev_dbg(dev, "SoundWire master %d is disabled or not-started, ignoring\n", 517 bus->link_id); 518 return 0; 519 } 520 521 if (!sdw_intel_shim_check_wake(sdw)) 522 return 0; 523 524 /* disable WAKEEN interrupt ASAP to prevent interrupt flood */ 525 sdw_intel_shim_wake(sdw, false); 526 527 /* 528 * resume the Master, which will generate a bus reset and result in 529 * Slaves re-attaching and be re-enumerated. The SoundWire physical 530 * device which generated the wake will trigger an interrupt, which 531 * will in turn cause the corresponding Linux Slave device to be 532 * resumed and the Slave codec driver to check the status. 533 */ 534 pm_request_resume(dev); 535 536 return 0; 537 } 538 539 /* 540 * PM calls 541 */ 542 543 int intel_resume_child_device(struct device *dev, void *data) 544 { 545 int ret; 546 struct sdw_slave *slave = dev_to_sdw_dev(dev); 547 548 if (!slave->probed) { 549 dev_dbg(dev, "skipping device, no probed driver\n"); 550 return 0; 551 } 552 if (!slave->dev_num_sticky) { 553 dev_dbg(dev, "skipping device, never detected on bus\n"); 554 return 0; 555 } 556 557 ret = pm_runtime_resume(dev); 558 if (ret < 0) { 559 dev_err(dev, "%s: pm_runtime_resume failed: %d\n", __func__, ret); 560 return ret; 561 } 562 563 return 0; 564 } 565 566 static int __maybe_unused intel_pm_prepare(struct device *dev) 567 { 568 struct sdw_cdns *cdns = dev_get_drvdata(dev); 569 struct sdw_intel *sdw = cdns_to_intel(cdns); 570 struct sdw_bus *bus = &cdns->bus; 571 u32 clock_stop_quirks; 572 int ret; 573 574 if (bus->prop.hw_disabled || !sdw->startup_done) { 575 dev_dbg(dev, "SoundWire master %d is disabled or not-started, ignoring\n", 576 bus->link_id); 577 return 0; 578 } 579 580 clock_stop_quirks = sdw->link_res->clock_stop_quirks; 581 582 if (pm_runtime_suspended(dev) && 583 pm_runtime_suspended(dev->parent) && 584 ((clock_stop_quirks & SDW_INTEL_CLK_STOP_BUS_RESET) || 585 !clock_stop_quirks)) { 586 /* 587 * if we've enabled clock stop, and the parent is suspended, the SHIM registers 588 * are not accessible and the shim wake cannot be disabled. 589 * The only solution is to resume the entire bus to full power 590 */ 591 592 /* 593 * If any operation in this block fails, we keep going since we don't want 594 * to prevent system suspend from happening and errors should be recoverable 595 * on resume. 596 */ 597 598 /* 599 * first resume the device for this link. This will also by construction 600 * resume the PCI parent device. 601 */ 602 ret = pm_runtime_resume(dev); 603 if (ret < 0) { 604 dev_err(dev, "%s: pm_runtime_resume failed: %d\n", __func__, ret); 605 return 0; 606 } 607 608 /* 609 * Continue resuming the entire bus (parent + child devices) to exit 610 * the clock stop mode. If there are no devices connected on this link 611 * this is a no-op. 612 * The resume to full power could have been implemented with a .prepare 613 * step in SoundWire codec drivers. This would however require a lot 614 * of code to handle an Intel-specific corner case. It is simpler in 615 * practice to add a loop at the link level. 616 */ 617 ret = device_for_each_child(bus->dev, NULL, intel_resume_child_device); 618 619 if (ret < 0) 620 dev_err(dev, "%s: intel_resume_child_device failed: %d\n", __func__, ret); 621 } 622 623 return 0; 624 } 625 626 static int __maybe_unused intel_suspend(struct device *dev) 627 { 628 struct sdw_cdns *cdns = dev_get_drvdata(dev); 629 struct sdw_intel *sdw = cdns_to_intel(cdns); 630 struct sdw_bus *bus = &cdns->bus; 631 u32 clock_stop_quirks; 632 int ret; 633 634 if (bus->prop.hw_disabled || !sdw->startup_done) { 635 dev_dbg(dev, "SoundWire master %d is disabled or not-started, ignoring\n", 636 bus->link_id); 637 return 0; 638 } 639 640 if (pm_runtime_suspended(dev)) { 641 dev_dbg(dev, "pm_runtime status: suspended\n"); 642 643 clock_stop_quirks = sdw->link_res->clock_stop_quirks; 644 645 if ((clock_stop_quirks & SDW_INTEL_CLK_STOP_BUS_RESET) || 646 !clock_stop_quirks) { 647 648 if (pm_runtime_suspended(dev->parent)) { 649 /* 650 * paranoia check: this should not happen with the .prepare 651 * resume to full power 652 */ 653 dev_err(dev, "%s: invalid config: parent is suspended\n", __func__); 654 } else { 655 sdw_intel_shim_wake(sdw, false); 656 } 657 } 658 659 return 0; 660 } 661 662 ret = sdw_intel_stop_bus(sdw, false); 663 if (ret < 0) { 664 dev_err(dev, "%s: cannot stop bus: %d\n", __func__, ret); 665 return ret; 666 } 667 668 return 0; 669 } 670 671 static int __maybe_unused intel_suspend_runtime(struct device *dev) 672 { 673 struct sdw_cdns *cdns = dev_get_drvdata(dev); 674 struct sdw_intel *sdw = cdns_to_intel(cdns); 675 struct sdw_bus *bus = &cdns->bus; 676 u32 clock_stop_quirks; 677 int ret; 678 679 if (bus->prop.hw_disabled || !sdw->startup_done) { 680 dev_dbg(dev, "SoundWire master %d is disabled or not-started, ignoring\n", 681 bus->link_id); 682 return 0; 683 } 684 685 clock_stop_quirks = sdw->link_res->clock_stop_quirks; 686 687 if (clock_stop_quirks & SDW_INTEL_CLK_STOP_TEARDOWN) { 688 ret = sdw_intel_stop_bus(sdw, false); 689 if (ret < 0) { 690 dev_err(dev, "%s: cannot stop bus during teardown: %d\n", 691 __func__, ret); 692 return ret; 693 } 694 } else if (clock_stop_quirks & SDW_INTEL_CLK_STOP_BUS_RESET || !clock_stop_quirks) { 695 ret = sdw_intel_stop_bus(sdw, true); 696 if (ret < 0) { 697 dev_err(dev, "%s: cannot stop bus during clock_stop: %d\n", 698 __func__, ret); 699 return ret; 700 } 701 } else { 702 dev_err(dev, "%s clock_stop_quirks %x unsupported\n", 703 __func__, clock_stop_quirks); 704 ret = -EINVAL; 705 } 706 707 return ret; 708 } 709 710 static int __maybe_unused intel_resume(struct device *dev) 711 { 712 struct sdw_cdns *cdns = dev_get_drvdata(dev); 713 struct sdw_intel *sdw = cdns_to_intel(cdns); 714 struct sdw_bus *bus = &cdns->bus; 715 int link_flags; 716 int ret; 717 718 if (bus->prop.hw_disabled || !sdw->startup_done) { 719 dev_dbg(dev, "SoundWire master %d is disabled or not-started, ignoring\n", 720 bus->link_id); 721 return 0; 722 } 723 724 if (pm_runtime_suspended(dev)) { 725 dev_dbg(dev, "pm_runtime status was suspended, forcing active\n"); 726 727 /* follow required sequence from runtime_pm.rst */ 728 pm_runtime_disable(dev); 729 pm_runtime_set_active(dev); 730 pm_runtime_mark_last_busy(dev); 731 pm_runtime_enable(dev); 732 733 pm_runtime_resume(bus->dev); 734 735 link_flags = md_flags >> (bus->link_id * 8); 736 737 if (!(link_flags & SDW_INTEL_MASTER_DISABLE_PM_RUNTIME_IDLE)) 738 pm_runtime_idle(dev); 739 } 740 741 ret = sdw_intel_link_power_up(sdw); 742 if (ret) { 743 dev_err(dev, "%s failed: %d\n", __func__, ret); 744 return ret; 745 } 746 747 /* 748 * make sure all Slaves are tagged as UNATTACHED and provide 749 * reason for reinitialization 750 */ 751 sdw_clear_slave_status(bus, SDW_UNATTACH_REQUEST_MASTER_RESET); 752 753 ret = sdw_intel_start_bus(sdw); 754 if (ret < 0) { 755 dev_err(dev, "cannot start bus during resume\n"); 756 sdw_intel_link_power_down(sdw); 757 return ret; 758 } 759 760 /* 761 * after system resume, the pm_runtime suspend() may kick in 762 * during the enumeration, before any children device force the 763 * master device to remain active. Using pm_runtime_get() 764 * routines is not really possible, since it'd prevent the 765 * master from suspending. 766 * A reasonable compromise is to update the pm_runtime 767 * counters and delay the pm_runtime suspend by several 768 * seconds, by when all enumeration should be complete. 769 */ 770 pm_runtime_mark_last_busy(bus->dev); 771 pm_runtime_mark_last_busy(dev); 772 773 return 0; 774 } 775 776 static int __maybe_unused intel_resume_runtime(struct device *dev) 777 { 778 struct sdw_cdns *cdns = dev_get_drvdata(dev); 779 struct sdw_intel *sdw = cdns_to_intel(cdns); 780 struct sdw_bus *bus = &cdns->bus; 781 u32 clock_stop_quirks; 782 int ret; 783 784 if (bus->prop.hw_disabled || !sdw->startup_done) { 785 dev_dbg(dev, "SoundWire master %d is disabled or not-started, ignoring\n", 786 bus->link_id); 787 return 0; 788 } 789 790 /* unconditionally disable WAKEEN interrupt */ 791 sdw_intel_shim_wake(sdw, false); 792 793 clock_stop_quirks = sdw->link_res->clock_stop_quirks; 794 795 if (clock_stop_quirks & SDW_INTEL_CLK_STOP_TEARDOWN) { 796 ret = sdw_intel_link_power_up(sdw); 797 if (ret) { 798 dev_err(dev, "%s: power_up failed after teardown: %d\n", __func__, ret); 799 return ret; 800 } 801 802 /* 803 * make sure all Slaves are tagged as UNATTACHED and provide 804 * reason for reinitialization 805 */ 806 sdw_clear_slave_status(bus, SDW_UNATTACH_REQUEST_MASTER_RESET); 807 808 ret = sdw_intel_start_bus(sdw); 809 if (ret < 0) { 810 dev_err(dev, "%s: cannot start bus after teardown: %d\n", __func__, ret); 811 sdw_intel_link_power_down(sdw); 812 return ret; 813 } 814 815 } else if (clock_stop_quirks & SDW_INTEL_CLK_STOP_BUS_RESET) { 816 ret = sdw_intel_link_power_up(sdw); 817 if (ret) { 818 dev_err(dev, "%s: power_up failed after bus reset: %d\n", __func__, ret); 819 return ret; 820 } 821 822 ret = sdw_intel_start_bus_after_reset(sdw); 823 if (ret < 0) { 824 dev_err(dev, "%s: cannot start bus after reset: %d\n", __func__, ret); 825 sdw_intel_link_power_down(sdw); 826 return ret; 827 } 828 } else if (!clock_stop_quirks) { 829 830 sdw_intel_check_clock_stop(sdw); 831 832 ret = sdw_intel_link_power_up(sdw); 833 if (ret) { 834 dev_err(dev, "%s: power_up failed: %d\n", __func__, ret); 835 return ret; 836 } 837 838 ret = sdw_intel_start_bus_after_clock_stop(sdw); 839 if (ret < 0) { 840 dev_err(dev, "%s: cannot start bus after clock stop: %d\n", __func__, ret); 841 sdw_intel_link_power_down(sdw); 842 return ret; 843 } 844 } else { 845 dev_err(dev, "%s: clock_stop_quirks %x unsupported\n", 846 __func__, clock_stop_quirks); 847 ret = -EINVAL; 848 } 849 850 return ret; 851 } 852 853 static const struct dev_pm_ops intel_pm = { 854 .prepare = intel_pm_prepare, 855 SET_SYSTEM_SLEEP_PM_OPS(intel_suspend, intel_resume) 856 SET_RUNTIME_PM_OPS(intel_suspend_runtime, intel_resume_runtime, NULL) 857 }; 858 859 static const struct auxiliary_device_id intel_link_id_table[] = { 860 { .name = "soundwire_intel.link" }, 861 {}, 862 }; 863 MODULE_DEVICE_TABLE(auxiliary, intel_link_id_table); 864 865 static struct auxiliary_driver sdw_intel_drv = { 866 .probe = intel_link_probe, 867 .remove = intel_link_remove, 868 .driver = { 869 /* auxiliary_driver_register() sets .name to be the modname */ 870 .pm = &intel_pm, 871 }, 872 .id_table = intel_link_id_table 873 }; 874 module_auxiliary_driver(sdw_intel_drv); 875 876 MODULE_LICENSE("Dual BSD/GPL"); 877 MODULE_DESCRIPTION("Intel Soundwire Link Driver"); 878