sound/soc/codecs/cs35l56-sdw.c

   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->clk_stop_mode1 = false;
 275         prop->quirks = SDW_SLAVE_QUIRKS_INVALID_INITIAL_PARITY;
 276         prop->scp_int1_mask = SDW_SCP_INT1_BUS_CLASH | SDW_SCP_INT1_PARITY | SDW_SCP_INT1_IMPL_DEF;
 277
 278         /* DP1 - playback */
 279         ports[0].num = CS35L56_SDW1_PLAYBACK_PORT;
 280         ports[0].type = SDW_DPN_FULL;
 281         ports[0].ch_prep_timeout = 10;
 282         prop->sink_dpn_prop = &ports[0];
 283
 284         /* DP3 - capture */
 285         ports[1].num = CS35L56_SDW1_CAPTURE_PORT;
 286         ports[1].type = SDW_DPN_FULL;
 287         ports[1].ch_prep_timeout = 10;
 288         prop->src_dpn_prop = &ports[1];
 289
 290         return 0;
 291 }
 292
 293 static int cs35l56_sdw_update_status(struct sdw_slave *peripheral,
 294                                      enum sdw_slave_status status)
 295 {
 296         struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev);
 297
 298         switch (status) {
 299         case SDW_SLAVE_ATTACHED:
 300                 dev_dbg(cs35l56->base.dev, "%s: ATTACHED\n", __func__);
 301                 if (cs35l56->sdw_attached)
 302                         break;
 303
 304                 if (!cs35l56->base.init_done || cs35l56->soft_resetting)
 305                         cs35l56_sdw_init(peripheral);
 306
 307                 cs35l56->sdw_attached = true;
 308                 break;
 309         case SDW_SLAVE_UNATTACHED:
 310                 dev_dbg(cs35l56->base.dev, "%s: UNATTACHED\n", __func__);
 311                 cs35l56->sdw_attached = false;
 312                 break;
 313         default:
 314                 break;
 315         }
 316
 317         return 0;
 318 }
 319
 320 static int cs35l56_a1_kick_divider(struct cs35l56_private *cs35l56,
 321                                    struct sdw_slave *peripheral)
 322 {
 323         unsigned int curr_scale_reg, next_scale_reg;
 324         int curr_scale, next_scale, ret;
 325
 326         if (!cs35l56->base.init_done)
 327                 return 0;
 328
 329         if (peripheral->bus->params.curr_bank) {
 330                 curr_scale_reg = SDW_SCP_BUSCLOCK_SCALE_B1;
 331                 next_scale_reg = SDW_SCP_BUSCLOCK_SCALE_B0;
 332         } else {
 333                 curr_scale_reg = SDW_SCP_BUSCLOCK_SCALE_B0;
 334                 next_scale_reg = SDW_SCP_BUSCLOCK_SCALE_B1;
 335         }
 336
 337         /*
 338          * Current clock scale value must be different to new value.
 339          * Modify current to guarantee this. If next still has the dummy
 340          * value we wrote when it was current, the core code has not set
 341          * a new scale so restore its original good value
 342          */
 343         curr_scale = sdw_read_no_pm(peripheral, curr_scale_reg);
 344         if (curr_scale < 0) {
 345                 dev_err(cs35l56->base.dev, "Failed to read current clock scale: %d\n", curr_scale);
 346                 return curr_scale;
 347         }
 348
 349         next_scale = sdw_read_no_pm(peripheral, next_scale_reg);
 350         if (next_scale < 0) {
 351                 dev_err(cs35l56->base.dev, "Failed to read next clock scale: %d\n", next_scale);
 352                 return next_scale;
 353         }
 354
 355         if (next_scale == CS35L56_SDW_INVALID_BUS_SCALE) {
 356                 next_scale = cs35l56->old_sdw_clock_scale;
 357                 ret = sdw_write_no_pm(peripheral, next_scale_reg, next_scale);
 358                 if (ret < 0) {
 359                         dev_err(cs35l56->base.dev, "Failed to modify current clock scale: %d\n",
 360                                 ret);
 361                         return ret;
 362                 }
 363         }
 364
 365         cs35l56->old_sdw_clock_scale = curr_scale;
 366         ret = sdw_write_no_pm(peripheral, curr_scale_reg, CS35L56_SDW_INVALID_BUS_SCALE);
 367         if (ret < 0) {
 368                 dev_err(cs35l56->base.dev, "Failed to modify current clock scale: %d\n", ret);
 369                 return ret;
 370         }
 371
 372         dev_dbg(cs35l56->base.dev, "Next bus scale: %#x\n", next_scale);
 373
 374         return 0;
 375 }
 376
 377 static int cs35l56_sdw_bus_config(struct sdw_slave *peripheral,
 378                                   struct sdw_bus_params *params)
 379 {
 380         struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev);
 381         int sclk;
 382
 383         sclk = params->curr_dr_freq / 2;
 384         dev_dbg(cs35l56->base.dev, "%s: sclk=%u c=%u r=%u\n",
 385                 __func__, sclk, params->col, params->row);
 386
 387         if ((cs35l56->base.type == 0x56) && (cs35l56->base.rev < 0xb0))
 388                 return cs35l56_a1_kick_divider(cs35l56, peripheral);
 389
 390         return 0;
 391 }
 392
 393 static int __maybe_unused cs35l56_sdw_clk_stop(struct sdw_slave *peripheral,
 394                                                enum sdw_clk_stop_mode mode,
 395                                                enum sdw_clk_stop_type type)
 396 {
 397         struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev);
 398
 399         dev_dbg(cs35l56->base.dev, "%s: mode:%d type:%d\n", __func__, mode, type);
 400
 401         return 0;
 402 }
 403
 404 static const struct sdw_slave_ops cs35l56_sdw_ops = {
 405         .read_prop = cs35l56_sdw_read_prop,
 406         .interrupt_callback = cs35l56_sdw_interrupt,
 407         .update_status = cs35l56_sdw_update_status,
 408         .bus_config = cs35l56_sdw_bus_config,
 409 #ifdef DEBUG
 410         .clk_stop = cs35l56_sdw_clk_stop,
 411 #endif
 412 };
 413
 414 static int __maybe_unused cs35l56_sdw_handle_unattach(struct cs35l56_private *cs35l56)
 415 {
 416         struct sdw_slave *peripheral = cs35l56->sdw_peripheral;
 417
 418         if (peripheral->unattach_request) {
 419                 /* Cannot access registers until bus is re-initialized. */
 420                 dev_dbg(cs35l56->base.dev, "Wait for initialization_complete\n");
 421                 if (!wait_for_completion_timeout(&peripheral->initialization_complete,
 422                                                  msecs_to_jiffies(5000))) {
 423                         dev_err(cs35l56->base.dev, "initialization_complete timed out\n");
 424                         return -ETIMEDOUT;
 425                 }
 426
 427                 peripheral->unattach_request = 0;
 428
 429                 /*
 430                  * Don't call regcache_mark_dirty(), we can't be sure that the
 431                  * Manager really did issue a Bus Reset.
 432                  */
 433         }
 434
 435         return 0;
 436 }
 437
 438 static int __maybe_unused cs35l56_sdw_runtime_suspend(struct device *dev)
 439 {
 440         struct cs35l56_private *cs35l56 = dev_get_drvdata(dev);
 441
 442         if (!cs35l56->base.init_done)
 443                 return 0;
 444
 445         return cs35l56_runtime_suspend_common(&cs35l56->base);
 446 }
 447
 448 static int __maybe_unused cs35l56_sdw_runtime_resume(struct device *dev)
 449 {
 450         struct cs35l56_private *cs35l56 = dev_get_drvdata(dev);
 451         int ret;
 452
 453         dev_dbg(dev, "Runtime resume\n");
 454
 455         if (!cs35l56->base.init_done)
 456                 return 0;
 457
 458         ret = cs35l56_sdw_handle_unattach(cs35l56);
 459         if (ret < 0)
 460                 return ret;
 461
 462         ret = cs35l56_runtime_resume_common(&cs35l56->base, true);
 463         if (ret)
 464                 return ret;
 465
 466         /* Re-enable SoundWire interrupts */
 467         sdw_write_no_pm(cs35l56->sdw_peripheral, CS35L56_SDW_GEN_INT_MASK_1,
 468                         CS35L56_SDW_INT_MASK_CODEC_IRQ);
 469
 470         return 0;
 471 }
 472
 473 static int __maybe_unused cs35l56_sdw_system_suspend(struct device *dev)
 474 {
 475         struct cs35l56_private *cs35l56 = dev_get_drvdata(dev);
 476
 477         if (!cs35l56->base.init_done)
 478                 return 0;
 479
 480         /*
 481          * Disable SoundWire interrupts.
 482          * Flush - don't cancel because that could leave an unbalanced pm_runtime_get.
 483          */
 484         cs35l56->sdw_irq_no_unmask = true;
 485         flush_work(&cs35l56->sdw_irq_work);
 486
 487         /* Mask interrupts and flush in case sdw_irq_work was queued again */
 488         sdw_write_no_pm(cs35l56->sdw_peripheral, CS35L56_SDW_GEN_INT_MASK_1, 0);
 489         sdw_read_no_pm(cs35l56->sdw_peripheral, CS35L56_SDW_GEN_INT_STAT_1);
 490         sdw_write_no_pm(cs35l56->sdw_peripheral, CS35L56_SDW_GEN_INT_STAT_1, 0xFF);
 491         flush_work(&cs35l56->sdw_irq_work);
 492
 493         return cs35l56_system_suspend(dev);
 494 }
 495
 496 static int __maybe_unused cs35l56_sdw_system_resume(struct device *dev)
 497 {
 498         struct cs35l56_private *cs35l56 = dev_get_drvdata(dev);
 499
 500         cs35l56->sdw_irq_no_unmask = false;
 501         /* runtime_resume re-enables the interrupt */
 502
 503         return cs35l56_system_resume(dev);
 504 }
 505
 506 static int cs35l56_sdw_probe(struct sdw_slave *peripheral, const struct sdw_device_id *id)
 507 {
 508         struct device *dev = &peripheral->dev;
 509         struct cs35l56_private *cs35l56;
 510         int ret;
 511
 512         cs35l56 = devm_kzalloc(dev, sizeof(*cs35l56), GFP_KERNEL);
 513         if (!cs35l56)
 514                 return -ENOMEM;
 515
 516         cs35l56->base.dev = dev;
 517         cs35l56->sdw_peripheral = peripheral;
 518         INIT_WORK(&cs35l56->sdw_irq_work, cs35l56_sdw_irq_work);
 519
 520         dev_set_drvdata(dev, cs35l56);
 521
 522         cs35l56->base.regmap = devm_regmap_init(dev, &cs35l56_regmap_bus_sdw,
 523                                            peripheral, &cs35l56_regmap_sdw);
 524         if (IS_ERR(cs35l56->base.regmap)) {
 525                 ret = PTR_ERR(cs35l56->base.regmap);
 526                 return dev_err_probe(dev, ret, "Failed to allocate register map\n");
 527         }
 528
 529         /* Start in cache-only until device is enumerated */
 530         regcache_cache_only(cs35l56->base.regmap, true);
 531
 532         ret = cs35l56_common_probe(cs35l56);
 533         if (ret != 0)
 534                 return ret;
 535
 536         return 0;
 537 }
 538
 539 static int cs35l56_sdw_remove(struct sdw_slave *peripheral)
 540 {
 541         struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev);
 542
 543         /* Disable SoundWire interrupts */
 544         cs35l56->sdw_irq_no_unmask = true;
 545         cancel_work_sync(&cs35l56->sdw_irq_work);
 546         sdw_write_no_pm(peripheral, CS35L56_SDW_GEN_INT_MASK_1, 0);
 547         sdw_read_no_pm(peripheral, CS35L56_SDW_GEN_INT_STAT_1);
 548         sdw_write_no_pm(peripheral, CS35L56_SDW_GEN_INT_STAT_1, 0xFF);
 549
 550         cs35l56_remove(cs35l56);
 551
 552         return 0;
 553 }
 554
 555 static const struct dev_pm_ops cs35l56_sdw_pm = {
 556         SET_RUNTIME_PM_OPS(cs35l56_sdw_runtime_suspend, cs35l56_sdw_runtime_resume, NULL)
 557         SYSTEM_SLEEP_PM_OPS(cs35l56_sdw_system_suspend, cs35l56_sdw_system_resume)
 558         LATE_SYSTEM_SLEEP_PM_OPS(cs35l56_system_suspend_late, cs35l56_system_resume_early)
 559         /* NOIRQ stage not needed, SoundWire doesn't use a hard IRQ */
 560 };
 561
 562 static const struct sdw_device_id cs35l56_sdw_id[] = {
 563         SDW_SLAVE_ENTRY(0x01FA, 0x3556, 0),
 564         SDW_SLAVE_ENTRY(0x01FA, 0x3557, 0),
 565         {},
 566 };
 567 MODULE_DEVICE_TABLE(sdw, cs35l56_sdw_id);
 568
 569 static struct sdw_driver cs35l56_sdw_driver = {
 570         .driver = {
 571                 .name = "cs35l56",
 572                 .pm = pm_ptr(&cs35l56_sdw_pm),
 573         },
 574         .probe = cs35l56_sdw_probe,
 575         .remove = cs35l56_sdw_remove,
 576         .ops = &cs35l56_sdw_ops,
 577         .id_table = cs35l56_sdw_id,
 578 };
 579
 580 module_sdw_driver(cs35l56_sdw_driver);
 581
 582 MODULE_DESCRIPTION("ASoC CS35L56 SoundWire driver");
 583 MODULE_IMPORT_NS(SND_SOC_CS35L56_CORE);
 584 MODULE_IMPORT_NS(SND_SOC_CS35L56_SHARED);
 585 MODULE_AUTHOR("Richard Fitzgerald <rf@opensource.cirrus.com>");
 586 MODULE_AUTHOR("Simon Trimmer <simont@opensource.cirrus.com>");
 587 MODULE_LICENSE("GPL");