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 sdw_cdns_probe(cdns); 321 322 /* Set ops */ 323 bus->ops = &sdw_intel_ops; 324 325 /* set driver data, accessed by snd_soc_dai_get_drvdata() */ 326 auxiliary_set_drvdata(auxdev, cdns); 327 328 /* use generic bandwidth allocation algorithm */ 329 sdw->cdns.bus.compute_params = sdw_compute_params; 330 331 /* avoid resuming from pm_runtime suspend if it's not required */ 332 dev_pm_set_driver_flags(dev, DPM_FLAG_SMART_SUSPEND); 333 334 ret = sdw_bus_master_add(bus, dev, dev->fwnode); 335 if (ret) { 336 dev_err(dev, "sdw_bus_master_add fail: %d\n", ret); 337 return ret; 338 } 339 340 if (bus->prop.hw_disabled) 341 dev_info(dev, 342 "SoundWire master %d is disabled, will be ignored\n", 343 bus->link_id); 344 /* 345 * Ignore BIOS err_threshold, it's a really bad idea when dealing 346 * with multiple hardware synchronized links 347 */ 348 bus->prop.err_threshold = 0; 349 350 return 0; 351 } 352 353 int intel_link_startup(struct auxiliary_device *auxdev) 354 { 355 struct device *dev = &auxdev->dev; 356 struct sdw_cdns *cdns = auxiliary_get_drvdata(auxdev); 357 struct sdw_intel *sdw = cdns_to_intel(cdns); 358 struct sdw_bus *bus = &cdns->bus; 359 int link_flags; 360 bool multi_link; 361 u32 clock_stop_quirks; 362 int ret; 363 364 if (bus->prop.hw_disabled) { 365 dev_info(dev, 366 "SoundWire master %d is disabled, ignoring\n", 367 sdw->instance); 368 return 0; 369 } 370 371 link_flags = md_flags >> (bus->link_id * 8); 372 multi_link = !(link_flags & SDW_INTEL_MASTER_DISABLE_MULTI_LINK); 373 if (!multi_link) { 374 dev_dbg(dev, "Multi-link is disabled\n"); 375 } else { 376 /* 377 * hardware-based synchronization is required regardless 378 * of the number of segments used by a stream: SSP-based 379 * synchronization is gated by gsync when the multi-master 380 * mode is set. 381 */ 382 bus->hw_sync_min_links = 1; 383 } 384 bus->multi_link = multi_link; 385 386 /* Initialize shim, controller */ 387 ret = sdw_intel_link_power_up(sdw); 388 if (ret) 389 goto err_init; 390 391 /* Register DAIs */ 392 ret = sdw_intel_register_dai(sdw); 393 if (ret) { 394 dev_err(dev, "DAI registration failed: %d\n", ret); 395 goto err_power_up; 396 } 397 398 sdw_intel_debugfs_init(sdw); 399 400 /* Enable runtime PM */ 401 if (!(link_flags & SDW_INTEL_MASTER_DISABLE_PM_RUNTIME)) { 402 pm_runtime_set_autosuspend_delay(dev, 403 INTEL_MASTER_SUSPEND_DELAY_MS); 404 pm_runtime_use_autosuspend(dev); 405 pm_runtime_mark_last_busy(dev); 406 407 pm_runtime_set_active(dev); 408 pm_runtime_enable(dev); 409 410 pm_runtime_resume(bus->dev); 411 } 412 413 /* start bus */ 414 ret = sdw_intel_start_bus(sdw); 415 if (ret) { 416 dev_err(dev, "bus start failed: %d\n", ret); 417 goto err_pm_runtime; 418 } 419 420 clock_stop_quirks = sdw->link_res->clock_stop_quirks; 421 if (clock_stop_quirks & SDW_INTEL_CLK_STOP_NOT_ALLOWED) { 422 /* 423 * To keep the clock running we need to prevent 424 * pm_runtime suspend from happening by increasing the 425 * reference count. 426 * This quirk is specified by the parent PCI device in 427 * case of specific latency requirements. It will have 428 * no effect if pm_runtime is disabled by the user via 429 * a module parameter for testing purposes. 430 */ 431 pm_runtime_get_noresume(dev); 432 } 433 434 /* 435 * The runtime PM status of Slave devices is "Unsupported" 436 * until they report as ATTACHED. If they don't, e.g. because 437 * there are no Slave devices populated or if the power-on is 438 * delayed or dependent on a power switch, the Master will 439 * remain active and prevent its parent from suspending. 440 * 441 * Conditionally force the pm_runtime core to re-evaluate the 442 * Master status in the absence of any Slave activity. A quirk 443 * is provided to e.g. deal with Slaves that may be powered on 444 * with a delay. A more complete solution would require the 445 * definition of Master properties. 446 */ 447 if (!(link_flags & SDW_INTEL_MASTER_DISABLE_PM_RUNTIME_IDLE)) { 448 pm_runtime_mark_last_busy(bus->dev); 449 pm_runtime_mark_last_busy(dev); 450 pm_runtime_idle(dev); 451 } 452 453 sdw->startup_done = true; 454 return 0; 455 456 err_pm_runtime: 457 if (!(link_flags & SDW_INTEL_MASTER_DISABLE_PM_RUNTIME)) 458 pm_runtime_disable(dev); 459 err_power_up: 460 sdw_intel_link_power_down(sdw); 461 err_init: 462 return ret; 463 } 464 465 static void intel_link_remove(struct auxiliary_device *auxdev) 466 { 467 struct sdw_cdns *cdns = auxiliary_get_drvdata(auxdev); 468 struct sdw_intel *sdw = cdns_to_intel(cdns); 469 struct sdw_bus *bus = &cdns->bus; 470 471 /* 472 * Since pm_runtime is already disabled, we don't decrease 473 * the refcount when the clock_stop_quirk is 474 * SDW_INTEL_CLK_STOP_NOT_ALLOWED 475 */ 476 if (!bus->prop.hw_disabled) { 477 sdw_intel_debugfs_exit(sdw); 478 sdw_cdns_enable_interrupt(cdns, false); 479 } 480 sdw_bus_master_delete(bus); 481 } 482 483 int intel_link_process_wakeen_event(struct auxiliary_device *auxdev) 484 { 485 struct device *dev = &auxdev->dev; 486 struct sdw_intel *sdw; 487 struct sdw_bus *bus; 488 489 sdw = auxiliary_get_drvdata(auxdev); 490 bus = &sdw->cdns.bus; 491 492 if (bus->prop.hw_disabled || !sdw->startup_done) { 493 dev_dbg(dev, "SoundWire master %d is disabled or not-started, ignoring\n", 494 bus->link_id); 495 return 0; 496 } 497 498 if (!sdw_intel_shim_check_wake(sdw)) 499 return 0; 500 501 /* disable WAKEEN interrupt ASAP to prevent interrupt flood */ 502 sdw_intel_shim_wake(sdw, false); 503 504 /* 505 * resume the Master, which will generate a bus reset and result in 506 * Slaves re-attaching and be re-enumerated. The SoundWire physical 507 * device which generated the wake will trigger an interrupt, which 508 * will in turn cause the corresponding Linux Slave device to be 509 * resumed and the Slave codec driver to check the status. 510 */ 511 pm_request_resume(dev); 512 513 return 0; 514 } 515 516 /* 517 * PM calls 518 */ 519 520 int intel_resume_child_device(struct device *dev, void *data) 521 { 522 int ret; 523 struct sdw_slave *slave = dev_to_sdw_dev(dev); 524 525 if (!slave->probed) { 526 dev_dbg(dev, "skipping device, no probed driver\n"); 527 return 0; 528 } 529 if (!slave->dev_num_sticky) { 530 dev_dbg(dev, "skipping device, never detected on bus\n"); 531 return 0; 532 } 533 534 ret = pm_runtime_resume(dev); 535 if (ret < 0) { 536 dev_err(dev, "%s: pm_runtime_resume failed: %d\n", __func__, ret); 537 return ret; 538 } 539 540 return 0; 541 } 542 543 static int __maybe_unused intel_pm_prepare(struct device *dev) 544 { 545 struct sdw_cdns *cdns = dev_get_drvdata(dev); 546 struct sdw_intel *sdw = cdns_to_intel(cdns); 547 struct sdw_bus *bus = &cdns->bus; 548 u32 clock_stop_quirks; 549 int ret; 550 551 if (bus->prop.hw_disabled || !sdw->startup_done) { 552 dev_dbg(dev, "SoundWire master %d is disabled or not-started, ignoring\n", 553 bus->link_id); 554 return 0; 555 } 556 557 clock_stop_quirks = sdw->link_res->clock_stop_quirks; 558 559 if (pm_runtime_suspended(dev) && 560 pm_runtime_suspended(dev->parent) && 561 ((clock_stop_quirks & SDW_INTEL_CLK_STOP_BUS_RESET) || 562 !clock_stop_quirks)) { 563 /* 564 * if we've enabled clock stop, and the parent is suspended, the SHIM registers 565 * are not accessible and the shim wake cannot be disabled. 566 * The only solution is to resume the entire bus to full power 567 */ 568 569 /* 570 * If any operation in this block fails, we keep going since we don't want 571 * to prevent system suspend from happening and errors should be recoverable 572 * on resume. 573 */ 574 575 /* 576 * first resume the device for this link. This will also by construction 577 * resume the PCI parent device. 578 */ 579 ret = pm_runtime_resume(dev); 580 if (ret < 0) { 581 dev_err(dev, "%s: pm_runtime_resume failed: %d\n", __func__, ret); 582 return 0; 583 } 584 585 /* 586 * Continue resuming the entire bus (parent + child devices) to exit 587 * the clock stop mode. If there are no devices connected on this link 588 * this is a no-op. 589 * The resume to full power could have been implemented with a .prepare 590 * step in SoundWire codec drivers. This would however require a lot 591 * of code to handle an Intel-specific corner case. It is simpler in 592 * practice to add a loop at the link level. 593 */ 594 ret = device_for_each_child(bus->dev, NULL, intel_resume_child_device); 595 596 if (ret < 0) 597 dev_err(dev, "%s: intel_resume_child_device failed: %d\n", __func__, ret); 598 } 599 600 return 0; 601 } 602 603 static int __maybe_unused intel_suspend(struct device *dev) 604 { 605 struct sdw_cdns *cdns = dev_get_drvdata(dev); 606 struct sdw_intel *sdw = cdns_to_intel(cdns); 607 struct sdw_bus *bus = &cdns->bus; 608 u32 clock_stop_quirks; 609 int ret; 610 611 if (bus->prop.hw_disabled || !sdw->startup_done) { 612 dev_dbg(dev, "SoundWire master %d is disabled or not-started, ignoring\n", 613 bus->link_id); 614 return 0; 615 } 616 617 if (pm_runtime_suspended(dev)) { 618 dev_dbg(dev, "pm_runtime status: suspended\n"); 619 620 clock_stop_quirks = sdw->link_res->clock_stop_quirks; 621 622 if ((clock_stop_quirks & SDW_INTEL_CLK_STOP_BUS_RESET) || 623 !clock_stop_quirks) { 624 625 if (pm_runtime_suspended(dev->parent)) { 626 /* 627 * paranoia check: this should not happen with the .prepare 628 * resume to full power 629 */ 630 dev_err(dev, "%s: invalid config: parent is suspended\n", __func__); 631 } else { 632 sdw_intel_shim_wake(sdw, false); 633 } 634 } 635 636 return 0; 637 } 638 639 ret = sdw_intel_stop_bus(sdw, false); 640 if (ret < 0) { 641 dev_err(dev, "%s: cannot stop bus: %d\n", __func__, ret); 642 return ret; 643 } 644 645 return 0; 646 } 647 648 static int __maybe_unused intel_suspend_runtime(struct device *dev) 649 { 650 struct sdw_cdns *cdns = dev_get_drvdata(dev); 651 struct sdw_intel *sdw = cdns_to_intel(cdns); 652 struct sdw_bus *bus = &cdns->bus; 653 u32 clock_stop_quirks; 654 int ret; 655 656 if (bus->prop.hw_disabled || !sdw->startup_done) { 657 dev_dbg(dev, "SoundWire master %d is disabled or not-started, ignoring\n", 658 bus->link_id); 659 return 0; 660 } 661 662 clock_stop_quirks = sdw->link_res->clock_stop_quirks; 663 664 if (clock_stop_quirks & SDW_INTEL_CLK_STOP_TEARDOWN) { 665 ret = sdw_intel_stop_bus(sdw, false); 666 if (ret < 0) { 667 dev_err(dev, "%s: cannot stop bus during teardown: %d\n", 668 __func__, ret); 669 return ret; 670 } 671 } else if (clock_stop_quirks & SDW_INTEL_CLK_STOP_BUS_RESET || !clock_stop_quirks) { 672 ret = sdw_intel_stop_bus(sdw, true); 673 if (ret < 0) { 674 dev_err(dev, "%s: cannot stop bus during clock_stop: %d\n", 675 __func__, ret); 676 return ret; 677 } 678 } else { 679 dev_err(dev, "%s clock_stop_quirks %x unsupported\n", 680 __func__, clock_stop_quirks); 681 ret = -EINVAL; 682 } 683 684 return ret; 685 } 686 687 static int __maybe_unused intel_resume(struct device *dev) 688 { 689 struct sdw_cdns *cdns = dev_get_drvdata(dev); 690 struct sdw_intel *sdw = cdns_to_intel(cdns); 691 struct sdw_bus *bus = &cdns->bus; 692 int link_flags; 693 int ret; 694 695 if (bus->prop.hw_disabled || !sdw->startup_done) { 696 dev_dbg(dev, "SoundWire master %d is disabled or not-started, ignoring\n", 697 bus->link_id); 698 return 0; 699 } 700 701 if (pm_runtime_suspended(dev)) { 702 dev_dbg(dev, "pm_runtime status was suspended, forcing active\n"); 703 704 /* follow required sequence from runtime_pm.rst */ 705 pm_runtime_disable(dev); 706 pm_runtime_set_active(dev); 707 pm_runtime_mark_last_busy(dev); 708 pm_runtime_enable(dev); 709 710 pm_runtime_resume(bus->dev); 711 712 link_flags = md_flags >> (bus->link_id * 8); 713 714 if (!(link_flags & SDW_INTEL_MASTER_DISABLE_PM_RUNTIME_IDLE)) 715 pm_runtime_idle(dev); 716 } 717 718 ret = sdw_intel_link_power_up(sdw); 719 if (ret) { 720 dev_err(dev, "%s failed: %d\n", __func__, ret); 721 return ret; 722 } 723 724 /* 725 * make sure all Slaves are tagged as UNATTACHED and provide 726 * reason for reinitialization 727 */ 728 sdw_clear_slave_status(bus, SDW_UNATTACH_REQUEST_MASTER_RESET); 729 730 ret = sdw_intel_start_bus(sdw); 731 if (ret < 0) { 732 dev_err(dev, "cannot start bus during resume\n"); 733 sdw_intel_link_power_down(sdw); 734 return ret; 735 } 736 737 /* 738 * after system resume, the pm_runtime suspend() may kick in 739 * during the enumeration, before any children device force the 740 * master device to remain active. Using pm_runtime_get() 741 * routines is not really possible, since it'd prevent the 742 * master from suspending. 743 * A reasonable compromise is to update the pm_runtime 744 * counters and delay the pm_runtime suspend by several 745 * seconds, by when all enumeration should be complete. 746 */ 747 pm_runtime_mark_last_busy(bus->dev); 748 pm_runtime_mark_last_busy(dev); 749 750 return 0; 751 } 752 753 static int __maybe_unused intel_resume_runtime(struct device *dev) 754 { 755 struct sdw_cdns *cdns = dev_get_drvdata(dev); 756 struct sdw_intel *sdw = cdns_to_intel(cdns); 757 struct sdw_bus *bus = &cdns->bus; 758 u32 clock_stop_quirks; 759 int ret; 760 761 if (bus->prop.hw_disabled || !sdw->startup_done) { 762 dev_dbg(dev, "SoundWire master %d is disabled or not-started, ignoring\n", 763 bus->link_id); 764 return 0; 765 } 766 767 /* unconditionally disable WAKEEN interrupt */ 768 sdw_intel_shim_wake(sdw, false); 769 770 clock_stop_quirks = sdw->link_res->clock_stop_quirks; 771 772 if (clock_stop_quirks & SDW_INTEL_CLK_STOP_TEARDOWN) { 773 ret = sdw_intel_link_power_up(sdw); 774 if (ret) { 775 dev_err(dev, "%s: power_up failed after teardown: %d\n", __func__, ret); 776 return ret; 777 } 778 779 /* 780 * make sure all Slaves are tagged as UNATTACHED and provide 781 * reason for reinitialization 782 */ 783 sdw_clear_slave_status(bus, SDW_UNATTACH_REQUEST_MASTER_RESET); 784 785 ret = sdw_intel_start_bus(sdw); 786 if (ret < 0) { 787 dev_err(dev, "%s: cannot start bus after teardown: %d\n", __func__, ret); 788 sdw_intel_link_power_down(sdw); 789 return ret; 790 } 791 792 } else if (clock_stop_quirks & SDW_INTEL_CLK_STOP_BUS_RESET) { 793 ret = sdw_intel_link_power_up(sdw); 794 if (ret) { 795 dev_err(dev, "%s: power_up failed after bus reset: %d\n", __func__, ret); 796 return ret; 797 } 798 799 ret = sdw_intel_start_bus_after_reset(sdw); 800 if (ret < 0) { 801 dev_err(dev, "%s: cannot start bus after reset: %d\n", __func__, ret); 802 sdw_intel_link_power_down(sdw); 803 return ret; 804 } 805 } else if (!clock_stop_quirks) { 806 807 sdw_intel_check_clock_stop(sdw); 808 809 ret = sdw_intel_link_power_up(sdw); 810 if (ret) { 811 dev_err(dev, "%s: power_up failed: %d\n", __func__, ret); 812 return ret; 813 } 814 815 ret = sdw_intel_start_bus_after_clock_stop(sdw); 816 if (ret < 0) { 817 dev_err(dev, "%s: cannot start bus after clock stop: %d\n", __func__, ret); 818 sdw_intel_link_power_down(sdw); 819 return ret; 820 } 821 } else { 822 dev_err(dev, "%s: clock_stop_quirks %x unsupported\n", 823 __func__, clock_stop_quirks); 824 ret = -EINVAL; 825 } 826 827 return ret; 828 } 829 830 static const struct dev_pm_ops intel_pm = { 831 .prepare = intel_pm_prepare, 832 SET_SYSTEM_SLEEP_PM_OPS(intel_suspend, intel_resume) 833 SET_RUNTIME_PM_OPS(intel_suspend_runtime, intel_resume_runtime, NULL) 834 }; 835 836 static const struct auxiliary_device_id intel_link_id_table[] = { 837 { .name = "soundwire_intel.link" }, 838 {}, 839 }; 840 MODULE_DEVICE_TABLE(auxiliary, intel_link_id_table); 841 842 static struct auxiliary_driver sdw_intel_drv = { 843 .probe = intel_link_probe, 844 .remove = intel_link_remove, 845 .driver = { 846 /* auxiliary_driver_register() sets .name to be the modname */ 847 .pm = &intel_pm, 848 }, 849 .id_table = intel_link_id_table 850 }; 851 module_auxiliary_driver(sdw_intel_drv); 852 853 MODULE_LICENSE("Dual BSD/GPL"); 854 MODULE_DESCRIPTION("Intel Soundwire Link Driver"); 855