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 static int cs35l56_sdw_read_one(struct sdw_slave *peripheral, unsigned int reg, void *buf) 27 { 28 int ret; 29 30 ret = sdw_nread_no_pm(peripheral, reg, 4, (u8 *)buf); 31 if (ret != 0) { 32 dev_err(&peripheral->dev, "Read failed @%#x:%d\n", reg, ret); 33 return ret; 34 } 35 36 swab32s((u32 *)buf); 37 38 return 0; 39 } 40 41 static int cs35l56_sdw_read(void *context, const void *reg_buf, 42 const size_t reg_size, void *val_buf, 43 size_t val_size) 44 { 45 struct sdw_slave *peripheral = context; 46 u8 *buf8 = val_buf; 47 unsigned int reg, bytes; 48 int ret; 49 50 reg = le32_to_cpu(*(const __le32 *)reg_buf); 51 reg += CS35L56_SDW_ADDR_OFFSET; 52 53 if (val_size == 4) 54 return cs35l56_sdw_read_one(peripheral, reg, val_buf); 55 56 while (val_size) { 57 bytes = SDW_REG_NO_PAGE - (reg & SDW_REGADDR); /* to end of page */ 58 if (bytes > val_size) 59 bytes = val_size; 60 61 ret = sdw_nread_no_pm(peripheral, reg, bytes, buf8); 62 if (ret != 0) { 63 dev_err(&peripheral->dev, "Read failed @%#x..%#x:%d\n", 64 reg, reg + bytes - 1, ret); 65 return ret; 66 } 67 68 swab32_array((u32 *)buf8, bytes / 4); 69 val_size -= bytes; 70 reg += bytes; 71 buf8 += bytes; 72 } 73 74 return 0; 75 } 76 77 static inline void cs35l56_swab_copy(void *dest, const void *src, size_t nbytes) 78 { 79 u32 *dest32 = dest; 80 const u32 *src32 = src; 81 82 for (; nbytes > 0; nbytes -= 4) 83 *dest32++ = swab32(*src32++); 84 } 85 86 static int cs35l56_sdw_write_one(struct sdw_slave *peripheral, unsigned int reg, const void *buf) 87 { 88 u32 val_le = swab32(*(u32 *)buf); 89 int ret; 90 91 ret = sdw_nwrite_no_pm(peripheral, reg, 4, (u8 *)&val_le); 92 if (ret != 0) { 93 dev_err(&peripheral->dev, "Write failed @%#x:%d\n", reg, ret); 94 return ret; 95 } 96 97 return 0; 98 } 99 100 static int cs35l56_sdw_gather_write(void *context, 101 const void *reg_buf, size_t reg_size, 102 const void *val_buf, size_t val_size) 103 { 104 struct sdw_slave *peripheral = context; 105 const u8 *src_be = val_buf; 106 u32 val_le_buf[64]; /* Define u32 so it is 32-bit aligned */ 107 unsigned int reg, bytes; 108 int ret; 109 110 reg = le32_to_cpu(*(const __le32 *)reg_buf); 111 reg += CS35L56_SDW_ADDR_OFFSET; 112 113 if (val_size == 4) 114 return cs35l56_sdw_write_one(peripheral, reg, src_be); 115 116 while (val_size) { 117 bytes = SDW_REG_NO_PAGE - (reg & SDW_REGADDR); /* to end of page */ 118 if (bytes > val_size) 119 bytes = val_size; 120 if (bytes > sizeof(val_le_buf)) 121 bytes = sizeof(val_le_buf); 122 123 cs35l56_swab_copy(val_le_buf, src_be, bytes); 124 125 ret = sdw_nwrite_no_pm(peripheral, reg, bytes, (u8 *)val_le_buf); 126 if (ret != 0) { 127 dev_err(&peripheral->dev, "Write failed @%#x..%#x:%d\n", 128 reg, reg + bytes - 1, ret); 129 return ret; 130 } 131 132 val_size -= bytes; 133 reg += bytes; 134 src_be += bytes; 135 } 136 137 return 0; 138 } 139 140 static int cs35l56_sdw_write(void *context, const void *val_buf, size_t val_size) 141 { 142 const u8 *src_buf = val_buf; 143 144 /* First word of val_buf contains the destination address */ 145 return cs35l56_sdw_gather_write(context, &src_buf[0], 4, &src_buf[4], val_size - 4); 146 } 147 148 /* 149 * Registers are big-endian on I2C and SPI but little-endian on SoundWire. 150 * Exported firmware controls are big-endian on I2C/SPI but little-endian on 151 * SoundWire. Firmware files are always big-endian and are opaque blobs. 152 * Present a big-endian regmap and hide the endianness swap, so that the ALSA 153 * byte controls always have the same byte order, and firmware file blobs 154 * can be written verbatim. 155 */ 156 static const struct regmap_bus cs35l56_regmap_bus_sdw = { 157 .read = cs35l56_sdw_read, 158 .write = cs35l56_sdw_write, 159 .gather_write = cs35l56_sdw_gather_write, 160 .reg_format_endian_default = REGMAP_ENDIAN_LITTLE, 161 .val_format_endian_default = REGMAP_ENDIAN_BIG, 162 }; 163 164 static int cs35l56_sdw_set_cal_index(struct cs35l56_private *cs35l56) 165 { 166 int ret; 167 168 /* SoundWire UniqueId is used to index the calibration array */ 169 ret = sdw_read_no_pm(cs35l56->sdw_peripheral, SDW_SCP_DEVID_0); 170 if (ret < 0) 171 return ret; 172 173 cs35l56->base.cal_index = ret & 0xf; 174 175 return 0; 176 } 177 178 static void cs35l56_sdw_init(struct sdw_slave *peripheral) 179 { 180 struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev); 181 int ret; 182 183 pm_runtime_get_noresume(cs35l56->base.dev); 184 185 if (cs35l56->base.cal_index < 0) { 186 ret = cs35l56_sdw_set_cal_index(cs35l56); 187 if (ret < 0) 188 goto out; 189 } 190 191 ret = cs35l56_init(cs35l56); 192 if (ret < 0) { 193 regcache_cache_only(cs35l56->base.regmap, true); 194 goto out; 195 } 196 197 /* 198 * cs35l56_init can return with !init_done if it triggered 199 * a soft reset. 200 */ 201 if (cs35l56->base.init_done) { 202 /* Enable SoundWire interrupts */ 203 sdw_write_no_pm(peripheral, CS35L56_SDW_GEN_INT_MASK_1, 204 CS35L56_SDW_INT_MASK_CODEC_IRQ); 205 } 206 207 out: 208 pm_runtime_mark_last_busy(cs35l56->base.dev); 209 pm_runtime_put_autosuspend(cs35l56->base.dev); 210 } 211 212 static int cs35l56_sdw_interrupt(struct sdw_slave *peripheral, 213 struct sdw_slave_intr_status *status) 214 { 215 struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev); 216 217 /* SoundWire core holds our pm_runtime when calling this function. */ 218 219 dev_dbg(cs35l56->base.dev, "int control_port=%#x\n", status->control_port); 220 221 if ((status->control_port & SDW_SCP_INT1_IMPL_DEF) == 0) 222 return 0; 223 224 /* 225 * Prevent bus manager suspending and possibly issuing a 226 * bus-reset before the queued work has run. 227 */ 228 pm_runtime_get_noresume(cs35l56->base.dev); 229 230 /* 231 * Mask and clear until it has been handled. The read of GEN_INT_STAT_1 232 * is required as per the SoundWire spec for interrupt status bits 233 * to clear. GEN_INT_MASK_1 masks the _inputs_ to GEN_INT_STAT1. 234 * None of the interrupts are time-critical so use the 235 * power-efficient queue. 236 */ 237 sdw_write_no_pm(peripheral, CS35L56_SDW_GEN_INT_MASK_1, 0); 238 sdw_read_no_pm(peripheral, CS35L56_SDW_GEN_INT_STAT_1); 239 sdw_write_no_pm(peripheral, CS35L56_SDW_GEN_INT_STAT_1, 0xFF); 240 queue_work(system_power_efficient_wq, &cs35l56->sdw_irq_work); 241 242 return 0; 243 } 244 245 static void cs35l56_sdw_irq_work(struct work_struct *work) 246 { 247 struct cs35l56_private *cs35l56 = container_of(work, 248 struct cs35l56_private, 249 sdw_irq_work); 250 251 cs35l56_irq(-1, &cs35l56->base); 252 253 /* unmask interrupts */ 254 if (!cs35l56->sdw_irq_no_unmask) 255 sdw_write_no_pm(cs35l56->sdw_peripheral, CS35L56_SDW_GEN_INT_MASK_1, 256 CS35L56_SDW_INT_MASK_CODEC_IRQ); 257 258 pm_runtime_put_autosuspend(cs35l56->base.dev); 259 } 260 261 static int cs35l56_sdw_read_prop(struct sdw_slave *peripheral) 262 { 263 struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev); 264 struct sdw_slave_prop *prop = &peripheral->prop; 265 struct sdw_dpn_prop *ports; 266 267 ports = devm_kcalloc(cs35l56->base.dev, 2, sizeof(*ports), GFP_KERNEL); 268 if (!ports) 269 return -ENOMEM; 270 271 prop->source_ports = BIT(CS35L56_SDW1_CAPTURE_PORT); 272 prop->sink_ports = BIT(CS35L56_SDW1_PLAYBACK_PORT); 273 prop->paging_support = true; 274 prop->quirks = SDW_SLAVE_QUIRKS_INVALID_INITIAL_PARITY; 275 prop->scp_int1_mask = SDW_SCP_INT1_BUS_CLASH | SDW_SCP_INT1_PARITY | SDW_SCP_INT1_IMPL_DEF; 276 277 /* DP1 - playback */ 278 ports[0].num = CS35L56_SDW1_PLAYBACK_PORT; 279 ports[0].type = SDW_DPN_FULL; 280 ports[0].ch_prep_timeout = 10; 281 prop->sink_dpn_prop = &ports[0]; 282 283 /* DP3 - capture */ 284 ports[1].num = CS35L56_SDW1_CAPTURE_PORT; 285 ports[1].type = SDW_DPN_FULL; 286 ports[1].ch_prep_timeout = 10; 287 prop->src_dpn_prop = &ports[1]; 288 289 return 0; 290 } 291 292 static int cs35l56_sdw_update_status(struct sdw_slave *peripheral, 293 enum sdw_slave_status status) 294 { 295 struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev); 296 297 switch (status) { 298 case SDW_SLAVE_ATTACHED: 299 dev_dbg(cs35l56->base.dev, "%s: ATTACHED\n", __func__); 300 if (cs35l56->sdw_attached) 301 break; 302 303 if (!cs35l56->base.init_done || cs35l56->soft_resetting) 304 cs35l56_sdw_init(peripheral); 305 306 cs35l56->sdw_attached = true; 307 break; 308 case SDW_SLAVE_UNATTACHED: 309 dev_dbg(cs35l56->base.dev, "%s: UNATTACHED\n", __func__); 310 cs35l56->sdw_attached = false; 311 break; 312 default: 313 break; 314 } 315 316 return 0; 317 } 318 319 static int __maybe_unused cs35l56_sdw_clk_stop(struct sdw_slave *peripheral, 320 enum sdw_clk_stop_mode mode, 321 enum sdw_clk_stop_type type) 322 { 323 struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev); 324 325 dev_dbg(cs35l56->base.dev, "%s: mode:%d type:%d\n", __func__, mode, type); 326 327 return 0; 328 } 329 330 static const struct sdw_slave_ops cs35l56_sdw_ops = { 331 .read_prop = cs35l56_sdw_read_prop, 332 .interrupt_callback = cs35l56_sdw_interrupt, 333 .update_status = cs35l56_sdw_update_status, 334 #ifdef DEBUG 335 .clk_stop = cs35l56_sdw_clk_stop, 336 #endif 337 }; 338 339 static int __maybe_unused cs35l56_sdw_handle_unattach(struct cs35l56_private *cs35l56) 340 { 341 struct sdw_slave *peripheral = cs35l56->sdw_peripheral; 342 343 if (peripheral->unattach_request) { 344 /* Cannot access registers until bus is re-initialized. */ 345 dev_dbg(cs35l56->base.dev, "Wait for initialization_complete\n"); 346 if (!wait_for_completion_timeout(&peripheral->initialization_complete, 347 msecs_to_jiffies(5000))) { 348 dev_err(cs35l56->base.dev, "initialization_complete timed out\n"); 349 return -ETIMEDOUT; 350 } 351 352 peripheral->unattach_request = 0; 353 354 /* 355 * Don't call regcache_mark_dirty(), we can't be sure that the 356 * Manager really did issue a Bus Reset. 357 */ 358 } 359 360 return 0; 361 } 362 363 static int __maybe_unused cs35l56_sdw_runtime_suspend(struct device *dev) 364 { 365 struct cs35l56_private *cs35l56 = dev_get_drvdata(dev); 366 367 if (!cs35l56->base.init_done) 368 return 0; 369 370 return cs35l56_runtime_suspend_common(&cs35l56->base); 371 } 372 373 static int __maybe_unused cs35l56_sdw_runtime_resume(struct device *dev) 374 { 375 struct cs35l56_private *cs35l56 = dev_get_drvdata(dev); 376 int ret; 377 378 dev_dbg(dev, "Runtime resume\n"); 379 380 if (!cs35l56->base.init_done) 381 return 0; 382 383 ret = cs35l56_sdw_handle_unattach(cs35l56); 384 if (ret < 0) 385 return ret; 386 387 ret = cs35l56_runtime_resume_common(&cs35l56->base, true); 388 if (ret) 389 return ret; 390 391 /* Re-enable SoundWire interrupts */ 392 sdw_write_no_pm(cs35l56->sdw_peripheral, CS35L56_SDW_GEN_INT_MASK_1, 393 CS35L56_SDW_INT_MASK_CODEC_IRQ); 394 395 return 0; 396 } 397 398 static int __maybe_unused cs35l56_sdw_system_suspend(struct device *dev) 399 { 400 struct cs35l56_private *cs35l56 = dev_get_drvdata(dev); 401 402 if (!cs35l56->base.init_done) 403 return 0; 404 405 /* 406 * Disable SoundWire interrupts. 407 * Flush - don't cancel because that could leave an unbalanced pm_runtime_get. 408 */ 409 cs35l56->sdw_irq_no_unmask = true; 410 flush_work(&cs35l56->sdw_irq_work); 411 412 /* Mask interrupts and flush in case sdw_irq_work was queued again */ 413 sdw_write_no_pm(cs35l56->sdw_peripheral, CS35L56_SDW_GEN_INT_MASK_1, 0); 414 sdw_read_no_pm(cs35l56->sdw_peripheral, CS35L56_SDW_GEN_INT_STAT_1); 415 sdw_write_no_pm(cs35l56->sdw_peripheral, CS35L56_SDW_GEN_INT_STAT_1, 0xFF); 416 flush_work(&cs35l56->sdw_irq_work); 417 418 return cs35l56_system_suspend(dev); 419 } 420 421 static int __maybe_unused cs35l56_sdw_system_resume(struct device *dev) 422 { 423 struct cs35l56_private *cs35l56 = dev_get_drvdata(dev); 424 425 cs35l56->sdw_irq_no_unmask = false; 426 /* runtime_resume re-enables the interrupt */ 427 428 return cs35l56_system_resume(dev); 429 } 430 431 static int cs35l56_sdw_probe(struct sdw_slave *peripheral, const struct sdw_device_id *id) 432 { 433 struct device *dev = &peripheral->dev; 434 struct cs35l56_private *cs35l56; 435 int ret; 436 437 cs35l56 = devm_kzalloc(dev, sizeof(*cs35l56), GFP_KERNEL); 438 if (!cs35l56) 439 return -ENOMEM; 440 441 cs35l56->base.dev = dev; 442 cs35l56->sdw_peripheral = peripheral; 443 INIT_WORK(&cs35l56->sdw_irq_work, cs35l56_sdw_irq_work); 444 445 dev_set_drvdata(dev, cs35l56); 446 447 cs35l56->base.regmap = devm_regmap_init(dev, &cs35l56_regmap_bus_sdw, 448 peripheral, &cs35l56_regmap_sdw); 449 if (IS_ERR(cs35l56->base.regmap)) { 450 ret = PTR_ERR(cs35l56->base.regmap); 451 return dev_err_probe(dev, ret, "Failed to allocate register map\n"); 452 } 453 454 /* Start in cache-only until device is enumerated */ 455 regcache_cache_only(cs35l56->base.regmap, true); 456 457 ret = cs35l56_common_probe(cs35l56); 458 if (ret != 0) 459 return ret; 460 461 return 0; 462 } 463 464 static int cs35l56_sdw_remove(struct sdw_slave *peripheral) 465 { 466 struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev); 467 468 /* Disable SoundWire interrupts */ 469 cs35l56->sdw_irq_no_unmask = true; 470 cancel_work_sync(&cs35l56->sdw_irq_work); 471 sdw_write_no_pm(peripheral, CS35L56_SDW_GEN_INT_MASK_1, 0); 472 sdw_read_no_pm(peripheral, CS35L56_SDW_GEN_INT_STAT_1); 473 sdw_write_no_pm(peripheral, CS35L56_SDW_GEN_INT_STAT_1, 0xFF); 474 475 cs35l56_remove(cs35l56); 476 477 return 0; 478 } 479 480 static const struct dev_pm_ops cs35l56_sdw_pm = { 481 SET_RUNTIME_PM_OPS(cs35l56_sdw_runtime_suspend, cs35l56_sdw_runtime_resume, NULL) 482 SYSTEM_SLEEP_PM_OPS(cs35l56_sdw_system_suspend, cs35l56_sdw_system_resume) 483 LATE_SYSTEM_SLEEP_PM_OPS(cs35l56_system_suspend_late, cs35l56_system_resume_early) 484 /* NOIRQ stage not needed, SoundWire doesn't use a hard IRQ */ 485 }; 486 487 static const struct sdw_device_id cs35l56_sdw_id[] = { 488 SDW_SLAVE_ENTRY(0x01FA, 0x3556, 0), 489 SDW_SLAVE_ENTRY(0x01FA, 0x3557, 0), 490 {}, 491 }; 492 MODULE_DEVICE_TABLE(sdw, cs35l56_sdw_id); 493 494 static struct sdw_driver cs35l56_sdw_driver = { 495 .driver = { 496 .name = "cs35l56", 497 .pm = pm_ptr(&cs35l56_sdw_pm), 498 }, 499 .probe = cs35l56_sdw_probe, 500 .remove = cs35l56_sdw_remove, 501 .ops = &cs35l56_sdw_ops, 502 .id_table = cs35l56_sdw_id, 503 }; 504 505 module_sdw_driver(cs35l56_sdw_driver); 506 507 MODULE_DESCRIPTION("ASoC CS35L56 SoundWire driver"); 508 MODULE_IMPORT_NS(SND_SOC_CS35L56_CORE); 509 MODULE_IMPORT_NS(SND_SOC_CS35L56_SHARED); 510 MODULE_AUTHOR("Richard Fitzgerald <rf@opensource.cirrus.com>"); 511 MODULE_AUTHOR("Simon Trimmer <simont@opensource.cirrus.com>"); 512 MODULE_LICENSE("GPL"); 513