1 // SPDX-License-Identifier: GPL-2.0-only 2 // 3 // rt712-sdca-sdw.c -- rt712 SDCA ALSA SoC audio driver 4 // 5 // Copyright(c) 2023 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 #include "rt712-sdca.h" 16 #include "rt712-sdca-sdw.h" 17 18 static bool rt712_sdca_readable_register(struct device *dev, unsigned int reg) 19 { 20 switch (reg) { 21 case 0x004d: 22 case 0x201a ... 0x201f: 23 case 0x2029 ... 0x202a: 24 case 0x202d ... 0x2034: 25 case 0x2230 ... 0x2232: 26 case 0x2f01 ... 0x2f0a: 27 case 0x2f35 ... 0x2f36: 28 case 0x2f3a: 29 case 0x2f3d: 30 case 0x2f41: 31 case 0x2f50: 32 case 0x2f54: 33 case 0x2f58 ... 0x2f5d: 34 case 0x3201: 35 case 0x320c: 36 case 0x3301 ... 0x3303: 37 case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_GE49, RT712_SDCA_CTL_SELECTED_MODE, 0): 38 case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_GE49, RT712_SDCA_CTL_DETECTED_MODE, 0): 39 case SDW_SDCA_CTL(FUNC_NUM_HID, RT712_SDCA_ENT_HID01, RT712_SDCA_CTL_HIDTX_CURRENT_OWNER, 0) ... 40 SDW_SDCA_CTL(FUNC_NUM_HID, RT712_SDCA_ENT_HID01, RT712_SDCA_CTL_HIDTX_MESSAGE_LENGTH, 0): 41 case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT0, RT712_SDCA_CTL_FUNC_STATUS, 0): 42 case SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT0, RT712_SDCA_CTL_FUNC_STATUS, 0): 43 case SDW_SDCA_CTL(FUNC_NUM_HID, RT712_SDCA_ENT0, RT712_SDCA_CTL_FUNC_STATUS, 0): 44 case SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT0, RT712_SDCA_CTL_FUNC_STATUS, 0): 45 case RT712_BUF_ADDR_HID1 ... RT712_BUF_ADDR_HID2: 46 return true; 47 default: 48 return false; 49 } 50 } 51 52 static bool rt712_sdca_volatile_register(struct device *dev, unsigned int reg) 53 { 54 switch (reg) { 55 case 0x004d: 56 case 0x201b: 57 case 0x201c: 58 case 0x201d: 59 case 0x201f: 60 case 0x202d ... 0x202f: 61 case 0x2230: 62 case 0x2f01: 63 case 0x2f35: 64 case 0x2f3a: 65 case 0x2f3d: 66 case 0x2f41: 67 case 0x320c: 68 case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_GE49, RT712_SDCA_CTL_DETECTED_MODE, 0): 69 case SDW_SDCA_CTL(FUNC_NUM_HID, RT712_SDCA_ENT_HID01, RT712_SDCA_CTL_HIDTX_CURRENT_OWNER, 0) ... 70 SDW_SDCA_CTL(FUNC_NUM_HID, RT712_SDCA_ENT_HID01, RT712_SDCA_CTL_HIDTX_MESSAGE_LENGTH, 0): 71 case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT0, RT712_SDCA_CTL_FUNC_STATUS, 0): 72 case SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT0, RT712_SDCA_CTL_FUNC_STATUS, 0): 73 case SDW_SDCA_CTL(FUNC_NUM_HID, RT712_SDCA_ENT0, RT712_SDCA_CTL_FUNC_STATUS, 0): 74 case SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT0, RT712_SDCA_CTL_FUNC_STATUS, 0): 75 case RT712_BUF_ADDR_HID1 ... RT712_BUF_ADDR_HID2: 76 return true; 77 default: 78 return false; 79 } 80 } 81 82 static bool rt712_sdca_mbq_readable_register(struct device *dev, unsigned int reg) 83 { 84 switch (reg) { 85 case 0x2000000 ... 0x200008e: 86 case 0x5300000 ... 0x530000e: 87 case 0x5400000 ... 0x540000e: 88 case 0x5600000 ... 0x5600008: 89 case 0x5700000 ... 0x570000d: 90 case 0x5800000 ... 0x5800021: 91 case 0x5900000 ... 0x5900028: 92 case 0x5a00000 ... 0x5a00009: 93 case 0x5b00000 ... 0x5b00051: 94 case 0x5c00000 ... 0x5c0009a: 95 case 0x5d00000 ... 0x5d00009: 96 case 0x5f00000 ... 0x5f00030: 97 case 0x6100000 ... 0x61000f1: 98 case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU05, RT712_SDCA_CTL_FU_VOLUME, CH_01): 99 case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU05, RT712_SDCA_CTL_FU_VOLUME, CH_02): 100 case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU0F, RT712_SDCA_CTL_FU_VOLUME, CH_01): 101 case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU0F, RT712_SDCA_CTL_FU_VOLUME, CH_02): 102 case SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT_USER_FU06, RT712_SDCA_CTL_FU_VOLUME, CH_01): 103 case SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT_USER_FU06, RT712_SDCA_CTL_FU_VOLUME, CH_02): 104 case SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT_USER_FU1E, RT712_SDCA_CTL_FU_VOLUME, CH_01): 105 case SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT_USER_FU1E, RT712_SDCA_CTL_FU_VOLUME, CH_02): 106 case SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT_USER_FU1E, RT712_SDCA_CTL_FU_VOLUME, CH_03): 107 case SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT_USER_FU1E, RT712_SDCA_CTL_FU_VOLUME, CH_04): 108 case SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT_PLATFORM_FU15, RT712_SDCA_CTL_FU_CH_GAIN, CH_01): 109 case SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT_PLATFORM_FU15, RT712_SDCA_CTL_FU_CH_GAIN, CH_02): 110 case SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT_PLATFORM_FU15, RT712_SDCA_CTL_FU_CH_GAIN, CH_03): 111 case SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT_PLATFORM_FU15, RT712_SDCA_CTL_FU_CH_GAIN, CH_04): 112 return true; 113 default: 114 return false; 115 } 116 } 117 118 static bool rt712_sdca_mbq_volatile_register(struct device *dev, unsigned int reg) 119 { 120 switch (reg) { 121 case 0x2000000: 122 case 0x200001a: 123 case 0x2000020: 124 case 0x2000024: 125 case 0x2000030: 126 case 0x2000046: 127 case 0x200008a: 128 case 0x5800000: 129 case 0x5800001: 130 case 0x6100008: 131 return true; 132 default: 133 return false; 134 } 135 } 136 137 static const struct regmap_config rt712_sdca_regmap = { 138 .reg_bits = 32, 139 .val_bits = 8, 140 .readable_reg = rt712_sdca_readable_register, 141 .volatile_reg = rt712_sdca_volatile_register, 142 .max_register = 0x44ffffff, 143 .reg_defaults = rt712_sdca_reg_defaults, 144 .num_reg_defaults = ARRAY_SIZE(rt712_sdca_reg_defaults), 145 .cache_type = REGCACHE_MAPLE, 146 .use_single_read = true, 147 .use_single_write = true, 148 }; 149 150 static const struct regmap_config rt712_sdca_mbq_regmap = { 151 .name = "sdw-mbq", 152 .reg_bits = 32, 153 .val_bits = 16, 154 .readable_reg = rt712_sdca_mbq_readable_register, 155 .volatile_reg = rt712_sdca_mbq_volatile_register, 156 .max_register = 0x41000312, 157 .reg_defaults = rt712_sdca_mbq_defaults, 158 .num_reg_defaults = ARRAY_SIZE(rt712_sdca_mbq_defaults), 159 .cache_type = REGCACHE_MAPLE, 160 .use_single_read = true, 161 .use_single_write = true, 162 }; 163 164 static int rt712_sdca_update_status(struct sdw_slave *slave, 165 enum sdw_slave_status status) 166 { 167 struct rt712_sdca_priv *rt712 = dev_get_drvdata(&slave->dev); 168 169 if (status == SDW_SLAVE_UNATTACHED) 170 rt712->hw_init = false; 171 172 if (status == SDW_SLAVE_ATTACHED) { 173 if (rt712->hs_jack) { 174 /* 175 * Due to the SCP_SDCA_INTMASK will be cleared by any reset, and then 176 * if the device attached again, we will need to set the setting back. 177 * It could avoid losing the jack detection interrupt. 178 * This also could sync with the cache value as the rt712_sdca_jack_init set. 179 */ 180 sdw_write_no_pm(rt712->slave, SDW_SCP_SDCA_INTMASK1, 181 SDW_SCP_SDCA_INTMASK_SDCA_0); 182 sdw_write_no_pm(rt712->slave, SDW_SCP_SDCA_INTMASK2, 183 SDW_SCP_SDCA_INTMASK_SDCA_8); 184 } 185 } 186 187 /* 188 * Perform initialization only if slave status is present and 189 * hw_init flag is false 190 */ 191 if (rt712->hw_init || status != SDW_SLAVE_ATTACHED) 192 return 0; 193 194 /* perform I/O transfers required for Slave initialization */ 195 return rt712_sdca_io_init(&slave->dev, slave); 196 } 197 198 static int rt712_sdca_read_prop(struct sdw_slave *slave) 199 { 200 struct sdw_slave_prop *prop = &slave->prop; 201 int nval; 202 int i, j; 203 u32 bit; 204 unsigned long addr; 205 struct sdw_dpn_prop *dpn; 206 207 sdw_slave_read_prop(slave); 208 209 prop->scp_int1_mask = SDW_SCP_INT1_BUS_CLASH | SDW_SCP_INT1_PARITY; 210 prop->quirks = SDW_SLAVE_QUIRKS_INVALID_INITIAL_PARITY; 211 212 prop->paging_support = true; 213 214 /* first we need to allocate memory for set bits in port lists */ 215 prop->source_ports = BIT(8) | BIT(4); /* BITMAP: 100010000 */ 216 prop->sink_ports = BIT(3) | BIT(1); /* BITMAP: 00001010 */ 217 218 nval = hweight32(prop->source_ports); 219 prop->src_dpn_prop = devm_kcalloc(&slave->dev, nval, 220 sizeof(*prop->src_dpn_prop), GFP_KERNEL); 221 if (!prop->src_dpn_prop) 222 return -ENOMEM; 223 224 i = 0; 225 dpn = prop->src_dpn_prop; 226 addr = prop->source_ports; 227 for_each_set_bit(bit, &addr, 32) { 228 dpn[i].num = bit; 229 dpn[i].type = SDW_DPN_FULL; 230 dpn[i].simple_ch_prep_sm = true; 231 dpn[i].ch_prep_timeout = 10; 232 i++; 233 } 234 235 /* do this again for sink now */ 236 nval = hweight32(prop->sink_ports); 237 prop->sink_dpn_prop = devm_kcalloc(&slave->dev, nval, 238 sizeof(*prop->sink_dpn_prop), GFP_KERNEL); 239 if (!prop->sink_dpn_prop) 240 return -ENOMEM; 241 242 j = 0; 243 dpn = prop->sink_dpn_prop; 244 addr = prop->sink_ports; 245 for_each_set_bit(bit, &addr, 32) { 246 dpn[j].num = bit; 247 dpn[j].type = SDW_DPN_FULL; 248 dpn[j].simple_ch_prep_sm = true; 249 dpn[j].ch_prep_timeout = 10; 250 j++; 251 } 252 253 /* set the timeout values */ 254 prop->clk_stop_timeout = 1380; 255 256 /* wake-up event */ 257 prop->wake_capable = 1; 258 259 return 0; 260 } 261 262 static int rt712_sdca_interrupt_callback(struct sdw_slave *slave, 263 struct sdw_slave_intr_status *status) 264 { 265 struct rt712_sdca_priv *rt712 = dev_get_drvdata(&slave->dev); 266 int ret, stat; 267 int count = 0, retry = 3; 268 unsigned int sdca_cascade, scp_sdca_stat1, scp_sdca_stat2 = 0; 269 270 dev_dbg(&slave->dev, 271 "%s control_port_stat=%x, sdca_cascade=%x", __func__, 272 status->control_port, status->sdca_cascade); 273 274 if (cancel_delayed_work_sync(&rt712->jack_detect_work)) { 275 dev_warn(&slave->dev, "%s the pending delayed_work was cancelled", __func__); 276 /* avoid the HID owner doesn't change to device */ 277 if (rt712->scp_sdca_stat2) 278 scp_sdca_stat2 = rt712->scp_sdca_stat2; 279 } 280 281 /* 282 * The critical section below intentionally protects a rather large piece of code. 283 * We don't want to allow the system suspend to disable an interrupt while we are 284 * processing it, which could be problematic given the quirky SoundWire interrupt 285 * scheme. We do want however to prevent new workqueues from being scheduled if 286 * the disable_irq flag was set during system suspend. 287 */ 288 mutex_lock(&rt712->disable_irq_lock); 289 290 ret = sdw_read_no_pm(rt712->slave, SDW_SCP_SDCA_INT1); 291 if (ret < 0) 292 goto io_error; 293 rt712->scp_sdca_stat1 = ret; 294 ret = sdw_read_no_pm(rt712->slave, SDW_SCP_SDCA_INT2); 295 if (ret < 0) 296 goto io_error; 297 rt712->scp_sdca_stat2 = ret; 298 if (scp_sdca_stat2) 299 rt712->scp_sdca_stat2 |= scp_sdca_stat2; 300 301 do { 302 /* clear flag */ 303 ret = sdw_read_no_pm(rt712->slave, SDW_SCP_SDCA_INT1); 304 if (ret < 0) 305 goto io_error; 306 if (ret & SDW_SCP_SDCA_INTMASK_SDCA_0) { 307 ret = sdw_write_no_pm(rt712->slave, SDW_SCP_SDCA_INT1, 308 SDW_SCP_SDCA_INTMASK_SDCA_0); 309 if (ret < 0) 310 goto io_error; 311 } 312 ret = sdw_read_no_pm(rt712->slave, SDW_SCP_SDCA_INT2); 313 if (ret < 0) 314 goto io_error; 315 if (ret & SDW_SCP_SDCA_INTMASK_SDCA_8) { 316 ret = sdw_write_no_pm(rt712->slave, SDW_SCP_SDCA_INT2, 317 SDW_SCP_SDCA_INTMASK_SDCA_8); 318 if (ret < 0) 319 goto io_error; 320 } 321 322 /* check if flag clear or not */ 323 ret = sdw_read_no_pm(rt712->slave, SDW_DP0_INT); 324 if (ret < 0) 325 goto io_error; 326 sdca_cascade = ret & SDW_DP0_SDCA_CASCADE; 327 328 ret = sdw_read_no_pm(rt712->slave, SDW_SCP_SDCA_INT1); 329 if (ret < 0) 330 goto io_error; 331 scp_sdca_stat1 = ret & SDW_SCP_SDCA_INTMASK_SDCA_0; 332 333 ret = sdw_read_no_pm(rt712->slave, SDW_SCP_SDCA_INT2); 334 if (ret < 0) 335 goto io_error; 336 scp_sdca_stat2 = ret & SDW_SCP_SDCA_INTMASK_SDCA_8; 337 338 stat = scp_sdca_stat1 || scp_sdca_stat2 || sdca_cascade; 339 340 count++; 341 } while (stat != 0 && count < retry); 342 343 if (stat) 344 dev_warn(&slave->dev, 345 "%s scp_sdca_stat1=0x%x, scp_sdca_stat2=0x%x\n", __func__, 346 rt712->scp_sdca_stat1, rt712->scp_sdca_stat2); 347 348 if (status->sdca_cascade && !rt712->disable_irq) 349 mod_delayed_work(system_power_efficient_wq, 350 &rt712->jack_detect_work, msecs_to_jiffies(30)); 351 352 mutex_unlock(&rt712->disable_irq_lock); 353 354 return 0; 355 356 io_error: 357 mutex_unlock(&rt712->disable_irq_lock); 358 pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret); 359 return ret; 360 } 361 362 static const struct sdw_slave_ops rt712_sdca_slave_ops = { 363 .read_prop = rt712_sdca_read_prop, 364 .interrupt_callback = rt712_sdca_interrupt_callback, 365 .update_status = rt712_sdca_update_status, 366 }; 367 368 static int rt712_sdca_sdw_probe(struct sdw_slave *slave, 369 const struct sdw_device_id *id) 370 { 371 struct regmap *regmap, *mbq_regmap; 372 373 /* Regmap Initialization */ 374 mbq_regmap = devm_regmap_init_sdw_mbq(slave, &rt712_sdca_mbq_regmap); 375 if (IS_ERR(mbq_regmap)) 376 return PTR_ERR(mbq_regmap); 377 378 regmap = devm_regmap_init_sdw(slave, &rt712_sdca_regmap); 379 if (IS_ERR(regmap)) 380 return PTR_ERR(regmap); 381 382 return rt712_sdca_init(&slave->dev, regmap, mbq_regmap, slave); 383 } 384 385 static void rt712_sdca_sdw_remove(struct sdw_slave *slave) 386 { 387 struct rt712_sdca_priv *rt712 = dev_get_drvdata(&slave->dev); 388 389 if (rt712->hw_init) { 390 cancel_delayed_work_sync(&rt712->jack_detect_work); 391 cancel_delayed_work_sync(&rt712->jack_btn_check_work); 392 } 393 394 pm_runtime_disable(&slave->dev); 395 396 mutex_destroy(&rt712->calibrate_mutex); 397 mutex_destroy(&rt712->disable_irq_lock); 398 } 399 400 static const struct sdw_device_id rt712_sdca_id[] = { 401 SDW_SLAVE_ENTRY_EXT(0x025d, 0x712, 0x3, 0x1, 0), 402 SDW_SLAVE_ENTRY_EXT(0x025d, 0x713, 0x3, 0x1, 0), 403 SDW_SLAVE_ENTRY_EXT(0x025d, 0x716, 0x3, 0x1, 0), 404 SDW_SLAVE_ENTRY_EXT(0x025d, 0x717, 0x3, 0x1, 0), 405 {}, 406 }; 407 MODULE_DEVICE_TABLE(sdw, rt712_sdca_id); 408 409 static int rt712_sdca_dev_suspend(struct device *dev) 410 { 411 struct rt712_sdca_priv *rt712 = dev_get_drvdata(dev); 412 413 if (!rt712->hw_init) 414 return 0; 415 416 cancel_delayed_work_sync(&rt712->jack_detect_work); 417 cancel_delayed_work_sync(&rt712->jack_btn_check_work); 418 419 regcache_cache_only(rt712->regmap, true); 420 regcache_cache_only(rt712->mbq_regmap, true); 421 422 return 0; 423 } 424 425 static int rt712_sdca_dev_system_suspend(struct device *dev) 426 { 427 struct rt712_sdca_priv *rt712_sdca = dev_get_drvdata(dev); 428 struct sdw_slave *slave = dev_to_sdw_dev(dev); 429 int ret1, ret2; 430 431 if (!rt712_sdca->hw_init) 432 return 0; 433 434 /* 435 * prevent new interrupts from being handled after the 436 * deferred work completes and before the parent disables 437 * interrupts on the link 438 */ 439 scoped_guard(mutex, &rt712_sdca->disable_irq_lock) { 440 rt712_sdca->disable_irq = true; 441 ret1 = sdw_update_no_pm(slave, SDW_SCP_SDCA_INTMASK1, 442 SDW_SCP_SDCA_INTMASK_SDCA_0, 0); 443 ret2 = sdw_update_no_pm(slave, SDW_SCP_SDCA_INTMASK2, 444 SDW_SCP_SDCA_INTMASK_SDCA_8, 0); 445 } 446 447 if (ret1 < 0 || ret2 < 0) { 448 /* log but don't prevent suspend from happening */ 449 dev_dbg(&slave->dev, "%s: could not disable SDCA interrupts\n:", __func__); 450 } 451 452 return rt712_sdca_dev_suspend(dev); 453 } 454 455 #define RT712_PROBE_TIMEOUT 5000 456 457 static int rt712_sdca_dev_resume(struct device *dev) 458 { 459 struct sdw_slave *slave = dev_to_sdw_dev(dev); 460 struct rt712_sdca_priv *rt712 = dev_get_drvdata(dev); 461 int ret; 462 463 if (!rt712->first_hw_init) 464 return 0; 465 466 if (!slave->unattach_request) { 467 scoped_guard(mutex, &rt712->disable_irq_lock) { 468 if (rt712->disable_irq) { 469 sdw_write_no_pm(slave, SDW_SCP_SDCA_INTMASK1, 470 SDW_SCP_SDCA_INTMASK_SDCA_0); 471 sdw_write_no_pm(slave, SDW_SCP_SDCA_INTMASK2, 472 SDW_SCP_SDCA_INTMASK_SDCA_8); 473 rt712->disable_irq = false; 474 } 475 } 476 } 477 478 ret = sdw_slave_wait_for_init(slave, RT712_PROBE_TIMEOUT); 479 if (ret) { 480 sdw_show_ping_status(slave->bus, true); 481 return ret; 482 } 483 484 regcache_cache_only(rt712->regmap, false); 485 ret = regcache_sync(rt712->regmap); 486 if (ret) { 487 regcache_cache_only(rt712->regmap, true); 488 return ret; 489 } 490 491 regcache_cache_only(rt712->mbq_regmap, false); 492 ret = regcache_sync(rt712->mbq_regmap); 493 if (ret) { 494 regcache_cache_only(rt712->mbq_regmap, true); 495 regcache_cache_only(rt712->regmap, true); 496 return ret; 497 } 498 499 return 0; 500 } 501 502 static const struct dev_pm_ops rt712_sdca_pm = { 503 SYSTEM_SLEEP_PM_OPS(rt712_sdca_dev_system_suspend, rt712_sdca_dev_resume) 504 RUNTIME_PM_OPS(rt712_sdca_dev_suspend, rt712_sdca_dev_resume, NULL) 505 }; 506 507 static struct sdw_driver rt712_sdca_sdw_driver = { 508 .driver = { 509 .name = "rt712-sdca", 510 .pm = pm_ptr(&rt712_sdca_pm), 511 }, 512 .probe = rt712_sdca_sdw_probe, 513 .remove = rt712_sdca_sdw_remove, 514 .ops = &rt712_sdca_slave_ops, 515 .id_table = rt712_sdca_id, 516 }; 517 module_sdw_driver(rt712_sdca_sdw_driver); 518 519 MODULE_DESCRIPTION("ASoC RT712 SDCA SDW driver"); 520 MODULE_AUTHOR("Shuming Fan <shumingf@realtek.com>"); 521 MODULE_LICENSE("GPL"); 522 MODULE_IMPORT_NS("SND_SOC_SDCA"); 523