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_bpt_send_async(struct sdw_bus *bus, struct sdw_slave *slave, 83 struct sdw_bpt_msg *msg) 84 { 85 struct sdw_cdns *cdns = bus_to_cdns(bus); 86 struct sdw_intel *sdw = cdns_to_intel(cdns); 87 88 if (sdw->link_res->hw_ops->bpt_send_async) 89 return sdw->link_res->hw_ops->bpt_send_async(sdw, slave, msg); 90 return -EOPNOTSUPP; 91 } 92 93 static int generic_bpt_wait(struct sdw_bus *bus, struct sdw_slave *slave, struct sdw_bpt_msg *msg) 94 { 95 struct sdw_cdns *cdns = bus_to_cdns(bus); 96 struct sdw_intel *sdw = cdns_to_intel(cdns); 97 98 if (sdw->link_res->hw_ops->bpt_wait) 99 return sdw->link_res->hw_ops->bpt_wait(sdw, slave, msg); 100 return -EOPNOTSUPP; 101 } 102 103 static int generic_pre_bank_switch(struct sdw_bus *bus) 104 { 105 struct sdw_cdns *cdns = bus_to_cdns(bus); 106 struct sdw_intel *sdw = cdns_to_intel(cdns); 107 108 return sdw->link_res->hw_ops->pre_bank_switch(sdw); 109 } 110 111 static int generic_post_bank_switch(struct sdw_bus *bus) 112 { 113 struct sdw_cdns *cdns = bus_to_cdns(bus); 114 struct sdw_intel *sdw = cdns_to_intel(cdns); 115 116 return sdw->link_res->hw_ops->post_bank_switch(sdw); 117 } 118 119 static void generic_new_peripheral_assigned(struct sdw_bus *bus, 120 struct sdw_slave *slave, 121 int dev_num) 122 { 123 struct sdw_cdns *cdns = bus_to_cdns(bus); 124 struct sdw_intel *sdw = cdns_to_intel(cdns); 125 int dev_num_min; 126 int dev_num_max; 127 bool wake_capable = slave->prop.wake_capable || is_wake_capable(slave); 128 129 if (wake_capable) { 130 dev_num_min = SDW_INTEL_DEV_NUM_IDA_MIN; 131 dev_num_max = SDW_MAX_DEVICES; 132 } else { 133 dev_num_min = 1; 134 dev_num_max = SDW_INTEL_DEV_NUM_IDA_MIN - 1; 135 } 136 137 /* paranoia check, this should never happen */ 138 if (dev_num < dev_num_min || dev_num > dev_num_max) { 139 dev_err(bus->dev, "%s: invalid dev_num %d, wake supported %d\n", 140 __func__, dev_num, slave->prop.wake_capable); 141 return; 142 } 143 144 if (sdw->link_res->hw_ops->program_sdi && wake_capable) 145 sdw->link_res->hw_ops->program_sdi(sdw, dev_num); 146 } 147 148 static int sdw_master_read_intel_prop(struct sdw_bus *bus) 149 { 150 struct sdw_master_prop *prop = &bus->prop; 151 struct sdw_intel_prop *intel_prop; 152 struct fwnode_handle *link; 153 char name[32]; 154 u32 quirk_mask; 155 156 /* Find master handle */ 157 snprintf(name, sizeof(name), 158 "mipi-sdw-link-%d-subproperties", bus->link_id); 159 160 link = device_get_named_child_node(bus->dev, name); 161 if (!link) { 162 dev_err(bus->dev, "Master node %s not found\n", name); 163 return -EIO; 164 } 165 166 fwnode_property_read_u32(link, 167 "intel-sdw-ip-clock", 168 &prop->mclk_freq); 169 170 if (mclk_divider) 171 /* use kernel parameter for BIOS or board work-arounds */ 172 prop->mclk_freq /= mclk_divider; 173 else 174 /* the values reported by BIOS are the 2x clock, not the bus clock */ 175 prop->mclk_freq /= 2; 176 177 fwnode_property_read_u32(link, 178 "intel-quirk-mask", 179 &quirk_mask); 180 181 if (quirk_mask & SDW_INTEL_QUIRK_MASK_BUS_DISABLE) 182 prop->hw_disabled = true; 183 184 prop->quirks = SDW_MASTER_QUIRKS_CLEAR_INITIAL_CLASH | 185 SDW_MASTER_QUIRKS_CLEAR_INITIAL_PARITY; 186 187 intel_prop = devm_kzalloc(bus->dev, sizeof(*intel_prop), GFP_KERNEL); 188 if (!intel_prop) { 189 fwnode_handle_put(link); 190 return -ENOMEM; 191 } 192 193 /* initialize with hardware defaults, in case the properties are not found */ 194 intel_prop->clde = 0x0; 195 intel_prop->doaise2 = 0x0; 196 intel_prop->dodse2 = 0x0; 197 intel_prop->clds = 0x0; 198 intel_prop->clss = 0x0; 199 intel_prop->doaise = 0x1; 200 intel_prop->doais = 0x3; 201 intel_prop->dodse = 0x0; 202 intel_prop->dods = 0x1; 203 204 fwnode_property_read_u16(link, 205 "intel-sdw-clde", 206 &intel_prop->clde); 207 fwnode_property_read_u16(link, 208 "intel-sdw-doaise2", 209 &intel_prop->doaise2); 210 fwnode_property_read_u16(link, 211 "intel-sdw-dodse2", 212 &intel_prop->dodse2); 213 fwnode_property_read_u16(link, 214 "intel-sdw-clds", 215 &intel_prop->clds); 216 fwnode_property_read_u16(link, 217 "intel-sdw-clss", 218 &intel_prop->clss); 219 fwnode_property_read_u16(link, 220 "intel-sdw-doaise", 221 &intel_prop->doaise); 222 fwnode_property_read_u16(link, 223 "intel-sdw-doais", 224 &intel_prop->doais); 225 fwnode_property_read_u16(link, 226 "intel-sdw-dodse", 227 &intel_prop->dodse); 228 fwnode_property_read_u16(link, 229 "intel-sdw-dods", 230 &intel_prop->dods); 231 bus->vendor_specific_prop = intel_prop; 232 233 dev_dbg(bus->dev, "doaise %#x doais %#x dodse %#x dods %#x\n", 234 intel_prop->doaise, 235 intel_prop->doais, 236 intel_prop->dodse, 237 intel_prop->dods); 238 239 fwnode_handle_put(link); 240 241 return 0; 242 } 243 244 static int intel_prop_read(struct sdw_bus *bus) 245 { 246 /* Initialize with default handler to read all DisCo properties */ 247 sdw_master_read_prop(bus); 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 .bpt_send_async = generic_bpt_send_async, 293 .bpt_wait = generic_bpt_wait, 294 }; 295 296 /* 297 * probe and init (aux_dev_id argument is required by function prototype but not used) 298 */ 299 static int intel_link_probe(struct auxiliary_device *auxdev, 300 const struct auxiliary_device_id *aux_dev_id) 301 302 { 303 struct device *dev = &auxdev->dev; 304 struct sdw_intel_link_dev *ldev = auxiliary_dev_to_sdw_intel_link_dev(auxdev); 305 struct sdw_intel *sdw; 306 struct sdw_cdns *cdns; 307 struct sdw_bus *bus; 308 int ret; 309 310 sdw = devm_kzalloc(dev, sizeof(*sdw), GFP_KERNEL); 311 if (!sdw) 312 return -ENOMEM; 313 314 cdns = &sdw->cdns; 315 bus = &cdns->bus; 316 317 sdw->instance = auxdev->id; 318 sdw->link_res = &ldev->link_res; 319 cdns->dev = dev; 320 cdns->registers = sdw->link_res->registers; 321 cdns->ip_offset = sdw->link_res->ip_offset; 322 cdns->instance = sdw->instance; 323 cdns->msg_count = 0; 324 325 /* single controller for all SoundWire links */ 326 bus->controller_id = 0; 327 328 bus->link_id = auxdev->id; 329 bus->clk_stop_timeout = 1; 330 331 /* 332 * paranoia check: make sure ACPI-reported number of links is aligned with 333 * hardware capabilities. 334 */ 335 ret = sdw_intel_get_link_count(sdw); 336 if (ret < 0) { 337 dev_err(dev, "%s: sdw_intel_get_link_count failed: %d\n", __func__, ret); 338 return ret; 339 } 340 if (ret <= sdw->instance) { 341 dev_err(dev, "%s: invalid link id %d, link count %d\n", __func__, auxdev->id, ret); 342 return -EINVAL; 343 } 344 345 sdw_cdns_probe(cdns); 346 347 /* Set ops */ 348 bus->ops = &sdw_intel_ops; 349 350 /* set driver data, accessed by snd_soc_dai_get_drvdata() */ 351 auxiliary_set_drvdata(auxdev, cdns); 352 353 /* use generic bandwidth allocation algorithm */ 354 sdw->cdns.bus.compute_params = sdw_compute_params; 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 /* Prevent runtime PM from racing with the code below. */ 641 pm_runtime_disable(dev); 642 643 if (pm_runtime_status_suspended(dev)) { 644 dev_dbg(dev, "pm_runtime status: suspended\n"); 645 646 clock_stop_quirks = sdw->link_res->clock_stop_quirks; 647 648 if ((clock_stop_quirks & SDW_INTEL_CLK_STOP_BUS_RESET) || 649 !clock_stop_quirks) { 650 651 if (pm_runtime_status_suspended(dev->parent)) { 652 /* 653 * paranoia check: this should not happen with the .prepare 654 * resume to full power 655 */ 656 dev_err(dev, "%s: invalid config: parent is suspended\n", __func__); 657 } else { 658 sdw_intel_shim_wake(sdw, false); 659 } 660 } 661 662 return 0; 663 } 664 665 ret = sdw_intel_stop_bus(sdw, false); 666 if (ret < 0) { 667 dev_err(dev, "%s: cannot stop bus: %d\n", __func__, ret); 668 return ret; 669 } 670 671 return 0; 672 } 673 674 static int __maybe_unused intel_suspend_runtime(struct device *dev) 675 { 676 struct sdw_cdns *cdns = dev_get_drvdata(dev); 677 struct sdw_intel *sdw = cdns_to_intel(cdns); 678 struct sdw_bus *bus = &cdns->bus; 679 u32 clock_stop_quirks; 680 int ret; 681 682 if (bus->prop.hw_disabled || !sdw->startup_done) { 683 dev_dbg(dev, "SoundWire master %d is disabled or not-started, ignoring\n", 684 bus->link_id); 685 return 0; 686 } 687 688 clock_stop_quirks = sdw->link_res->clock_stop_quirks; 689 690 if (clock_stop_quirks & SDW_INTEL_CLK_STOP_TEARDOWN) { 691 ret = sdw_intel_stop_bus(sdw, false); 692 if (ret < 0) { 693 dev_err(dev, "%s: cannot stop bus during teardown: %d\n", 694 __func__, ret); 695 return ret; 696 } 697 } else if (clock_stop_quirks & SDW_INTEL_CLK_STOP_BUS_RESET || !clock_stop_quirks) { 698 ret = sdw_intel_stop_bus(sdw, true); 699 if (ret < 0) { 700 dev_err(dev, "%s: cannot stop bus during clock_stop: %d\n", 701 __func__, ret); 702 return ret; 703 } 704 } else { 705 dev_err(dev, "%s clock_stop_quirks %x unsupported\n", 706 __func__, clock_stop_quirks); 707 ret = -EINVAL; 708 } 709 710 return ret; 711 } 712 713 static int __maybe_unused intel_resume(struct device *dev) 714 { 715 struct sdw_cdns *cdns = dev_get_drvdata(dev); 716 struct sdw_intel *sdw = cdns_to_intel(cdns); 717 struct sdw_bus *bus = &cdns->bus; 718 int ret; 719 720 if (bus->prop.hw_disabled || !sdw->startup_done) { 721 dev_dbg(dev, "SoundWire master %d is disabled or not-started, ignoring\n", 722 bus->link_id); 723 return 0; 724 } 725 726 ret = sdw_intel_link_power_up(sdw); 727 if (ret) { 728 dev_err(dev, "%s failed: %d\n", __func__, ret); 729 return ret; 730 } 731 732 /* 733 * make sure all Slaves are tagged as UNATTACHED and provide 734 * reason for reinitialization 735 */ 736 sdw_clear_slave_status(bus, SDW_UNATTACH_REQUEST_MASTER_RESET); 737 738 ret = sdw_intel_start_bus(sdw); 739 if (ret < 0) { 740 dev_err(dev, "cannot start bus during resume\n"); 741 sdw_intel_link_power_down(sdw); 742 return ret; 743 } 744 745 /* 746 * Runtime PM has been disabled in intel_suspend(), so set the status 747 * to active because the device has just been resumed and re-enable 748 * runtime PM. 749 */ 750 pm_runtime_set_active(dev); 751 pm_runtime_enable(dev); 752 753 /* 754 * after system resume, the pm_runtime suspend() may kick in 755 * during the enumeration, before any children device force the 756 * master device to remain active. Using pm_runtime_get() 757 * routines is not really possible, since it'd prevent the 758 * master from suspending. 759 * A reasonable compromise is to update the pm_runtime 760 * counters and delay the pm_runtime suspend by several 761 * seconds, by when all enumeration should be complete. 762 */ 763 pm_runtime_mark_last_busy(bus->dev); 764 pm_runtime_mark_last_busy(dev); 765 766 return 0; 767 } 768 769 static int __maybe_unused intel_resume_runtime(struct device *dev) 770 { 771 struct sdw_cdns *cdns = dev_get_drvdata(dev); 772 struct sdw_intel *sdw = cdns_to_intel(cdns); 773 struct sdw_bus *bus = &cdns->bus; 774 u32 clock_stop_quirks; 775 int ret; 776 777 if (bus->prop.hw_disabled || !sdw->startup_done) { 778 dev_dbg(dev, "SoundWire master %d is disabled or not-started, ignoring\n", 779 bus->link_id); 780 return 0; 781 } 782 783 /* unconditionally disable WAKEEN interrupt */ 784 sdw_intel_shim_wake(sdw, false); 785 786 clock_stop_quirks = sdw->link_res->clock_stop_quirks; 787 788 if (clock_stop_quirks & SDW_INTEL_CLK_STOP_TEARDOWN) { 789 ret = sdw_intel_link_power_up(sdw); 790 if (ret) { 791 dev_err(dev, "%s: power_up failed after teardown: %d\n", __func__, ret); 792 return ret; 793 } 794 795 /* 796 * make sure all Slaves are tagged as UNATTACHED and provide 797 * reason for reinitialization 798 */ 799 sdw_clear_slave_status(bus, SDW_UNATTACH_REQUEST_MASTER_RESET); 800 801 ret = sdw_intel_start_bus(sdw); 802 if (ret < 0) { 803 dev_err(dev, "%s: cannot start bus after teardown: %d\n", __func__, ret); 804 sdw_intel_link_power_down(sdw); 805 return ret; 806 } 807 808 } else if (clock_stop_quirks & SDW_INTEL_CLK_STOP_BUS_RESET) { 809 ret = sdw_intel_link_power_up(sdw); 810 if (ret) { 811 dev_err(dev, "%s: power_up failed after bus reset: %d\n", __func__, ret); 812 return ret; 813 } 814 815 ret = sdw_intel_start_bus_after_reset(sdw); 816 if (ret < 0) { 817 dev_err(dev, "%s: cannot start bus after reset: %d\n", __func__, ret); 818 sdw_intel_link_power_down(sdw); 819 return ret; 820 } 821 } else if (!clock_stop_quirks) { 822 823 sdw_intel_check_clock_stop(sdw); 824 825 ret = sdw_intel_link_power_up(sdw); 826 if (ret) { 827 dev_err(dev, "%s: power_up failed: %d\n", __func__, ret); 828 return ret; 829 } 830 831 ret = sdw_intel_start_bus_after_clock_stop(sdw); 832 if (ret < 0) { 833 dev_err(dev, "%s: cannot start bus after clock stop: %d\n", __func__, ret); 834 sdw_intel_link_power_down(sdw); 835 return ret; 836 } 837 } else { 838 dev_err(dev, "%s: clock_stop_quirks %x unsupported\n", 839 __func__, clock_stop_quirks); 840 ret = -EINVAL; 841 } 842 843 return ret; 844 } 845 846 static const struct dev_pm_ops intel_pm = { 847 .prepare = intel_pm_prepare, 848 SET_SYSTEM_SLEEP_PM_OPS(intel_suspend, intel_resume) 849 SET_RUNTIME_PM_OPS(intel_suspend_runtime, intel_resume_runtime, NULL) 850 }; 851 852 static const struct auxiliary_device_id intel_link_id_table[] = { 853 { .name = "soundwire_intel.link" }, 854 {}, 855 }; 856 MODULE_DEVICE_TABLE(auxiliary, intel_link_id_table); 857 858 static struct auxiliary_driver sdw_intel_drv = { 859 .probe = intel_link_probe, 860 .remove = intel_link_remove, 861 .driver = { 862 /* auxiliary_driver_register() sets .name to be the modname */ 863 .pm = &intel_pm, 864 }, 865 .id_table = intel_link_id_table 866 }; 867 module_auxiliary_driver(sdw_intel_drv); 868 869 MODULE_LICENSE("Dual BSD/GPL"); 870 MODULE_DESCRIPTION("Intel Soundwire Link Driver"); 871