1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * rt715-sdw.c -- rt715 ALSA SoC audio driver 4 * 5 * Copyright(c) 2019 Realtek Semiconductor Corp. 6 * 7 * ALC715 ASoC Codec Driver based Intel Dummy SdW codec driver 8 * 9 */ 10 #include <linux/delay.h> 11 #include <linux/device.h> 12 #include <linux/soundwire/sdw.h> 13 #include <linux/soundwire/sdw_type.h> 14 #include <linux/soundwire/sdw_registers.h> 15 #include <linux/module.h> 16 #include <linux/pm_runtime.h> 17 #include <linux/of.h> 18 #include <linux/regmap.h> 19 #include <sound/soc.h> 20 #include "rt715.h" 21 #include "rt715-sdw.h" 22 23 static bool rt715_readable_register(struct device *dev, unsigned int reg) 24 { 25 switch (reg) { 26 case 0x00e0 ... 0x00e5: 27 case 0x00ee ... 0x00ef: 28 case 0x00f0 ... 0x00f5: 29 case 0x00fe ... 0x00ff: 30 case 0x02e0: 31 case 0x02f0: 32 case 0x04e0: 33 case 0x04f0: 34 case 0x06e0: 35 case 0x06f0: 36 case 0x2000 ... 0x2016: 37 case 0x201a ... 0x2027: 38 case 0x2029 ... 0x202a: 39 case 0x202d ... 0x2034: 40 case 0x2200 ... 0x2204: 41 case 0x2206 ... 0x2212: 42 case 0x2220 ... 0x2223: 43 case 0x2230 ... 0x2239: 44 case 0x22f0 ... 0x22f3: 45 case 0x3122: 46 case 0x3123: 47 case 0x3124: 48 case 0x3125: 49 case 0x3607: 50 case 0x3608: 51 case 0x3609: 52 case 0x3610: 53 case 0x3611: 54 case 0x3627: 55 case 0x3712: 56 case 0x3713: 57 case 0x3718: 58 case 0x3719: 59 case 0x371a: 60 case 0x371b: 61 case 0x371d: 62 case 0x3729: 63 case 0x385e: 64 case 0x3859: 65 case 0x4c12: 66 case 0x4c13: 67 case 0x4c1d: 68 case 0x4c29: 69 case 0x4d12: 70 case 0x4d13: 71 case 0x4d1d: 72 case 0x4d29: 73 case 0x4e12: 74 case 0x4e13: 75 case 0x4e1d: 76 case 0x4e29: 77 case 0x4f12: 78 case 0x4f13: 79 case 0x4f1d: 80 case 0x4f29: 81 case 0x7207: 82 case 0x7208: 83 case 0x7209: 84 case 0x7227: 85 case 0x7307: 86 case 0x7308: 87 case 0x7309: 88 case 0x7312: 89 case 0x7313: 90 case 0x7318: 91 case 0x7319: 92 case 0x731a: 93 case 0x731b: 94 case 0x731d: 95 case 0x7327: 96 case 0x7329: 97 case 0x8287: 98 case 0x8288: 99 case 0x8289: 100 case 0x82a7: 101 case 0x8387: 102 case 0x8388: 103 case 0x8389: 104 case 0x8392: 105 case 0x8393: 106 case 0x8398: 107 case 0x8399: 108 case 0x839a: 109 case 0x839b: 110 case 0x839d: 111 case 0x83a7: 112 case 0x83a9: 113 case 0x752001: 114 case 0x752039: 115 return true; 116 default: 117 return false; 118 } 119 } 120 121 static bool rt715_volatile_register(struct device *dev, unsigned int reg) 122 { 123 switch (reg) { 124 case 0x00e5: 125 case 0x00f0: 126 case 0x00f3: 127 case 0x00f5: 128 case 0x2009: 129 case 0x2016: 130 case 0x201b: 131 case 0x201c: 132 case 0x201d: 133 case 0x201f: 134 case 0x2023: 135 case 0x2230: 136 case 0x200b ... 0x200e: /* i2c read */ 137 case 0x2012 ... 0x2015: /* HD-A read */ 138 case 0x202d ... 0x202f: /* BRA */ 139 case 0x2201 ... 0x2212: /* i2c debug */ 140 case 0x2220 ... 0x2223: /* decoded HD-A */ 141 return true; 142 default: 143 return false; 144 } 145 } 146 147 static int rt715_sdw_read(void *context, unsigned int reg, unsigned int *val) 148 { 149 struct device *dev = context; 150 struct rt715_priv *rt715 = dev_get_drvdata(dev); 151 unsigned int sdw_data_3, sdw_data_2, sdw_data_1, sdw_data_0; 152 unsigned int reg2 = 0, reg3 = 0, reg4 = 0, mask, nid, val2; 153 unsigned int is_hda_reg = 1, is_index_reg = 0; 154 int ret; 155 156 if (reg > 0xffff) 157 is_index_reg = 1; 158 159 mask = reg & 0xf000; 160 161 if (is_index_reg) { /* index registers */ 162 val2 = reg & 0xff; 163 reg = reg >> 8; 164 nid = reg & 0xff; 165 ret = regmap_write(rt715->sdw_regmap, reg, 0); 166 if (ret < 0) 167 return ret; 168 reg2 = reg + 0x1000; 169 reg2 |= 0x80; 170 ret = regmap_write(rt715->sdw_regmap, reg2, val2); 171 if (ret < 0) 172 return ret; 173 174 reg3 = RT715_PRIV_DATA_R_H | nid; 175 ret = regmap_write(rt715->sdw_regmap, reg3, 176 ((*val >> 8) & 0xff)); 177 if (ret < 0) 178 return ret; 179 reg4 = reg3 + 0x1000; 180 reg4 |= 0x80; 181 ret = regmap_write(rt715->sdw_regmap, reg4, (*val & 0xff)); 182 if (ret < 0) 183 return ret; 184 } else if (mask == 0x3000) { 185 reg += 0x8000; 186 ret = regmap_write(rt715->sdw_regmap, reg, *val); 187 if (ret < 0) 188 return ret; 189 } else if (mask == 0x7000) { 190 reg += 0x2000; 191 reg |= 0x800; 192 ret = regmap_write(rt715->sdw_regmap, reg, 193 ((*val >> 8) & 0xff)); 194 if (ret < 0) 195 return ret; 196 reg2 = reg + 0x1000; 197 reg2 |= 0x80; 198 ret = regmap_write(rt715->sdw_regmap, reg2, (*val & 0xff)); 199 if (ret < 0) 200 return ret; 201 } else if ((reg & 0xff00) == 0x8300) { /* for R channel */ 202 reg2 = reg - 0x1000; 203 reg2 &= ~0x80; 204 ret = regmap_write(rt715->sdw_regmap, reg2, 205 ((*val >> 8) & 0xff)); 206 if (ret < 0) 207 return ret; 208 ret = regmap_write(rt715->sdw_regmap, reg, (*val & 0xff)); 209 if (ret < 0) 210 return ret; 211 } else if (mask == 0x9000) { 212 ret = regmap_write(rt715->sdw_regmap, reg, 213 ((*val >> 8) & 0xff)); 214 if (ret < 0) 215 return ret; 216 reg2 = reg + 0x1000; 217 reg2 |= 0x80; 218 ret = regmap_write(rt715->sdw_regmap, reg2, (*val & 0xff)); 219 if (ret < 0) 220 return ret; 221 } else if (mask == 0xb000) { 222 ret = regmap_write(rt715->sdw_regmap, reg, *val); 223 if (ret < 0) 224 return ret; 225 } else { 226 ret = regmap_read(rt715->sdw_regmap, reg, val); 227 if (ret < 0) 228 return ret; 229 is_hda_reg = 0; 230 } 231 232 if (is_hda_reg || is_index_reg) { 233 sdw_data_3 = 0; 234 sdw_data_2 = 0; 235 sdw_data_1 = 0; 236 sdw_data_0 = 0; 237 ret = regmap_read(rt715->sdw_regmap, RT715_READ_HDA_3, 238 &sdw_data_3); 239 if (ret < 0) 240 return ret; 241 ret = regmap_read(rt715->sdw_regmap, RT715_READ_HDA_2, 242 &sdw_data_2); 243 if (ret < 0) 244 return ret; 245 ret = regmap_read(rt715->sdw_regmap, RT715_READ_HDA_1, 246 &sdw_data_1); 247 if (ret < 0) 248 return ret; 249 ret = regmap_read(rt715->sdw_regmap, RT715_READ_HDA_0, 250 &sdw_data_0); 251 if (ret < 0) 252 return ret; 253 *val = ((sdw_data_3 & 0xff) << 24) | 254 ((sdw_data_2 & 0xff) << 16) | 255 ((sdw_data_1 & 0xff) << 8) | (sdw_data_0 & 0xff); 256 } 257 258 if (is_hda_reg == 0) 259 dev_dbg(dev, "[%s] %04x => %08x\n", __func__, reg, *val); 260 else if (is_index_reg) 261 dev_dbg(dev, "[%s] %04x %04x %04x %04x => %08x\n", __func__, 262 reg, reg2, reg3, reg4, *val); 263 else 264 dev_dbg(dev, "[%s] %04x %04x => %08x\n", 265 __func__, reg, reg2, *val); 266 267 return 0; 268 } 269 270 static int rt715_sdw_write(void *context, unsigned int reg, unsigned int val) 271 { 272 struct device *dev = context; 273 struct rt715_priv *rt715 = dev_get_drvdata(dev); 274 unsigned int reg2 = 0, reg3, reg4, nid, mask, val2; 275 unsigned int is_index_reg = 0; 276 int ret; 277 278 if (reg > 0xffff) 279 is_index_reg = 1; 280 281 mask = reg & 0xf000; 282 283 if (is_index_reg) { /* index registers */ 284 val2 = reg & 0xff; 285 reg = reg >> 8; 286 nid = reg & 0xff; 287 ret = regmap_write(rt715->sdw_regmap, reg, 0); 288 if (ret < 0) 289 return ret; 290 reg2 = reg + 0x1000; 291 reg2 |= 0x80; 292 ret = regmap_write(rt715->sdw_regmap, reg2, val2); 293 if (ret < 0) 294 return ret; 295 296 reg3 = RT715_PRIV_DATA_W_H | nid; 297 ret = regmap_write(rt715->sdw_regmap, reg3, 298 ((val >> 8) & 0xff)); 299 if (ret < 0) 300 return ret; 301 reg4 = reg3 + 0x1000; 302 reg4 |= 0x80; 303 ret = regmap_write(rt715->sdw_regmap, reg4, (val & 0xff)); 304 if (ret < 0) 305 return ret; 306 is_index_reg = 1; 307 } else if (reg < 0x4fff) { 308 ret = regmap_write(rt715->sdw_regmap, reg, val); 309 if (ret < 0) 310 return ret; 311 } else if (reg == RT715_FUNC_RESET) { 312 ret = regmap_write(rt715->sdw_regmap, reg, val); 313 if (ret < 0) 314 return ret; 315 } else if (mask == 0x7000) { 316 ret = regmap_write(rt715->sdw_regmap, reg, 317 ((val >> 8) & 0xff)); 318 if (ret < 0) 319 return ret; 320 reg2 = reg + 0x1000; 321 reg2 |= 0x80; 322 ret = regmap_write(rt715->sdw_regmap, reg2, (val & 0xff)); 323 if (ret < 0) 324 return ret; 325 } else if ((reg & 0xff00) == 0x8300) { /* for R channel */ 326 reg2 = reg - 0x1000; 327 reg2 &= ~0x80; 328 ret = regmap_write(rt715->sdw_regmap, reg2, 329 ((val >> 8) & 0xff)); 330 if (ret < 0) 331 return ret; 332 ret = regmap_write(rt715->sdw_regmap, reg, (val & 0xff)); 333 if (ret < 0) 334 return ret; 335 } 336 337 if (reg2 == 0) 338 dev_dbg(dev, "[%s] %04x <= %04x\n", __func__, reg, val); 339 else if (is_index_reg) 340 dev_dbg(dev, "[%s] %04x %04x %04x %04x <= %04x %04x\n", 341 __func__, reg, reg2, reg3, reg4, val2, val); 342 else 343 dev_dbg(dev, "[%s] %04x %04x <= %04x\n", 344 __func__, reg, reg2, val); 345 346 return 0; 347 } 348 349 static const struct regmap_config rt715_regmap = { 350 .reg_bits = 24, 351 .val_bits = 32, 352 .readable_reg = rt715_readable_register, /* Readable registers */ 353 .volatile_reg = rt715_volatile_register, /* volatile register */ 354 .max_register = 0x752039, /* Maximum number of register */ 355 .reg_defaults = rt715_reg_defaults, /* Defaults */ 356 .num_reg_defaults = ARRAY_SIZE(rt715_reg_defaults), 357 .cache_type = REGCACHE_MAPLE, 358 .use_single_read = true, 359 .use_single_write = true, 360 .reg_read = rt715_sdw_read, 361 .reg_write = rt715_sdw_write, 362 }; 363 364 static const struct regmap_config rt715_sdw_regmap = { 365 .name = "sdw", 366 .reg_bits = 32, /* Total register space for SDW */ 367 .val_bits = 8, /* Total number of bits in register */ 368 .max_register = 0xff01, /* Maximum number of register */ 369 .cache_type = REGCACHE_NONE, 370 .use_single_read = true, 371 .use_single_write = true, 372 }; 373 374 static int rt715_update_status(struct sdw_slave *slave, 375 enum sdw_slave_status status) 376 { 377 struct rt715_priv *rt715 = dev_get_drvdata(&slave->dev); 378 379 /* 380 * Perform initialization only if slave status is present and 381 * hw_init flag is false 382 */ 383 if (rt715->hw_init || status != SDW_SLAVE_ATTACHED) 384 return 0; 385 386 /* perform I/O transfers required for Slave initialization */ 387 return rt715_io_init(&slave->dev, slave); 388 } 389 390 static int rt715_read_prop(struct sdw_slave *slave) 391 { 392 struct sdw_slave_prop *prop = &slave->prop; 393 int nval, i; 394 u32 bit; 395 unsigned long addr; 396 struct sdw_dpn_prop *dpn; 397 398 prop->scp_int1_mask = SDW_SCP_INT1_IMPL_DEF | SDW_SCP_INT1_BUS_CLASH | 399 SDW_SCP_INT1_PARITY; 400 prop->quirks = SDW_SLAVE_QUIRKS_INVALID_INITIAL_PARITY; 401 402 prop->paging_support = false; 403 404 /* first we need to allocate memory for set bits in port lists */ 405 prop->source_ports = 0x50;/* BITMAP: 01010000 */ 406 prop->sink_ports = 0x0; /* BITMAP: 00000000 */ 407 408 nval = hweight32(prop->source_ports); 409 prop->src_dpn_prop = devm_kcalloc(&slave->dev, nval, 410 sizeof(*prop->src_dpn_prop), 411 GFP_KERNEL); 412 if (!prop->src_dpn_prop) 413 return -ENOMEM; 414 415 dpn = prop->src_dpn_prop; 416 i = 0; 417 addr = prop->source_ports; 418 for_each_set_bit(bit, &addr, 32) { 419 dpn[i].num = bit; 420 dpn[i].simple_ch_prep_sm = true; 421 dpn[i].ch_prep_timeout = 10; 422 i++; 423 } 424 425 /* set the timeout values */ 426 prop->clk_stop_timeout = 20; 427 428 /* wake-up event */ 429 prop->wake_capable = 1; 430 431 return 0; 432 } 433 434 static int rt715_bus_config(struct sdw_slave *slave, 435 struct sdw_bus_params *params) 436 { 437 struct rt715_priv *rt715 = dev_get_drvdata(&slave->dev); 438 int ret; 439 440 memcpy(&rt715->params, params, sizeof(*params)); 441 442 ret = rt715_clock_config(&slave->dev); 443 if (ret < 0) 444 dev_err(&slave->dev, "%s: Invalid clk config", __func__); 445 446 return 0; 447 } 448 449 static const struct sdw_slave_ops rt715_slave_ops = { 450 .read_prop = rt715_read_prop, 451 .update_status = rt715_update_status, 452 .bus_config = rt715_bus_config, 453 }; 454 455 static int rt715_sdw_probe(struct sdw_slave *slave, 456 const struct sdw_device_id *id) 457 { 458 struct regmap *sdw_regmap, *regmap; 459 460 /* Regmap Initialization */ 461 sdw_regmap = devm_regmap_init_sdw(slave, &rt715_sdw_regmap); 462 if (IS_ERR(sdw_regmap)) 463 return PTR_ERR(sdw_regmap); 464 465 regmap = devm_regmap_init(&slave->dev, NULL, &slave->dev, 466 &rt715_regmap); 467 if (IS_ERR(regmap)) 468 return PTR_ERR(regmap); 469 470 return rt715_init(&slave->dev, sdw_regmap, regmap, slave); 471 } 472 473 static void rt715_sdw_remove(struct sdw_slave *slave) 474 { 475 pm_runtime_disable(&slave->dev); 476 } 477 478 static const struct sdw_device_id rt715_id[] = { 479 SDW_SLAVE_ENTRY_EXT(0x025d, 0x714, 0x2, 0, 0), 480 SDW_SLAVE_ENTRY_EXT(0x025d, 0x715, 0x2, 0, 0), 481 {}, 482 }; 483 MODULE_DEVICE_TABLE(sdw, rt715_id); 484 485 static int rt715_dev_suspend(struct device *dev) 486 { 487 struct rt715_priv *rt715 = dev_get_drvdata(dev); 488 489 if (!rt715->hw_init) 490 return 0; 491 492 regcache_cache_only(rt715->regmap, true); 493 494 return 0; 495 } 496 497 #define RT715_PROBE_TIMEOUT 5000 498 499 static int rt715_dev_resume(struct device *dev) 500 { 501 struct sdw_slave *slave = dev_to_sdw_dev(dev); 502 struct rt715_priv *rt715 = dev_get_drvdata(dev); 503 int ret; 504 505 if (!rt715->first_hw_init) 506 return 0; 507 508 ret = sdw_slave_wait_for_init(slave, RT715_PROBE_TIMEOUT); 509 if (ret) { 510 sdw_show_ping_status(slave->bus, true); 511 return ret; 512 } 513 514 regcache_cache_only(rt715->regmap, false); 515 regcache_sync_region(rt715->regmap, 0x3000, 0x8fff); 516 regcache_sync_region(rt715->regmap, 0x752039, 0x752039); 517 518 return 0; 519 } 520 521 static const struct dev_pm_ops rt715_pm = { 522 SYSTEM_SLEEP_PM_OPS(rt715_dev_suspend, rt715_dev_resume) 523 RUNTIME_PM_OPS(rt715_dev_suspend, rt715_dev_resume, NULL) 524 }; 525 526 static struct sdw_driver rt715_sdw_driver = { 527 .driver = { 528 .name = "rt715", 529 .pm = pm_ptr(&rt715_pm), 530 }, 531 .probe = rt715_sdw_probe, 532 .remove = rt715_sdw_remove, 533 .ops = &rt715_slave_ops, 534 .id_table = rt715_id, 535 }; 536 module_sdw_driver(rt715_sdw_driver); 537 538 MODULE_DESCRIPTION("ASoC RT715 driver SDW"); 539 MODULE_AUTHOR("Jack Yu <jack.yu@realtek.com>"); 540 MODULE_LICENSE("GPL v2"); 541