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