| // SPDX-License-Identifier: GPL-2.0-only | |
| // | |
| // CS35L56 ALSA SoC audio driver SoundWire binding | |
| // | |
| // Copyright (C) 2023 Cirrus Logic, Inc. and | |
| // Cirrus Logic International Semiconductor Ltd. | |
| #include <linux/delay.h> | |
| #include <linux/device.h> | |
| #include <linux/err.h> | |
| #include <linux/module.h> | |
| #include <linux/mutex.h> | |
| #include <linux/pm_runtime.h> | |
| #include <linux/regmap.h> | |
| #include <linux/soundwire/sdw.h> | |
| #include <linux/soundwire/sdw_registers.h> | |
| #include <linux/soundwire/sdw_type.h> | |
| #include <linux/string_choices.h> | |
| #include <linux/swab.h> | |
| #include <linux/types.h> | |
| #include <linux/unaligned.h> | |
| #include <linux/workqueue.h> | |
| #include "cs35l56.h" | |
| /* Register addresses are offset when sent over SoundWire */ | |
| #define CS35L56_SDW_ADDR_OFFSET 0x8000 | |
| /* Cirrus bus bridge registers */ | |
| #define CS35L56_SDW_MEM_ACCESS_STATUS 0xd0 | |
| #define CS35L56_SDW_MEM_READ_DATA 0xd8 | |
| #define CS35L56_SDW_LAST_LATE BIT(3) | |
| #define CS35L56_SDW_CMD_IN_PROGRESS BIT(2) | |
| #define CS35L56_SDW_RDATA_RDY BIT(0) | |
| #define CS35L56_LATE_READ_POLL_US 10 | |
| #define CS35L56_LATE_READ_TIMEOUT_US 1000 | |
| static DEFINE_MUTEX(cs35l56_fw_idle_wait_lock); | |
| static bool cs35l56_fw_idle_wait_pending; | |
| static int cs35l56_sdw_poll_mem_status(struct sdw_slave *peripheral, | |
| unsigned int mask, | |
| unsigned int match) | |
| { | |
| int ret, val; | |
| ret = read_poll_timeout(sdw_read_no_pm, val, | |
| (val < 0) || ((val & mask) == match), | |
| CS35L56_LATE_READ_POLL_US, CS35L56_LATE_READ_TIMEOUT_US, | |
| false, peripheral, CS35L56_SDW_MEM_ACCESS_STATUS); | |
| if (ret < 0) | |
| return ret; | |
| if (val < 0) | |
| return val; | |
| return 0; | |
| } | |
| static int cs35l56_sdw_slow_read(struct sdw_slave *peripheral, unsigned int reg, | |
| u8 *buf, size_t val_size) | |
| { | |
| int ret, i; | |
| for (i = 0; i < val_size; i += sizeof(u32)) { | |
| /* Poll for bus bridge idle */ | |
| ret = cs35l56_sdw_poll_mem_status(peripheral, | |
| CS35L56_SDW_CMD_IN_PROGRESS, | |
| 0); | |
| if (ret < 0) { | |
| dev_err(&peripheral->dev, "!CMD_IN_PROGRESS fail: %d\n", ret); | |
| return ret; | |
| } | |
| /* Reading LSByte triggers read of register to holding buffer */ | |
| sdw_read_no_pm(peripheral, reg + i); | |
| /* Wait for data available */ | |
| ret = cs35l56_sdw_poll_mem_status(peripheral, | |
| CS35L56_SDW_RDATA_RDY, | |
| CS35L56_SDW_RDATA_RDY); | |
| if (ret < 0) { | |
| dev_err(&peripheral->dev, "RDATA_RDY fail: %d\n", ret); | |
| return ret; | |
| } | |
| /* Read data from buffer */ | |
| ret = sdw_nread_no_pm(peripheral, CS35L56_SDW_MEM_READ_DATA, | |
| sizeof(u32), &buf[i]); | |
| if (ret) { | |
| dev_err(&peripheral->dev, "Late read @%#x failed: %d\n", reg + i, ret); | |
| return ret; | |
| } | |
| swab32s((u32 *)&buf[i]); | |
| } | |
| return 0; | |
| } | |
| static int cs35l56_sdw_read(void *context, const void *reg_buf, | |
| const size_t reg_size, void *val_buf, | |
| size_t val_size) | |
| { | |
| struct sdw_slave *peripheral = context; | |
| struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev); | |
| unsigned int reg_addr = get_unaligned_le32(reg_buf); | |
| int ret; | |
| if (cs35l56_is_otp_register(reg_addr - CS35L56_SDW_ADDR_OFFSET)) | |
| return cs35l56_sdw_slow_read(peripheral, reg_addr, (u8 *)val_buf, val_size); | |
| ret = regmap_raw_read(cs35l56->sdw_bus_regmap, reg_addr, val_buf, val_size); | |
| if (ret) | |
| return ret; | |
| swab32_array((u32 *)val_buf, val_size / sizeof(u32)); | |
| return 0; | |
| } | |
| static inline void cs35l56_swab_copy(void *dest, const void *src, size_t nbytes) | |
| { | |
| u32 *dest32 = dest; | |
| const u32 *src32 = src; | |
| for (; nbytes > 0; nbytes -= 4) | |
| *dest32++ = swab32(*src32++); | |
| } | |
| static int cs35l56_sdw_gather_write(void *context, | |
| const void *reg_buf, size_t reg_size, | |
| const void *val_buf, size_t val_size) | |
| { | |
| struct sdw_slave *peripheral = context; | |
| struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev); | |
| unsigned int reg_addr = get_unaligned_le32(reg_buf); | |
| u32 swab_buf[64]; /* Define u32 so it is 32-bit aligned */ | |
| int ret; | |
| while (val_size > sizeof(swab_buf)) { | |
| cs35l56_swab_copy(swab_buf, val_buf, sizeof(swab_buf)); | |
| ret = regmap_raw_write(cs35l56->sdw_bus_regmap, reg_addr, | |
| swab_buf, sizeof(swab_buf)); | |
| if (ret) | |
| return ret; | |
| val_size -= sizeof(swab_buf); | |
| reg_addr += sizeof(swab_buf); | |
| val_buf += sizeof(swab_buf); | |
| } | |
| if (val_size == 0) | |
| return 0; | |
| cs35l56_swab_copy(swab_buf, val_buf, val_size); | |
| return regmap_raw_write(cs35l56->sdw_bus_regmap, reg_addr, swab_buf, val_size); | |
| } | |
| static int cs35l56_sdw_write(void *context, const void *val_buf, size_t val_size) | |
| { | |
| const u8 *src_buf = val_buf; | |
| /* First word of val_buf contains the destination address */ | |
| return cs35l56_sdw_gather_write(context, &src_buf[0], 4, &src_buf[4], val_size - 4); | |
| } | |
| /* | |
| * Registers are big-endian on I2C and SPI but little-endian on SoundWire. | |
| * Exported firmware controls are big-endian on I2C/SPI but little-endian on | |
| * SoundWire. Firmware files are always big-endian and are opaque blobs. | |
| * Present a big-endian regmap and hide the endianness swap, so that the ALSA | |
| * byte controls always have the same byte order, and firmware file blobs | |
| * can be written verbatim. | |
| */ | |
| static const struct regmap_bus cs35l56_regmap_swab_bus_sdw = { | |
| .read = cs35l56_sdw_read, | |
| .write = cs35l56_sdw_write, | |
| .gather_write = cs35l56_sdw_gather_write, | |
| .reg_format_endian_default = REGMAP_ENDIAN_LITTLE, | |
| .val_format_endian_default = REGMAP_ENDIAN_BIG, | |
| }; | |
| /* Low-level SoundWire regmap to transfer the data over the bus */ | |
| static const struct regmap_config cs35l56_sdw_bus_regmap = { | |
| .name = "sdw-le32", | |
| .reg_bits = 32, | |
| .val_bits = 32, | |
| .reg_stride = 4, | |
| .reg_format_endian = REGMAP_ENDIAN_LITTLE, | |
| .val_format_endian = REGMAP_ENDIAN_LITTLE, | |
| .max_register = CS35L56_DSP1_PMEM_5114 + 0x8000, | |
| .cache_type = REGCACHE_NONE, | |
| }; | |
| static int cs35l56_sdw_get_unique_id(struct cs35l56_private *cs35l56) | |
| { | |
| int ret; | |
| ret = sdw_read_no_pm(cs35l56->sdw_peripheral, SDW_SCP_DEVID_0); | |
| if (ret < 0) | |
| return ret; | |
| cs35l56->sdw_unique_id = ret & 0xf; | |
| return 0; | |
| } | |
| static void cs35l56_sdw_init(struct sdw_slave *peripheral) | |
| { | |
| struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev); | |
| int ret; | |
| pm_runtime_get_noresume(cs35l56->base.dev); | |
| ret = cs35l56_sdw_get_unique_id(cs35l56); | |
| if (ret) | |
| goto out; | |
| /* SoundWire UniqueId is used to index the calibration array */ | |
| if (cs35l56->base.cal_index < 0) | |
| cs35l56->base.cal_index = cs35l56->sdw_unique_id; | |
| ret = cs35l56_init(cs35l56); | |
| if (ret < 0) { | |
| regcache_cache_only(cs35l56->base.regmap, true); | |
| goto out; | |
| } | |
| /* | |
| * cs35l56_init can return with !init_done if it triggered | |
| * a soft reset. | |
| */ | |
| if (cs35l56->base.init_done) | |
| cs35l56_unmask_soundwire_interrupts(cs35l56); | |
| out: | |
| pm_runtime_put_autosuspend(cs35l56->base.dev); | |
| } | |
| static int cs35l56_sdw_interrupt(struct sdw_slave *peripheral, | |
| struct sdw_slave_intr_status *status) | |
| { | |
| /* | |
| * The IRQ itself was handled through the regmap_irq handler, this is | |
| * just clearing up the additional Cirrus SoundWire registers that are | |
| * not covered by the SoundWire framework or the IRQ handler itself. | |
| */ | |
| sdw_read_no_pm(peripheral, CS35L56_SDW_GEN_INT_STAT_1); | |
| sdw_write_no_pm(peripheral, CS35L56_SDW_GEN_INT_STAT_1, 0xFF); | |
| return 0; | |
| } | |
| static int cs35l56_sdw_read_prop(struct sdw_slave *peripheral) | |
| { | |
| struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev); | |
| struct sdw_slave_prop *prop = &peripheral->prop; | |
| struct sdw_dpn_prop *ports; | |
| u8 clock_stop_1 = false; | |
| int ret; | |
| ret = fwnode_property_read_u8(dev_fwnode(cs35l56->base.dev), | |
| "mipi-sdw-clock-stop-mode1-supported", | |
| &clock_stop_1); | |
| if (ret == 0) | |
| prop->clk_stop_mode1 = !!clock_stop_1; | |
| ports = devm_kcalloc(cs35l56->base.dev, 3, sizeof(*ports), GFP_KERNEL); | |
| if (!ports) | |
| return -ENOMEM; | |
| prop->source_ports = BIT(CS35L56_SDW1_CAPTURE_PORT) | BIT(CS35L56_OT25_CAPTURE_PORT); | |
| prop->sink_ports = BIT(CS35L56_SDW1_PLAYBACK_PORT); | |
| prop->paging_support = true; | |
| prop->use_domain_irq = true; | |
| prop->quirks = SDW_SLAVE_QUIRKS_INVALID_INITIAL_PARITY; | |
| prop->scp_int1_mask = SDW_SCP_INT1_BUS_CLASH | SDW_SCP_INT1_PARITY | SDW_SCP_INT1_IMPL_DEF; | |
| /* DP1 - playback */ | |
| ports[0].num = CS35L56_SDW1_PLAYBACK_PORT; | |
| ports[0].type = SDW_DPN_FULL; | |
| ports[0].ch_prep_timeout = 10; | |
| prop->sink_dpn_prop = &ports[0]; | |
| /* DP3 - capture */ | |
| ports[1].num = CS35L56_SDW1_CAPTURE_PORT; | |
| ports[1].type = SDW_DPN_FULL; | |
| ports[1].ch_prep_timeout = 10; | |
| /* DP4 - capture */ | |
| ports[2].num = CS35L56_OT25_CAPTURE_PORT; | |
| ports[2].type = SDW_DPN_FULL; | |
| ports[2].ch_prep_timeout = 10; | |
| prop->src_dpn_prop = &ports[1]; | |
| dev_dbg(&peripheral->dev, "clock stop mode 1 supported: %s\n", | |
| str_yes_no(prop->clk_stop_mode1)); | |
| return 0; | |
| } | |
| static int cs35l56_sdw_update_status(struct sdw_slave *peripheral, | |
| enum sdw_slave_status status) | |
| { | |
| struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev); | |
| switch (status) { | |
| case SDW_SLAVE_ATTACHED: | |
| if (cs35l56->sdw_attached) | |
| break; | |
| dev_dbg(cs35l56->base.dev, "%s: ATTACHED\n", __func__); | |
| if (!cs35l56->base.init_done || cs35l56->soft_resetting) | |
| cs35l56_sdw_init(peripheral); | |
| cs35l56->sdw_attached = true; | |
| break; | |
| case SDW_SLAVE_UNATTACHED: | |
| if (cs35l56->sdw_attached) | |
| dev_dbg(cs35l56->base.dev, "%s: UNATTACHED\n", __func__); | |
| cs35l56->sdw_attached = false; | |
| break; | |
| default: | |
| break; | |
| } | |
| return 0; | |
| } | |
| static const struct sdw_slave_ops cs35l56_sdw_ops = { | |
| .read_prop = cs35l56_sdw_read_prop, | |
| .interrupt_callback = cs35l56_sdw_interrupt, | |
| .update_status = cs35l56_sdw_update_status, | |
| }; | |
| static int __maybe_unused cs35l56_sdw_handle_unattach(struct cs35l56_private *cs35l56) | |
| { | |
| struct sdw_slave *peripheral = cs35l56->sdw_peripheral; | |
| int ret; | |
| dev_dbg(cs35l56->base.dev, "attached:%u unattach_request:%u\n", | |
| cs35l56->sdw_attached, peripheral->unattach_request); | |
| /* Cannot access registers until bus is re-initialized. */ | |
| ret = sdw_slave_wait_for_init(peripheral, 5000); | |
| if (ret) | |
| return ret; | |
| /* | |
| * Don't call regcache_mark_dirty(), we can't be sure that the | |
| * Manager really did issue a Bus Reset. | |
| */ | |
| return 0; | |
| } | |
| static int __maybe_unused cs35l56_sdw_runtime_suspend(struct device *dev) | |
| { | |
| struct cs35l56_private *cs35l56 = dev_get_drvdata(dev); | |
| if (!cs35l56->base.init_done) | |
| return 0; | |
| return cs35l56_runtime_suspend_common(&cs35l56->base); | |
| } | |
| static int __maybe_unused cs35l56_sdw_runtime_resume(struct device *dev) | |
| { | |
| struct cs35l56_private *cs35l56 = dev_get_drvdata(dev); | |
| int ret; | |
| dev_dbg(dev, "Runtime resume\n"); | |
| if (!cs35l56->base.init_done) | |
| return 0; | |
| ret = cs35l56_sdw_handle_unattach(cs35l56); | |
| if (ret < 0) | |
| return ret; | |
| ret = cs35l56_runtime_resume_common(&cs35l56->base, true); | |
| if (ret) | |
| return ret; | |
| cs35l56_unmask_soundwire_interrupts(cs35l56); | |
| return 0; | |
| } | |
| static int cs35l56_sdw_system_suspend_prepare(struct device *dev) | |
| { | |
| cs35l56_fw_idle_wait_pending = true; | |
| return 0; | |
| } | |
| static int __maybe_unused cs35l56_sdw_system_suspend(struct device *dev) | |
| { | |
| struct cs35l56_private *cs35l56 = dev_get_drvdata(dev); | |
| int ret; | |
| if (cs35l56->sdw_attached) | |
| cs35l56_mask_soundwire_interrupts(cs35l56); | |
| ret = cs35l56_system_suspend(dev); | |
| if (ret < 0) | |
| return ret; | |
| scoped_guard(mutex, &cs35l56_fw_idle_wait_lock) { | |
| if (cs35l56_fw_idle_wait_pending && cs35l56->needs_wait_for_fw_idle) { | |
| dev_dbg(cs35l56->base.dev, "Wait for FW timer expiry\n"); | |
| msleep(CS35L56_FW_REQ_ACTIVE_TIMEOUT_MS + 10); | |
| cs35l56_fw_idle_wait_pending = false; | |
| } | |
| } | |
| return 0; | |
| } | |
| static int cs35l56_sdw_probe(struct sdw_slave *peripheral, const struct sdw_device_id *id) | |
| { | |
| struct device *dev = &peripheral->dev; | |
| struct cs35l56_private *cs35l56; | |
| const struct regmap_config *regmap_config; | |
| int ret; | |
| cs35l56 = devm_kzalloc(dev, sizeof(*cs35l56), GFP_KERNEL); | |
| if (!cs35l56) | |
| return -ENOMEM; | |
| cs35l56->base.dev = dev; | |
| cs35l56->sdw_peripheral = peripheral; | |
| cs35l56->sdw_link_num = peripheral->bus->link_id; | |
| dev_set_drvdata(dev, cs35l56); | |
| switch ((unsigned int)id->driver_data) { | |
| case 0x3556: | |
| case 0x3557: | |
| regmap_config = &cs35l56_regmap_sdw; | |
| break; | |
| case 0x3563: | |
| case 0x3562: | |
| regmap_config = &cs35l63_regmap_sdw; | |
| break; | |
| default: | |
| return -ENODEV; | |
| } | |
| cs35l56->base.type = ((unsigned int)id->driver_data) & 0xff; | |
| /* Low-level regmap to transfer read/writes over SoundWire bus */ | |
| cs35l56->sdw_bus_regmap = devm_regmap_init_sdw(peripheral, &cs35l56_sdw_bus_regmap); | |
| if (IS_ERR(cs35l56->sdw_bus_regmap)) { | |
| ret = PTR_ERR(cs35l56->sdw_bus_regmap); | |
| return dev_err_probe(dev, ret, "Failed to allocate bus register map\n"); | |
| } | |
| /* Wrapper regmap to simulate big-endian ordering */ | |
| cs35l56->base.regmap = devm_regmap_init(dev, &cs35l56_regmap_swab_bus_sdw, | |
| peripheral, regmap_config); | |
| if (IS_ERR(cs35l56->base.regmap)) { | |
| ret = PTR_ERR(cs35l56->base.regmap); | |
| return dev_err_probe(dev, ret, "Failed to allocate register map\n"); | |
| } | |
| /* Start in cache-only until device is enumerated */ | |
| regcache_cache_only(cs35l56->base.regmap, true); | |
| return cs35l56_common_probe(cs35l56, peripheral->irq); | |
| } | |
| static void cs35l56_sdw_remove(struct sdw_slave *peripheral) | |
| { | |
| struct cs35l56_private *cs35l56 = dev_get_drvdata(&peripheral->dev); | |
| cs35l56_mask_soundwire_interrupts(cs35l56); | |
| cs35l56_remove(cs35l56); | |
| } | |
| static const struct dev_pm_ops cs35l56_sdw_pm = { | |
| .prepare = cs35l56_sdw_system_suspend_prepare, | |
| SET_RUNTIME_PM_OPS(cs35l56_sdw_runtime_suspend, cs35l56_sdw_runtime_resume, NULL) | |
| SYSTEM_SLEEP_PM_OPS(cs35l56_sdw_system_suspend, cs35l56_system_resume) | |
| LATE_SYSTEM_SLEEP_PM_OPS(cs35l56_system_suspend_late, cs35l56_system_resume_early) | |
| /* NOIRQ stage not needed, SoundWire doesn't use a hard IRQ */ | |
| }; | |
| static const struct sdw_device_id cs35l56_sdw_id[] = { | |
| SDW_SLAVE_ENTRY(0x01FA, 0x3556, 0x3556), | |
| SDW_SLAVE_ENTRY(0x01FA, 0x3557, 0x3557), | |
| SDW_SLAVE_ENTRY(0x01FA, 0x3562, 0x3562), | |
| SDW_SLAVE_ENTRY(0x01FA, 0x3563, 0x3563), | |
| {}, | |
| }; | |
| MODULE_DEVICE_TABLE(sdw, cs35l56_sdw_id); | |
| static struct sdw_driver cs35l56_sdw_driver = { | |
| .driver = { | |
| .name = "cs35l56", | |
| .pm = pm_ptr(&cs35l56_sdw_pm), | |
| }, | |
| .probe = cs35l56_sdw_probe, | |
| .remove = cs35l56_sdw_remove, | |
| .ops = &cs35l56_sdw_ops, | |
| .id_table = cs35l56_sdw_id, | |
| }; | |
| module_sdw_driver(cs35l56_sdw_driver); | |
| MODULE_DESCRIPTION("ASoC CS35L56 SoundWire driver"); | |
| MODULE_IMPORT_NS("SND_SOC_CS35L56_CORE"); | |
| MODULE_IMPORT_NS("SND_SOC_CS35L56_SHARED"); | |
| MODULE_AUTHOR("Richard Fitzgerald <rf@opensource.cirrus.com>"); | |
| MODULE_AUTHOR("Simon Trimmer <simont@opensource.cirrus.com>"); | |
| MODULE_LICENSE("GPL"); |