1 // SPDX-License-Identifier: GPL-2.0-only 2 // 3 // CS35L56 ALSA SoC audio driver SoundWire binding 4 // 5 // Copyright (C) 2023 Cirrus Logic, Inc. and 6 // Cirrus Logic International Semiconductor Ltd. 7 8 #include <linux/delay.h> 9 #include <linux/device.h> 10 #include <linux/err.h> 11 #include <linux/module.h> 12 #include <linux/pm_runtime.h> 13 #include <linux/regmap.h> 14 #include <linux/soundwire/sdw.h> 15 #include <linux/soundwire/sdw_registers.h> 16 #include <linux/soundwire/sdw_type.h> 17 #include <linux/swab.h> 18 #include <linux/types.h> 19 #include <linux/workqueue.h> 20 21 #include "cs35l56.h" 22 23 /* Register addresses are offset when sent over SoundWire */ 24 #define CS35L56_SDW_ADDR_OFFSET 0x8000 25 26 /* Cirrus bus bridge registers */ 27 #define CS35L56_SDW_MEM_ACCESS_STATUS 0xd0 28 #define CS35L56_SDW_MEM_READ_DATA 0xd8 29 30 #define CS35L56_SDW_LAST_LATE BIT(3) 31 #define CS35L56_SDW_CMD_IN_PROGRESS BIT(2) 32 #define CS35L56_SDW_RDATA_RDY BIT(0) 33 34 #define CS35L56_LATE_READ_POLL_US 10 35 #define CS35L56_LATE_READ_TIMEOUT_US 1000 36 37 static int cs35l56_sdw_poll_mem_status(struct sdw_slave *peripheral, 38 unsigned int mask, 39 unsigned int match) 40 { 41 int ret, val; 42 43 ret = read_poll_timeout(sdw_read_no_pm, val, 44 (val < 0) || ((val & mask) == match), 45 CS35L56_LATE_READ_POLL_US, CS35L56_LATE_READ_TIMEOUT_US, 46 false, peripheral, CS35L56_SDW_MEM_ACCESS_STATUS); 47 if (ret < 0) 48 return ret; 49 50 if (val < 0) 51 return val; 52 53 return 0; 54 } 55 56 static int cs35l56_sdw_slow_read(struct sdw_slave *peripheral, unsigned int reg, 57 u8 *buf, size_t val_size) 58 { 59 int ret, i; 60 61 reg += CS35L56_SDW_ADDR_OFFSET; 62 63 for (i = 0; i < val_size; i += sizeof(u32)) { 64 /* Poll for bus bridge idle */ 65 ret = cs35l56_sdw_poll_mem_status(peripheral, 66 CS35L56_SDW_CMD_IN_PROGRESS, 67 0); 68 if (ret < 0) { 69 dev_err(&peripheral->dev, "!CMD_IN_PROGRESS fail: %d\n", ret); 70 return ret; 71 } 72 73 /* Reading LSByte triggers read of register to holding buffer */ 74 sdw_read_no_pm(peripheral, reg + i); 75 76 /* Wait for data available */ 77 ret = cs35l56_sdw_poll_mem_status(peripheral, 78 CS35L56_SDW_RDATA_RDY, 79 CS35L56_SDW_RDATA_RDY); 80 if (ret < 0) { 81 dev_err(&peripheral->dev, "RDATA_RDY fail: %d\n", ret); 82 return ret; 83 } 84 85 /* Read data from buffer */ 86 ret = sdw_nread_no_pm(peripheral, CS35L56_SDW_MEM_READ_DATA, 87 sizeof(u32), &buf[i]); 88 if (ret) { 89 dev_err(&peripheral->dev, "Late read @%#x failed: %d\n", reg + i, ret); 90 return ret; 91 } 92 93 swab32s((u32 *)&buf[i]); 94 } 95 96 return 0; 97 } 98 99 static int cs35l56_sdw_read_one(struct sdw_slave *peripheral, unsigned int reg, void *buf) 100 { 101 int ret; 102 103 ret = sdw_nread_no_pm(peripheral, reg, 4, (u8 *)buf); 104 if (ret != 0) { 105 dev_err(&peripheral->dev, "Read failed @%#x:%d\n", reg, ret); 106 return ret; 107 } 108 109 swab32s((u32 *)buf); 110 111 return 0; 112 } 113 114 static int cs35l56_sdw_read(void *context, const void *reg_buf, 115 const size_t reg_size, void *val_buf, 116 size_t val_size) 117 { 118 struct sdw_slave *peripheral = context; 119 u8 *buf8 = val_buf; 120 unsigned int reg, bytes; 121 int ret; 122 123 reg = le32_to_cpu(*(const __le32 *)reg_buf); 124 125 if (cs35l56_is_otp_register(reg)) 126 return cs35l56_sdw_slow_read(peripheral, reg, buf8, val_size); 127 128 reg += CS35L56_SDW_ADDR_OFFSET; 129 130 if (val_size == 4) 131 return cs35l56_sdw_read_one(peripheral, reg, val_buf); 132 133 while (val_size) { 134 bytes = SDW_REG_NO_PAGE - (reg & SDW_REGADDR); /* to end of page */ 135 if (bytes > val_size) 136 bytes = val_size; 137 138 ret = sdw_nread_no_pm(peripheral, reg, bytes, buf8); 139 if (ret != 0) { 140 dev_err(&peripheral->dev, "Read failed @%#x..%#x:%d\n", 141 reg, reg + bytes - 1, ret); 142 return ret; 143 } 144 145 swab32_array((u32 *)buf8, bytes / 4); 146 val_size -= bytes; 147 reg += bytes; 148 buf8 += bytes; 149 } 150 151 return 0; 152 } 153 154 static inline void cs35l56_swab_copy(void *dest, const void *src, size_t nbytes) 155 { 156 u32 *dest32 = dest; 157 const u32 *src32 = src; 158 159 for (; nbytes > 0; nbytes -= 4) 160 *dest32++ = swab32(*src32++); 161 } 162 163 static int cs35l56_sdw_write_one(struct sdw_slave *peripheral, unsigned int reg, const void *buf) 164 { 165 u32 val_le = swab32(*(u32 *)buf); 166 int ret; 167 168 ret = sdw_nwrite_no_pm(peripheral, reg, 4, (u8 *)&val_le); 169 if (ret != 0) { 170 dev_err(&peripheral->dev, "Write failed @%#x:%d\n", reg, ret); 171 return ret; 172 } 173 174 return 0; 175 } 176 177 static int cs35l56_sdw_gather_write(void *context, 178 const void *reg_buf, size_t reg_size, 179 const void *val_buf, size_t val_size) 180 { 181 struct sdw_slave *peripheral = context; 182 const u8 *src_be = val_buf; 183 u32 val_le_buf[64]; /* Define u32 so it is 32-bit aligned */ 184 unsigned int reg, bytes; 185 int ret; 186 187 reg = le32_to_cpu(*(const __le32 *)reg_buf); 188 reg += CS35L56_SDW_ADDR_OFFSET; 189 190 if (val_size == 4) 191 return cs35l56_sdw_write_one(peripheral, reg, src_be); 192 193 while (val_size) { 194 bytes = SDW_REG_NO_PAGE - (reg & SDW_REGADDR); /* to end of page */ 195 if (bytes > val_size) 196 bytes = val_size; 197 if (bytes > sizeof(val_le_buf)) 198 bytes = sizeof(val_le_buf); 199 200 cs35l56_swab_copy(val_le_buf, src_be, bytes); 201 202 ret = sdw_nwrite_no_pm(peripheral, reg, bytes, (u8 *)val_le_buf); 203 if (ret != 0) { 204 dev_err(&peripheral->dev, "Write failed @%#x..%#x:%d\n", 205 reg, reg + bytes - 1, ret); 206 return ret; 207 } 208 209 val_size -= bytes; 210 reg += bytes; 211 src_be += bytes; 212 } 213 214 return 0; 215 } 216 217 static int cs35l56_sdw_write(void *context, const void *val_buf, size_t val_size) 218 { 219 const u8 *src_buf = val_buf; 220 221 /* First word of val_buf contains the destination address */ 222 return cs35l56_sdw_gather_write(context, &src_buf[0], 4, &src_buf[4], val_size - 4); 223 } 224 225 /* 226 * Registers are big-endian on I2C and SPI but little-endian on SoundWire. 227 * Exported firmware controls are big-endian on I2C/SPI but little-endian on 228 * SoundWire. Firmware files are always big-endian and are opaque blobs. 229 * Present a big-endian regmap and hide the endianness swap, so that the ALSA 230 * byte controls always have the same byte order, and firmware file blobs 231 * can be written verbatim. 232 */ 233 static const struct regmap_bus cs35l56_regmap_bus_sdw = { 234 .read = cs35l56_sdw_read, 235 .write = cs35l56_sdw_write, 236 .gather_write = cs35l56_sdw_gather_write, 237 .reg_format_endian_default = REGMAP_ENDIAN_LITTLE, 238 .val_format_endian_default = REGMAP_ENDIAN_BIG, 239 }; 240 241 static int cs35l56_sdw_get_unique_id(struct cs35l56_private *cs35l56) 242 { 243 int ret; 244 245 ret = sdw_read_no_pm(cs35l56->sdw_peripheral, SDW_SCP_DEVID_0); 246 if (ret < 0) 247 return ret; 248 249 cs35l56->sdw_unique_id = ret & 0xf; 250 251 return 0; 252 } 253 254 static void cs35l56_sdw_init(struct sdw_slave *peripheral) 255 { 256 struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev); 257 int ret; 258 259 pm_runtime_get_noresume(cs35l56->base.dev); 260 261 ret = cs35l56_sdw_get_unique_id(cs35l56); 262 if (ret) 263 goto out; 264 265 /* SoundWire UniqueId is used to index the calibration array */ 266 if (cs35l56->base.cal_index < 0) 267 cs35l56->base.cal_index = cs35l56->sdw_unique_id; 268 269 ret = cs35l56_init(cs35l56); 270 if (ret < 0) { 271 regcache_cache_only(cs35l56->base.regmap, true); 272 goto out; 273 } 274 275 /* 276 * cs35l56_init can return with !init_done if it triggered 277 * a soft reset. 278 */ 279 if (cs35l56->base.init_done) { 280 /* Enable SoundWire interrupts */ 281 sdw_write_no_pm(peripheral, CS35L56_SDW_GEN_INT_MASK_1, 282 CS35L56_SDW_INT_MASK_CODEC_IRQ); 283 } 284 285 out: 286 pm_runtime_mark_last_busy(cs35l56->base.dev); 287 pm_runtime_put_autosuspend(cs35l56->base.dev); 288 } 289 290 static int cs35l56_sdw_interrupt(struct sdw_slave *peripheral, 291 struct sdw_slave_intr_status *status) 292 { 293 struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev); 294 295 /* SoundWire core holds our pm_runtime when calling this function. */ 296 297 dev_dbg(cs35l56->base.dev, "int control_port=%#x\n", status->control_port); 298 299 if ((status->control_port & SDW_SCP_INT1_IMPL_DEF) == 0) 300 return 0; 301 302 /* 303 * Prevent bus manager suspending and possibly issuing a 304 * bus-reset before the queued work has run. 305 */ 306 pm_runtime_get_noresume(cs35l56->base.dev); 307 308 /* 309 * Mask and clear until it has been handled. The read of GEN_INT_STAT_1 310 * is required as per the SoundWire spec for interrupt status bits 311 * to clear. GEN_INT_MASK_1 masks the _inputs_ to GEN_INT_STAT1. 312 * None of the interrupts are time-critical so use the 313 * power-efficient queue. 314 */ 315 sdw_write_no_pm(peripheral, CS35L56_SDW_GEN_INT_MASK_1, 0); 316 sdw_read_no_pm(peripheral, CS35L56_SDW_GEN_INT_STAT_1); 317 sdw_write_no_pm(peripheral, CS35L56_SDW_GEN_INT_STAT_1, 0xFF); 318 queue_work(system_power_efficient_wq, &cs35l56->sdw_irq_work); 319 320 return 0; 321 } 322 323 static void cs35l56_sdw_irq_work(struct work_struct *work) 324 { 325 struct cs35l56_private *cs35l56 = container_of(work, 326 struct cs35l56_private, 327 sdw_irq_work); 328 329 cs35l56_irq(-1, &cs35l56->base); 330 331 /* unmask interrupts */ 332 if (!cs35l56->sdw_irq_no_unmask) 333 sdw_write_no_pm(cs35l56->sdw_peripheral, CS35L56_SDW_GEN_INT_MASK_1, 334 CS35L56_SDW_INT_MASK_CODEC_IRQ); 335 336 pm_runtime_put_autosuspend(cs35l56->base.dev); 337 } 338 339 static int cs35l56_sdw_read_prop(struct sdw_slave *peripheral) 340 { 341 struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev); 342 struct sdw_slave_prop *prop = &peripheral->prop; 343 struct sdw_dpn_prop *ports; 344 345 ports = devm_kcalloc(cs35l56->base.dev, 2, sizeof(*ports), GFP_KERNEL); 346 if (!ports) 347 return -ENOMEM; 348 349 prop->source_ports = BIT(CS35L56_SDW1_CAPTURE_PORT); 350 prop->sink_ports = BIT(CS35L56_SDW1_PLAYBACK_PORT); 351 prop->paging_support = true; 352 prop->quirks = SDW_SLAVE_QUIRKS_INVALID_INITIAL_PARITY; 353 prop->scp_int1_mask = SDW_SCP_INT1_BUS_CLASH | SDW_SCP_INT1_PARITY | SDW_SCP_INT1_IMPL_DEF; 354 355 /* DP1 - playback */ 356 ports[0].num = CS35L56_SDW1_PLAYBACK_PORT; 357 ports[0].type = SDW_DPN_FULL; 358 ports[0].ch_prep_timeout = 10; 359 prop->sink_dpn_prop = &ports[0]; 360 361 /* DP3 - capture */ 362 ports[1].num = CS35L56_SDW1_CAPTURE_PORT; 363 ports[1].type = SDW_DPN_FULL; 364 ports[1].ch_prep_timeout = 10; 365 prop->src_dpn_prop = &ports[1]; 366 367 return 0; 368 } 369 370 static int cs35l56_sdw_update_status(struct sdw_slave *peripheral, 371 enum sdw_slave_status status) 372 { 373 struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev); 374 375 switch (status) { 376 case SDW_SLAVE_ATTACHED: 377 dev_dbg(cs35l56->base.dev, "%s: ATTACHED\n", __func__); 378 if (cs35l56->sdw_attached) 379 break; 380 381 if (!cs35l56->base.init_done || cs35l56->soft_resetting) 382 cs35l56_sdw_init(peripheral); 383 384 cs35l56->sdw_attached = true; 385 break; 386 case SDW_SLAVE_UNATTACHED: 387 dev_dbg(cs35l56->base.dev, "%s: UNATTACHED\n", __func__); 388 cs35l56->sdw_attached = false; 389 break; 390 default: 391 break; 392 } 393 394 return 0; 395 } 396 397 static int cs35l63_sdw_kick_divider(struct cs35l56_private *cs35l56, 398 struct sdw_slave *peripheral) 399 { 400 unsigned int curr_scale_reg, next_scale_reg; 401 int curr_scale, next_scale, ret; 402 403 if (!cs35l56->base.init_done) 404 return 0; 405 406 if (peripheral->bus->params.curr_bank) { 407 curr_scale_reg = SDW_SCP_BUSCLOCK_SCALE_B1; 408 next_scale_reg = SDW_SCP_BUSCLOCK_SCALE_B0; 409 } else { 410 curr_scale_reg = SDW_SCP_BUSCLOCK_SCALE_B0; 411 next_scale_reg = SDW_SCP_BUSCLOCK_SCALE_B1; 412 } 413 414 /* 415 * Current clock scale value must be different to new value. 416 * Modify current to guarantee this. If next still has the dummy 417 * value we wrote when it was current, the core code has not set 418 * a new scale so restore its original good value 419 */ 420 curr_scale = sdw_read_no_pm(peripheral, curr_scale_reg); 421 if (curr_scale < 0) { 422 dev_err(cs35l56->base.dev, "Failed to read current clock scale: %d\n", curr_scale); 423 return curr_scale; 424 } 425 426 next_scale = sdw_read_no_pm(peripheral, next_scale_reg); 427 if (next_scale < 0) { 428 dev_err(cs35l56->base.dev, "Failed to read next clock scale: %d\n", next_scale); 429 return next_scale; 430 } 431 432 if (next_scale == CS35L56_SDW_INVALID_BUS_SCALE) { 433 next_scale = cs35l56->old_sdw_clock_scale; 434 ret = sdw_write_no_pm(peripheral, next_scale_reg, next_scale); 435 if (ret < 0) { 436 dev_err(cs35l56->base.dev, "Failed to modify current clock scale: %d\n", 437 ret); 438 return ret; 439 } 440 } 441 442 cs35l56->old_sdw_clock_scale = curr_scale; 443 ret = sdw_write_no_pm(peripheral, curr_scale_reg, CS35L56_SDW_INVALID_BUS_SCALE); 444 if (ret < 0) { 445 dev_err(cs35l56->base.dev, "Failed to modify current clock scale: %d\n", ret); 446 return ret; 447 } 448 449 dev_dbg(cs35l56->base.dev, "Next bus scale: %#x\n", next_scale); 450 451 return 0; 452 } 453 454 static int cs35l56_sdw_bus_config(struct sdw_slave *peripheral, 455 struct sdw_bus_params *params) 456 { 457 struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev); 458 459 if ((cs35l56->base.type == 0x63) && (cs35l56->base.rev < 0xa1)) 460 return cs35l63_sdw_kick_divider(cs35l56, peripheral); 461 462 return 0; 463 } 464 465 static int __maybe_unused cs35l56_sdw_clk_stop(struct sdw_slave *peripheral, 466 enum sdw_clk_stop_mode mode, 467 enum sdw_clk_stop_type type) 468 { 469 struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev); 470 471 dev_dbg(cs35l56->base.dev, "%s: mode:%d type:%d\n", __func__, mode, type); 472 473 return 0; 474 } 475 476 static const struct sdw_slave_ops cs35l56_sdw_ops = { 477 .read_prop = cs35l56_sdw_read_prop, 478 .interrupt_callback = cs35l56_sdw_interrupt, 479 .update_status = cs35l56_sdw_update_status, 480 .bus_config = cs35l56_sdw_bus_config, 481 #ifdef DEBUG 482 .clk_stop = cs35l56_sdw_clk_stop, 483 #endif 484 }; 485 486 static int __maybe_unused cs35l56_sdw_handle_unattach(struct cs35l56_private *cs35l56) 487 { 488 struct sdw_slave *peripheral = cs35l56->sdw_peripheral; 489 490 if (peripheral->unattach_request) { 491 /* Cannot access registers until bus is re-initialized. */ 492 dev_dbg(cs35l56->base.dev, "Wait for initialization_complete\n"); 493 if (!wait_for_completion_timeout(&peripheral->initialization_complete, 494 msecs_to_jiffies(5000))) { 495 dev_err(cs35l56->base.dev, "initialization_complete timed out\n"); 496 return -ETIMEDOUT; 497 } 498 499 peripheral->unattach_request = 0; 500 501 /* 502 * Don't call regcache_mark_dirty(), we can't be sure that the 503 * Manager really did issue a Bus Reset. 504 */ 505 } 506 507 return 0; 508 } 509 510 static int __maybe_unused cs35l56_sdw_runtime_suspend(struct device *dev) 511 { 512 struct cs35l56_private *cs35l56 = dev_get_drvdata(dev); 513 514 if (!cs35l56->base.init_done) 515 return 0; 516 517 return cs35l56_runtime_suspend_common(&cs35l56->base); 518 } 519 520 static int __maybe_unused cs35l56_sdw_runtime_resume(struct device *dev) 521 { 522 struct cs35l56_private *cs35l56 = dev_get_drvdata(dev); 523 int ret; 524 525 dev_dbg(dev, "Runtime resume\n"); 526 527 if (!cs35l56->base.init_done) 528 return 0; 529 530 ret = cs35l56_sdw_handle_unattach(cs35l56); 531 if (ret < 0) 532 return ret; 533 534 ret = cs35l56_runtime_resume_common(&cs35l56->base, true); 535 if (ret) 536 return ret; 537 538 /* Re-enable SoundWire interrupts */ 539 sdw_write_no_pm(cs35l56->sdw_peripheral, CS35L56_SDW_GEN_INT_MASK_1, 540 CS35L56_SDW_INT_MASK_CODEC_IRQ); 541 542 return 0; 543 } 544 545 static int __maybe_unused cs35l56_sdw_system_suspend(struct device *dev) 546 { 547 struct cs35l56_private *cs35l56 = dev_get_drvdata(dev); 548 549 if (!cs35l56->base.init_done) 550 return 0; 551 552 /* 553 * Disable SoundWire interrupts. 554 * Flush - don't cancel because that could leave an unbalanced pm_runtime_get. 555 */ 556 cs35l56->sdw_irq_no_unmask = true; 557 flush_work(&cs35l56->sdw_irq_work); 558 559 /* Mask interrupts and flush in case sdw_irq_work was queued again */ 560 sdw_write_no_pm(cs35l56->sdw_peripheral, CS35L56_SDW_GEN_INT_MASK_1, 0); 561 sdw_read_no_pm(cs35l56->sdw_peripheral, CS35L56_SDW_GEN_INT_STAT_1); 562 sdw_write_no_pm(cs35l56->sdw_peripheral, CS35L56_SDW_GEN_INT_STAT_1, 0xFF); 563 flush_work(&cs35l56->sdw_irq_work); 564 565 return cs35l56_system_suspend(dev); 566 } 567 568 static int __maybe_unused cs35l56_sdw_system_resume(struct device *dev) 569 { 570 struct cs35l56_private *cs35l56 = dev_get_drvdata(dev); 571 572 cs35l56->sdw_irq_no_unmask = false; 573 /* runtime_resume re-enables the interrupt */ 574 575 return cs35l56_system_resume(dev); 576 } 577 578 static int cs35l56_sdw_probe(struct sdw_slave *peripheral, const struct sdw_device_id *id) 579 { 580 struct device *dev = &peripheral->dev; 581 struct cs35l56_private *cs35l56; 582 const struct regmap_config *regmap_config; 583 int ret; 584 585 cs35l56 = devm_kzalloc(dev, sizeof(*cs35l56), GFP_KERNEL); 586 if (!cs35l56) 587 return -ENOMEM; 588 589 cs35l56->base.dev = dev; 590 cs35l56->sdw_peripheral = peripheral; 591 cs35l56->sdw_link_num = peripheral->bus->link_id; 592 INIT_WORK(&cs35l56->sdw_irq_work, cs35l56_sdw_irq_work); 593 594 dev_set_drvdata(dev, cs35l56); 595 596 switch ((unsigned int)id->driver_data) { 597 case 0x3556: 598 case 0x3557: 599 regmap_config = &cs35l56_regmap_sdw; 600 cs35l56->base.fw_reg = &cs35l56_fw_reg; 601 break; 602 case 0x3563: 603 regmap_config = &cs35l63_regmap_sdw; 604 cs35l56->base.fw_reg = &cs35l63_fw_reg; 605 break; 606 default: 607 return -ENODEV; 608 } 609 610 cs35l56->base.regmap = devm_regmap_init(dev, &cs35l56_regmap_bus_sdw, 611 peripheral, regmap_config); 612 if (IS_ERR(cs35l56->base.regmap)) { 613 ret = PTR_ERR(cs35l56->base.regmap); 614 return dev_err_probe(dev, ret, "Failed to allocate register map\n"); 615 } 616 617 /* Start in cache-only until device is enumerated */ 618 regcache_cache_only(cs35l56->base.regmap, true); 619 620 ret = cs35l56_common_probe(cs35l56); 621 if (ret != 0) 622 return ret; 623 624 return 0; 625 } 626 627 static int cs35l56_sdw_remove(struct sdw_slave *peripheral) 628 { 629 struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev); 630 631 /* Disable SoundWire interrupts */ 632 cs35l56->sdw_irq_no_unmask = true; 633 cancel_work_sync(&cs35l56->sdw_irq_work); 634 sdw_write_no_pm(peripheral, CS35L56_SDW_GEN_INT_MASK_1, 0); 635 sdw_read_no_pm(peripheral, CS35L56_SDW_GEN_INT_STAT_1); 636 sdw_write_no_pm(peripheral, CS35L56_SDW_GEN_INT_STAT_1, 0xFF); 637 638 cs35l56_remove(cs35l56); 639 640 return 0; 641 } 642 643 static const struct dev_pm_ops cs35l56_sdw_pm = { 644 SET_RUNTIME_PM_OPS(cs35l56_sdw_runtime_suspend, cs35l56_sdw_runtime_resume, NULL) 645 SYSTEM_SLEEP_PM_OPS(cs35l56_sdw_system_suspend, cs35l56_sdw_system_resume) 646 LATE_SYSTEM_SLEEP_PM_OPS(cs35l56_system_suspend_late, cs35l56_system_resume_early) 647 /* NOIRQ stage not needed, SoundWire doesn't use a hard IRQ */ 648 }; 649 650 static const struct sdw_device_id cs35l56_sdw_id[] = { 651 SDW_SLAVE_ENTRY(0x01FA, 0x3556, 0x3556), 652 SDW_SLAVE_ENTRY(0x01FA, 0x3557, 0x3557), 653 SDW_SLAVE_ENTRY(0x01FA, 0x3563, 0x3563), 654 {}, 655 }; 656 MODULE_DEVICE_TABLE(sdw, cs35l56_sdw_id); 657 658 static struct sdw_driver cs35l56_sdw_driver = { 659 .driver = { 660 .name = "cs35l56", 661 .pm = pm_ptr(&cs35l56_sdw_pm), 662 }, 663 .probe = cs35l56_sdw_probe, 664 .remove = cs35l56_sdw_remove, 665 .ops = &cs35l56_sdw_ops, 666 .id_table = cs35l56_sdw_id, 667 }; 668 669 module_sdw_driver(cs35l56_sdw_driver); 670 671 MODULE_DESCRIPTION("ASoC CS35L56 SoundWire driver"); 672 MODULE_IMPORT_NS("SND_SOC_CS35L56_CORE"); 673 MODULE_IMPORT_NS("SND_SOC_CS35L56_SHARED"); 674 MODULE_AUTHOR("Richard Fitzgerald <rf@opensource.cirrus.com>"); 675 MODULE_AUTHOR("Simon Trimmer <simont@opensource.cirrus.com>"); 676 MODULE_LICENSE("GPL"); 677