1 // SPDX-License-Identifier: GPL-2.0-only 2 // 3 // rt721-sdca-sdw.c -- rt721 SDCA ALSA SoC audio driver 4 // 5 // Copyright(c) 2024 Realtek Semiconductor Corp. 6 // 7 // 8 9 #include <linux/cleanup.h> 10 #include <linux/delay.h> 11 #include <linux/device.h> 12 #include <linux/module.h> 13 #include <linux/pm_runtime.h> 14 #include <linux/soundwire/sdw_registers.h> 15 16 #include "rt721-sdca.h" 17 #include "rt721-sdca-sdw.h" 18 #include "rt-sdw-common.h" 19 20 static bool rt721_sdca_readable_register(struct device *dev, unsigned int reg) 21 { 22 switch (reg) { 23 case 0x2f01 ... 0x2f0a: 24 case 0x2f35: 25 case 0x2f50: 26 case 0x2f51: 27 case 0x2f58 ... 0x2f5d: 28 case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT0, 29 RT721_SDCA_CTL_FUNC_STATUS, 0): 30 case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_XUV, 31 RT721_SDCA_CTL_XUV, 0): 32 case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_GE49, 33 RT721_SDCA_CTL_SELECTED_MODE, 0): 34 case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_GE49, 35 RT721_SDCA_CTL_DETECTED_MODE, 0): 36 case SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT721_SDCA_ENT0, 37 RT721_SDCA_CTL_FUNC_STATUS, 0): 38 case SDW_SDCA_CTL(FUNC_NUM_HID, RT721_SDCA_ENT_HID01, 39 RT721_SDCA_CTL_HIDTX_CURRENT_OWNER, 0) ... SDW_SDCA_CTL(FUNC_NUM_HID, 40 RT721_SDCA_ENT_HID01, RT721_SDCA_CTL_HIDTX_MESSAGE_LENGTH, 0): 41 case RT721_BUF_ADDR_HID1 ... RT721_BUF_ADDR_HID2: 42 case SDW_SDCA_CTL(FUNC_NUM_AMP, RT721_SDCA_ENT0, 43 RT721_SDCA_CTL_FUNC_STATUS, 0): 44 return true; 45 default: 46 return false; 47 } 48 } 49 50 static bool rt721_sdca_volatile_register(struct device *dev, unsigned int reg) 51 { 52 switch (reg) { 53 case 0x2f01: 54 case 0x2f51: 55 case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT0, 56 RT721_SDCA_CTL_FUNC_STATUS, 0): 57 case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_GE49, 58 RT721_SDCA_CTL_DETECTED_MODE, 0): 59 case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_XUV, 60 RT721_SDCA_CTL_XUV, 0): 61 case SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT721_SDCA_ENT0, 62 RT721_SDCA_CTL_FUNC_STATUS, 0): 63 case SDW_SDCA_CTL(FUNC_NUM_HID, RT721_SDCA_ENT_HID01, 64 RT721_SDCA_CTL_HIDTX_CURRENT_OWNER, 0) ... SDW_SDCA_CTL(FUNC_NUM_HID, 65 RT721_SDCA_ENT_HID01, RT721_SDCA_CTL_HIDTX_MESSAGE_LENGTH, 0): 66 case RT721_BUF_ADDR_HID1 ... RT721_BUF_ADDR_HID2: 67 case SDW_SDCA_CTL(FUNC_NUM_AMP, RT721_SDCA_ENT0, 68 RT721_SDCA_CTL_FUNC_STATUS, 0): 69 return true; 70 default: 71 return false; 72 } 73 } 74 75 static bool rt721_sdca_mbq_readable_register(struct device *dev, unsigned int reg) 76 { 77 switch (reg) { 78 case 0x0900004 ... 0x0900009: 79 case 0x0910000: 80 case 0x0910001: 81 case 0x0910002: 82 case 0x0910003: 83 case 0x0910202: 84 case 0x0a00005: 85 case 0x0c00005: 86 case 0x0d00014: 87 case 0x0f00004: 88 case 0x0f00005: 89 case 0x0310100: 90 case 0x2000000 ... 0x2000003: 91 case 0x2000013: 92 case 0x2000026: 93 case 0x200002c: 94 case 0x200003c: 95 case 0x5810000: 96 case 0x5810033: 97 case 0x5810036: 98 case 0x5810037: 99 case 0x5810038: 100 case 0x5810039: 101 case 0x581003a: 102 case 0x581003b: 103 case 0x5810100: 104 case 0x5b10000 ... 0x5b10026: 105 case 0x5b10100 ... 0x5b10103: 106 case 0x5f00010: 107 case 0x5f00043: 108 case 0x5f00045: 109 case 0x5f00048: 110 case 0x6100000: 111 case 0x6100002: 112 case 0x6100005: 113 case 0x6100006: 114 case 0x6100007: 115 case 0x610000d: 116 case 0x6100010: 117 case 0x6100011: 118 case 0x6100013: 119 case 0x6100015: 120 case 0x6100017: 121 case 0x6100025: 122 case 0x6100029: 123 case 0x610002c ... 0x610002f: 124 case 0x6100053 ... 0x6100055: 125 case 0x6100057: 126 case 0x610005a: 127 case 0x610005b: 128 case 0x610006a: 129 case 0x610006d: 130 case 0x6100092: 131 case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_USER_FU05, RT721_SDCA_CTL_FU_VOLUME, 132 CH_L): 133 case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_USER_FU05, RT721_SDCA_CTL_FU_VOLUME, 134 CH_R): 135 case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_USER_FU0F, RT721_SDCA_CTL_FU_VOLUME, 136 CH_L): 137 case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_USER_FU0F, RT721_SDCA_CTL_FU_VOLUME, 138 CH_R): 139 case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_PLATFORM_FU44, 140 RT721_SDCA_CTL_FU_CH_GAIN, CH_L): 141 case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_PLATFORM_FU44, 142 RT721_SDCA_CTL_FU_CH_GAIN, CH_R): 143 case SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT721_SDCA_ENT_USER_FU1E, RT721_SDCA_CTL_FU_VOLUME, 144 CH_01): 145 case SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT721_SDCA_ENT_USER_FU1E, RT721_SDCA_CTL_FU_VOLUME, 146 CH_02): 147 case SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT721_SDCA_ENT_USER_FU1E, RT721_SDCA_CTL_FU_VOLUME, 148 CH_03): 149 case SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT721_SDCA_ENT_USER_FU1E, RT721_SDCA_CTL_FU_VOLUME, 150 CH_04): 151 case SDW_SDCA_CTL(FUNC_NUM_AMP, RT721_SDCA_ENT_USER_FU06, RT721_SDCA_CTL_FU_VOLUME, CH_L): 152 case SDW_SDCA_CTL(FUNC_NUM_AMP, RT721_SDCA_ENT_USER_FU06, RT721_SDCA_CTL_FU_VOLUME, CH_R): 153 return true; 154 default: 155 return false; 156 } 157 } 158 159 static bool rt721_sdca_mbq_volatile_register(struct device *dev, unsigned int reg) 160 { 161 switch (reg) { 162 case 0x0310100: 163 case 0x0900005: 164 case 0x0900009: 165 case 0x0a00005: 166 case 0x0c00005: 167 case 0x0d00014: 168 case 0x0f00004: 169 case 0x2000000: 170 case 0x200000d: 171 case 0x2000019: 172 case 0x2000020: 173 case 0x2000026: 174 case 0x200002c: 175 case 0x2000030: 176 case 0x2000067: 177 case 0x2000084: 178 case 0x2000086: 179 case 0x5810000: 180 case 0x5810036: 181 case 0x5810037: 182 case 0x5810038: 183 case 0x5810039: 184 case 0x581003a: 185 case 0x581003b: 186 case 0x5810100: 187 case 0x5b10000 ... 0x5b10016: 188 case 0x5b10018 ... 0x5b10026: 189 case 0x6100006: 190 return true; 191 default: 192 return false; 193 } 194 } 195 196 static const struct regmap_config rt721_sdca_regmap = { 197 .reg_bits = 32, 198 .val_bits = 8, 199 .readable_reg = rt721_sdca_readable_register, 200 .volatile_reg = rt721_sdca_volatile_register, 201 .max_register = 0x44ffffff, 202 .reg_defaults = rt721_sdca_reg_defaults, 203 .num_reg_defaults = ARRAY_SIZE(rt721_sdca_reg_defaults), 204 .cache_type = REGCACHE_MAPLE, 205 .use_single_read = true, 206 .use_single_write = true, 207 }; 208 209 static const struct regmap_config rt721_sdca_mbq_regmap = { 210 .name = "sdw-mbq", 211 .reg_bits = 32, 212 .val_bits = 16, 213 .readable_reg = rt721_sdca_mbq_readable_register, 214 .volatile_reg = rt721_sdca_mbq_volatile_register, 215 .max_register = 0x41000312, 216 .reg_defaults = rt721_sdca_mbq_defaults, 217 .num_reg_defaults = ARRAY_SIZE(rt721_sdca_mbq_defaults), 218 .cache_type = REGCACHE_MAPLE, 219 .use_single_read = true, 220 .use_single_write = true, 221 }; 222 223 static int rt721_sdca_update_status(struct sdw_slave *slave, 224 enum sdw_slave_status status) 225 { 226 struct rt721_sdca_priv *rt721 = dev_get_drvdata(&slave->dev); 227 228 if (status == SDW_SLAVE_UNATTACHED) 229 rt721->hw_init = false; 230 231 if (status == SDW_SLAVE_ATTACHED) { 232 if (rt721->hs_jack) { 233 /* 234 * Due to the SCP_SDCA_INTMASK will be cleared by any reset, and then 235 * if the device attached again, we will need to set the setting back. 236 * It could avoid losing the jack detection interrupt. 237 * This also could sync with the cache value as the rt721_sdca_jack_init set. 238 */ 239 sdw_write_no_pm(rt721->slave, SDW_SCP_SDCA_INTMASK1, 240 SDW_SCP_SDCA_INTMASK_SDCA_0); 241 sdw_write_no_pm(rt721->slave, SDW_SCP_SDCA_INTMASK2, 242 SDW_SCP_SDCA_INTMASK_SDCA_8); 243 } 244 } 245 246 /* 247 * Perform initialization only if slave status is present and 248 * hw_init flag is false 249 */ 250 if (rt721->hw_init || status != SDW_SLAVE_ATTACHED) 251 return 0; 252 253 /* perform I/O transfers required for Slave initialization */ 254 return rt721_sdca_io_init(&slave->dev, slave); 255 } 256 257 static int rt721_sdca_read_prop(struct sdw_slave *slave) 258 { 259 struct sdw_slave_prop *prop = &slave->prop; 260 int nval; 261 int i, j; 262 u32 bit; 263 unsigned long addr; 264 struct sdw_dpn_prop *dpn; 265 266 sdw_slave_read_prop(slave); 267 prop->scp_int1_mask = SDW_SCP_INT1_BUS_CLASH | SDW_SCP_INT1_PARITY; 268 prop->quirks = SDW_SLAVE_QUIRKS_INVALID_INITIAL_PARITY; 269 270 prop->paging_support = true; 271 272 /* 273 * port = 1 for headphone playback 274 * port = 2 for headset-mic capture 275 * port = 3 for speaker playback 276 * port = 6 for digital-mic capture 277 */ 278 prop->source_ports = BIT(6) | BIT(2); /* BITMAP: 01000100 */ 279 prop->sink_ports = BIT(3) | BIT(1); /* BITMAP: 00001010 */ 280 281 nval = hweight32(prop->source_ports); 282 prop->src_dpn_prop = devm_kcalloc(&slave->dev, nval, 283 sizeof(*prop->src_dpn_prop), GFP_KERNEL); 284 if (!prop->src_dpn_prop) 285 return -ENOMEM; 286 287 i = 0; 288 dpn = prop->src_dpn_prop; 289 addr = prop->source_ports; 290 for_each_set_bit(bit, &addr, 32) { 291 dpn[i].num = bit; 292 dpn[i].type = SDW_DPN_FULL; 293 dpn[i].simple_ch_prep_sm = true; 294 dpn[i].ch_prep_timeout = 10; 295 i++; 296 } 297 298 /* do this again for sink now */ 299 nval = hweight32(prop->sink_ports); 300 prop->sink_dpn_prop = devm_kcalloc(&slave->dev, nval, 301 sizeof(*prop->sink_dpn_prop), GFP_KERNEL); 302 if (!prop->sink_dpn_prop) 303 return -ENOMEM; 304 305 j = 0; 306 dpn = prop->sink_dpn_prop; 307 addr = prop->sink_ports; 308 for_each_set_bit(bit, &addr, 32) { 309 dpn[j].num = bit; 310 dpn[j].type = SDW_DPN_FULL; 311 dpn[j].simple_ch_prep_sm = true; 312 dpn[j].ch_prep_timeout = 10; 313 j++; 314 } 315 316 /* set the timeout values */ 317 prop->clk_stop_timeout = 1380; 318 319 /* wake-up event */ 320 prop->wake_capable = 1; 321 322 /* Three data lanes are supported by rt721-sdca codec */ 323 prop->lane_control_support = true; 324 325 return 0; 326 } 327 328 static int rt721_sdca_interrupt_callback(struct sdw_slave *slave, 329 struct sdw_slave_intr_status *status) 330 { 331 struct rt721_sdca_priv *rt721 = dev_get_drvdata(&slave->dev); 332 int ret, stat; 333 int count = 0, retry = 3; 334 unsigned int sdca_cascade, scp_sdca_stat1, scp_sdca_stat2 = 0; 335 336 if (rt721->imp_sensing_ongoing && rt721->wf_id == RT721_S) 337 dev_info(&slave->dev, 338 "%s: IRQ arrived DURING impedance sensing\n", 339 __func__); 340 341 if (cancel_delayed_work_sync(&rt721->jack_detect_work)) { 342 dev_warn(&slave->dev, "%s the pending delayed_work was cancelled", __func__); 343 /* avoid the HID owner doesn't change to device */ 344 if (rt721->scp_sdca_stat2) 345 scp_sdca_stat2 = rt721->scp_sdca_stat2; 346 } 347 348 /* 349 * The critical section below intentionally protects a rather large piece of code. 350 * We don't want to allow the system suspend to disable an interrupt while we are 351 * processing it, which could be problematic given the quirky SoundWire interrupt 352 * scheme. We do want however to prevent new workqueues from being scheduled if 353 * the disable_irq flag was set during system suspend. 354 */ 355 mutex_lock(&rt721->disable_irq_lock); 356 357 ret = sdw_read_no_pm(rt721->slave, SDW_SCP_SDCA_INT1); 358 if (ret < 0) 359 goto io_error; 360 361 rt721->scp_sdca_stat1 = ret; 362 ret = sdw_read_no_pm(rt721->slave, SDW_SCP_SDCA_INT2); 363 if (ret < 0) 364 goto io_error; 365 366 rt721->scp_sdca_stat2 = ret; 367 if (scp_sdca_stat2) 368 rt721->scp_sdca_stat2 |= scp_sdca_stat2; 369 do { 370 /* clear flag */ 371 ret = sdw_read_no_pm(rt721->slave, SDW_SCP_SDCA_INT1); 372 if (ret < 0) 373 goto io_error; 374 if (ret & SDW_SCP_SDCA_INTMASK_SDCA_0) { 375 ret = sdw_update_no_pm(rt721->slave, SDW_SCP_SDCA_INT1, 376 SDW_SCP_SDCA_INT_SDCA_0, SDW_SCP_SDCA_INT_SDCA_0); 377 if (ret < 0) 378 goto io_error; 379 } 380 ret = sdw_read_no_pm(rt721->slave, SDW_SCP_SDCA_INT2); 381 if (ret < 0) 382 goto io_error; 383 if (ret & SDW_SCP_SDCA_INTMASK_SDCA_8) { 384 ret = sdw_write_no_pm(rt721->slave, SDW_SCP_SDCA_INT2, 385 SDW_SCP_SDCA_INTMASK_SDCA_8); 386 if (ret < 0) 387 goto io_error; 388 } 389 390 /* check if flag clear or not */ 391 ret = sdw_read_no_pm(rt721->slave, SDW_DP0_INT); 392 if (ret < 0) 393 goto io_error; 394 sdca_cascade = ret & SDW_DP0_SDCA_CASCADE; 395 396 ret = sdw_read_no_pm(rt721->slave, SDW_SCP_SDCA_INT1); 397 if (ret < 0) 398 goto io_error; 399 scp_sdca_stat1 = ret & SDW_SCP_SDCA_INTMASK_SDCA_0; 400 401 ret = sdw_read_no_pm(rt721->slave, SDW_SCP_SDCA_INT2); 402 if (ret < 0) 403 goto io_error; 404 scp_sdca_stat2 = ret & SDW_SCP_SDCA_INTMASK_SDCA_8; 405 406 stat = scp_sdca_stat1 || scp_sdca_stat2 || sdca_cascade; 407 408 count++; 409 } while (stat != 0 && count < retry); 410 411 if (stat) 412 dev_warn(&slave->dev, 413 "%s scp_sdca_stat1=0x%x, scp_sdca_stat2=0x%x\n", __func__, 414 rt721->scp_sdca_stat1, rt721->scp_sdca_stat2); 415 ret = sdw_read_no_pm(rt721->slave, SDW_SCP_SDCA_INT1); 416 ret = sdw_read_no_pm(rt721->slave, SDW_SCP_SDCA_INT2); 417 418 if (status->sdca_cascade && !rt721->disable_irq) { 419 unsigned int delay_ms = 280; 420 421 if (rt721->imp_sensing_ongoing && rt721->wf_id == RT721_S) 422 delay_ms = 800; 423 424 mod_delayed_work(system_power_efficient_wq, 425 &rt721->jack_detect_work, msecs_to_jiffies(delay_ms)); 426 } 427 428 mutex_unlock(&rt721->disable_irq_lock); 429 430 return 0; 431 432 io_error: 433 mutex_unlock(&rt721->disable_irq_lock); 434 pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret); 435 return ret; 436 } 437 438 static const struct sdw_slave_ops rt721_sdca_slave_ops = { 439 .read_prop = rt721_sdca_read_prop, 440 .interrupt_callback = rt721_sdca_interrupt_callback, 441 .update_status = rt721_sdca_update_status, 442 }; 443 444 static int rt721_sdca_sdw_probe(struct sdw_slave *slave, 445 const struct sdw_device_id *id) 446 { 447 struct regmap *regmap, *mbq_regmap; 448 449 /* Regmap Initialization */ 450 mbq_regmap = devm_regmap_init_sdw_mbq(slave, &rt721_sdca_mbq_regmap); 451 if (IS_ERR(mbq_regmap)) 452 return PTR_ERR(mbq_regmap); 453 454 regmap = devm_regmap_init_sdw(slave, &rt721_sdca_regmap); 455 if (IS_ERR(regmap)) 456 return PTR_ERR(regmap); 457 458 return rt721_sdca_init(&slave->dev, regmap, mbq_regmap, slave); 459 } 460 461 static void rt721_sdca_sdw_remove(struct sdw_slave *slave) 462 { 463 struct rt721_sdca_priv *rt721 = dev_get_drvdata(&slave->dev); 464 465 cancel_delayed_work_sync(&rt721->jack_detect_work); 466 cancel_delayed_work_sync(&rt721->jack_btn_check_work); 467 468 if (rt721->first_hw_init) 469 pm_runtime_disable(&slave->dev); 470 471 mutex_destroy(&rt721->calibrate_mutex); 472 mutex_destroy(&rt721->disable_irq_lock); 473 } 474 475 static const struct sdw_device_id rt721_sdca_id[] = { 476 SDW_SLAVE_ENTRY_EXT(0x025d, 0x721, 0x3, 0x1, 0), 477 SDW_SLAVE_ENTRY_EXT(0x025d, 0x718, 0x3, 0x1, 0), 478 {}, 479 }; 480 MODULE_DEVICE_TABLE(sdw, rt721_sdca_id); 481 482 static int rt721_sdca_dev_suspend(struct device *dev) 483 { 484 struct rt721_sdca_priv *rt721 = dev_get_drvdata(dev); 485 486 if (!rt721->hw_init) 487 return 0; 488 489 cancel_delayed_work_sync(&rt721->jack_detect_work); 490 cancel_delayed_work_sync(&rt721->jack_btn_check_work); 491 492 regcache_cache_only(rt721->regmap, true); 493 regcache_cache_only(rt721->mbq_regmap, true); 494 495 return 0; 496 } 497 498 static int rt721_sdca_dev_system_suspend(struct device *dev) 499 { 500 struct rt721_sdca_priv *rt721_sdca = dev_get_drvdata(dev); 501 struct sdw_slave *slave = dev_to_sdw_dev(dev); 502 int ret1, ret2; 503 504 if (!rt721_sdca->hw_init) 505 return 0; 506 507 /* 508 * prevent new interrupts from being handled after the 509 * deferred work completes and before the parent disables 510 * interrupts on the link 511 */ 512 scoped_guard(mutex, &rt721_sdca->disable_irq_lock) { 513 rt721_sdca->disable_irq = true; 514 ret1 = sdw_update_no_pm(slave, SDW_SCP_SDCA_INTMASK1, 515 SDW_SCP_SDCA_INTMASK_SDCA_0, 0); 516 ret2 = sdw_update_no_pm(slave, SDW_SCP_SDCA_INTMASK2, 517 SDW_SCP_SDCA_INTMASK_SDCA_8, 0); 518 } 519 520 if (ret1 < 0 || ret2 < 0) { 521 /* log but don't prevent suspend from happening */ 522 dev_dbg(&slave->dev, "%s: could not disable SDCA interrupts\n:", __func__); 523 } 524 525 return rt721_sdca_dev_suspend(dev); 526 } 527 528 #define RT721_PROBE_TIMEOUT 5000 529 530 static int rt721_sdca_dev_resume(struct device *dev) 531 { 532 struct sdw_slave *slave = dev_to_sdw_dev(dev); 533 struct rt721_sdca_priv *rt721 = dev_get_drvdata(dev); 534 int ret; 535 536 if (!rt721->first_hw_init) 537 return 0; 538 539 if (!slave->unattach_request) { 540 scoped_guard(mutex, &rt721->disable_irq_lock) { 541 if (rt721->disable_irq) { 542 sdw_write_no_pm(slave, SDW_SCP_SDCA_INTMASK1, 543 SDW_SCP_SDCA_INTMASK_SDCA_0); 544 sdw_write_no_pm(slave, SDW_SCP_SDCA_INTMASK2, 545 SDW_SCP_SDCA_INTMASK_SDCA_8); 546 rt721->disable_irq = false; 547 } 548 } 549 } 550 551 ret = sdw_slave_wait_for_init(slave, RT721_PROBE_TIMEOUT); 552 if (ret) { 553 sdw_show_ping_status(slave->bus, true); 554 return ret; 555 } 556 557 regcache_cache_only(rt721->regmap, false); 558 ret = regcache_sync(rt721->regmap); 559 if (ret) { 560 regcache_cache_only(rt721->regmap, true); 561 return ret; 562 } 563 564 regcache_cache_only(rt721->mbq_regmap, false); 565 ret = regcache_sync(rt721->mbq_regmap); 566 if (ret) { 567 regcache_cache_only(rt721->mbq_regmap, true); 568 regcache_cache_only(rt721->regmap, true); 569 return ret; 570 } 571 572 return 0; 573 } 574 575 static const struct dev_pm_ops rt721_sdca_pm = { 576 SYSTEM_SLEEP_PM_OPS(rt721_sdca_dev_system_suspend, rt721_sdca_dev_resume) 577 RUNTIME_PM_OPS(rt721_sdca_dev_suspend, rt721_sdca_dev_resume, NULL) 578 }; 579 580 static struct sdw_driver rt721_sdca_sdw_driver = { 581 .driver = { 582 .name = "rt721-sdca", 583 .owner = THIS_MODULE, 584 .pm = pm_ptr(&rt721_sdca_pm), 585 }, 586 .probe = rt721_sdca_sdw_probe, 587 .remove = rt721_sdca_sdw_remove, 588 .ops = &rt721_sdca_slave_ops, 589 .id_table = rt721_sdca_id, 590 }; 591 module_sdw_driver(rt721_sdca_sdw_driver); 592 593 MODULE_DESCRIPTION("ASoC RT721 SDCA SDW driver"); 594 MODULE_AUTHOR("Jack Yu <jack.yu@realtek.com>"); 595 MODULE_LICENSE("GPL"); 596