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