Re: [PATCH v5] ASoc: tas2783: Add tas2783 codec driver

Hi Shenghao,

On Sat, 2024-01-13 at 19:49 +0800, Shenghao Ding wrote: ...

+static const unsigned int tas2783_cali_reg[] = {

• TAS2783_CALIBRATION_RE, /* Resistance */
• TAS2783_CALIBRATION_RE_LOW, /* Low limitation of RE */
• TAS2783_CALIBRATION_INV_RE, /* Reciprocal of RE */
• TAS2783_CALIBRATION_POW, /* RMS Power */
• TAS2783_CALIBRATION_TLIMIT /* Temperature limitation */

+};

...

+static void tas2783_apply_calib(struct tasdevice_priv *tas_dev,

• unsigned int *cali_data)

+{

• struct regmap *map = tas_dev->regmap;
• u8 *reg_start;
• int ret;
• if (!tas_dev->sdw_peripheral) {

• dev_err(tas_dev->dev, "%s, slaver doesn't exist.\n",
  

• 	__func__);
  

• return;
  

• }
• if ((tas_dev->sdw_peripheral->id.unique_id < TAS2783_ID_MIN) ||

• (tas_dev->sdw_peripheral->id.unique_id > TAS2783_ID_MAX)) {
  

• dev_err(tas_dev->dev, "%s, error unique_id.\n",
  

• 	__func__);
  

• return;
  

• }
• reg_start = (u8 *)(cali_data + (tas_dev->sdw_peripheral->id.unique_id

• - TAS2783_ID_MIN) * sizeof(tas2783_cali_reg));
  

• for (int i = 0; i < ARRAY_SIZE(tas2783_cali_reg); i++) {

• ret = regmap_bulk_write(map, tas2783_cali_reg[i],
  

• 	reg_start + i, 4);
  

reg_start is u8, reg_start + i only adds i byte. I think it should be reg_start + i * 4, because the calibration values are unsigned ints.

• if (ret != 0) {
  

• 	dev_err(tas_dev->dev, "Cali failed %x:%d\n",
  

• 		tas2783_cali_reg[i], ret);
  

• 	break;
  

• }
  

• }

+}

+/* Update the calibrate data, including speaker impedance, f0, etc, into algo.

• • Calibrate data is done by manufacturer in the factory. These data are used
• • by Algo for calucating the speaker temperature, speaker membrance excursion
• • and f0 in real time during playback.
• • In case of no or valid calibrated data, dsp will still works with default
• • calibrated data inside algo.
• */

calibration data, Calibration data, calculating, membrane

+static int tas2783_calibration(struct tasdevice_priv *tas_dev) +{

• efi_guid_t efi_guid = EFI_GUID(0x1f52d2a1, 0xbb3a, 0x457d, 0xbc,

• 	0x09, 0x43, 0xa3, 0xf4, 0x31, 0x0a, 0x92);
  

• static efi_char16_t efi_name[] = L"CALI_DATA";
• struct tm *tm = &tas_dev->tm;
• unsigned int attr = 0, crc;
• unsigned int *tmp_val;
• efi_status_t status;
• tas_dev->cali_data.total_sz = 128;

Where does 128 come from? The tas_dev->cali_data.data is a 252 byte buffer.

#define TAS2783_MAX_CALIDATA_SIZE 252

struct calibration_data { unsigned long total_sz; unsigned char data[TAS2783_MAX_CALIDATA_SIZE]; };

• status = efi.get_variable(efi_name, &efi_guid, &attr,

• &tas_dev->cali_data.total_sz, tas_dev->cali_data.data);
  

• if (status == EFI_BUFFER_TOO_SMALL) {

• status = efi.get_variable(efi_name, &efi_guid, &attr,
  

• 	&tas_dev->cali_data.total_sz,
  

• 	tas_dev->cali_data.data);
  

The first efi.get_variable call updates the total_sz, and the second efi.get_variable can write more than 252 bytes. (if the efi variable is bigger)

I don't think you can handle the EFI_BUFFER_TOO_SMALL case, if you only want to use the fixed size buffer.

• dev_dbg(tas_dev->dev, "cali get %lx bytes result:%ld\n",
  

• 	tas_dev->cali_data.total_sz, status);
  

• }
• if (status != 0) {

status != EFI_SUCCESS

• /* Failed got calibration data from EFI. */
  

• dev_dbg(tas_dev->dev, "No calibration data in UEFI.");
  

• return 0;
  

• }
• tmp_val = (unsigned int *)tas_dev->cali_data.data;
• crc = crc32(~0, tas_dev->cali_data.data, 84) ^ ~0;
• if (crc == tmp_val[21]) {

• /* Date and time of calibration was done. */
  

• time64_to_tm(tmp_val[20], 0, tm);
  

• dev_dbg(tas_dev->dev, "%4ld-%2d-%2d, %2d:%2d:%2d\n",
  

• 	tm->tm_year, tm->tm_mon, tm->tm_mday,
  

• 	tm->tm_hour, tm->tm_min, tm->tm_sec);
  

• tas2783_apply_calib(tas_dev, tmp_val);
  

• } else {

• dev_dbg(tas_dev->dev, "CRC 0x%08x not match 0x%08x\n",
  

• 	crc, tmp_val[21]);
  

• tas_dev->cali_data.total_sz = 0;
  

• }
• return 0;

+}

+static void tasdevice_rca_ready(const struct firmware *fmw,

• void *context)

+{

• struct tasdevice_priv *tas_dev =

• (struct tasdevice_priv *) context;
  

• struct tas2783_firmware_node *p;
• struct regmap *map = tas_dev->regmap;
• unsigned char *buf = NULL;
• int offset = 0, img_sz;
• int ret, value_sdw;
• mutex_lock(&tas_dev->codec_lock);
• if (!fmw || !fmw->data) {

• /* No firmware binary, devices will work in ROM mode. */
  

• dev_err(tas_dev->dev,
  

• 	"Failed to read %s, no side-effect on driver\n",
  

• 	tas_dev->rca_binaryname);
  

• ret = -EINVAL;
  

• goto out;
  

• }
• buf = (unsigned char *)fmw->data;
• img_sz = le32_to_cpup((__le32 *)&buf[offset]);
• offset += sizeof(img_sz);
• if (img_sz != fmw->size) {

• dev_err(tas_dev->dev, "Size not matching, %d %u",
  

• 	(int)fmw->size, img_sz);
  

• ret = -EINVAL;
  

• goto out;
  

• }
• while (offset < img_sz) {

• p = (struct tas2783_firmware_node *)(buf + offset);
  

• if (p->length > 1) {
  

• 	ret = regmap_bulk_write(map, p->download_addr,
  

• 	buf + offset + sizeof(unsigned int)*5, p->length);
  

• } else
  

• 	ret = regmap_write(map, p->download_addr,
  

• 		*(buf + offset + sizeof(unsigned int) * 5));
  

• if (ret != 0) {
  

• 	dev_dbg(tas_dev->dev, "Load FW fail: %d.\n", ret);
  

• 	goto out;
  

• }
  

• offset += sizeof(unsigned int)*5 + p->length;
  

• }
• /* Select left/right channel based on unique id. */
• value_sdw = 0x1a;
• value_sdw += ((tas_dev->sdw_peripheral->dev_num & 1) << 4);
• dev_dbg(tas_dev->dev, "%s dev_num = %u", __func__,

• tas_dev->sdw_peripheral->dev_num);
  

• regmap_write(map, TASDEVICE_REG(0, 0, 0x0a), value_sdw);

You can add a define for TASDEVICE_REG(0, 0, 0x0a)

• tas2783_calibration(tas_dev);

+out:

• mutex_unlock(&tas_dev->codec_lock);
• if (fmw)

• release_firmware(fmw);
  

+}

+static const struct snd_soc_dapm_widget tasdevice_dapm_widgets[] = {

• SND_SOC_DAPM_AIF_IN("ASI", "ASI Playback", 0, SND_SOC_NOPM, 0, 0),
• SND_SOC_DAPM_AIF_OUT("ASI OUT", "ASI Capture", 0, SND_SOC_NOPM,

• 0, 0),
  

• SND_SOC_DAPM_OUTPUT("OUT"),
• SND_SOC_DAPM_INPUT("DMIC")

+};

+static const struct snd_soc_dapm_route tasdevice_audio_map[] = {

• {"OUT", NULL, "ASI"},
• {"ASI OUT", NULL, "DMIC"}

+};

+static int tasdevice_set_sdw_stream(struct snd_soc_dai *dai,

• void *sdw_stream, int direction)

+{

• snd_soc_dai_dma_data_set(dai, direction, sdw_stream);
• return 0;

+}

+static void tasdevice_sdw_shutdown(struct snd_pcm_substream *substream,

• struct snd_soc_dai *dai)

+{

• snd_soc_dai_set_dma_data(dai, substream, NULL);

+}

+static int tasdevice_sdw_hw_params(struct snd_pcm_substream *substream,

• struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)

+{

• struct snd_soc_component *component = dai->component;
• struct tasdevice_priv *tas_priv =

• snd_soc_component_get_drvdata(component);
  

• struct sdw_stream_config stream_config = {0};
• struct sdw_port_config port_config = {0};
• struct sdw_stream_runtime *sdw_stream;
• int ret;
• dev_dbg(dai->dev, "%s %s", __func__, dai->name);
• sdw_stream = snd_soc_dai_get_dma_data(dai, substream);
• if (!sdw_stream)

• return -EINVAL;
  

• if (!tas_priv->sdw_peripheral)

• return -EINVAL;
  

• /* SoundWire specific configuration */
• snd_sdw_params_to_config(substream, params,

• &stream_config, &port_config);
  

• /* port 1 for playback */
• if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)

• port_config.num = 1;
  

• else

• port_config.num = 2;
  

• ret = sdw_stream_add_slave(tas_priv->sdw_peripheral,

• &stream_config, &port_config, 1, sdw_stream);
  

• if (ret) {

• dev_err(dai->dev, "Unable to configure port\n");
  

• return ret;
  

• }
• dev_dbg(dai->dev, "%s fomrat: %i rate: %i\n", __func__,

format

• params_format(params), params_rate(params));
  

• return 0;

+}

+static int tasdevice_sdw_pcm_hw_free(struct snd_pcm_substream *substream,

• struct snd_soc_dai *dai)

+{

• struct snd_soc_component *component = dai->component;
• struct tasdevice_priv *tas_priv =

• snd_soc_component_get_drvdata(component);
  

• struct sdw_stream_runtime *sdw_stream =

• snd_soc_dai_get_dma_data(dai, substream);
  

• if (!tas_priv->sdw_peripheral)

• return -EINVAL;
  

• sdw_stream_remove_slave(tas_priv->sdw_peripheral, sdw_stream);
• return 0;

+}

+static int tasdevice_mute(struct snd_soc_dai *dai, int mute,

• int direction)

+{

• struct snd_soc_component *component = dai->component;
• struct tasdevice_priv *tas_dev =

• snd_soc_component_get_drvdata(component);
  

• struct regmap *map = tas_dev->regmap;
• int ret;
• dev_dbg(tas_dev->dev, "Mute or unmute %d.\n", mute);
• if (mute) {

• /* Echo channel can't be shutdown while tas2783 must keep
  

•  * working state while playback is on.
  

•  */
  

• if (direction == SNDRV_PCM_STREAM_CAPTURE
  

• 	&& tas_dev->pstream == true)
  

• 	return 0;
  

• /* FU23 mute (0x40400108) */
  

• ret = regmap_write(map,
  

• 	SDW_SDCA_CTL(TAS2783_FUNC_TYPE_SMART_AMP,
  

• 	TAS2783_SDCA_ENT_FU23, TAS2783_SDCA_CTL_FU_MUTE, 0),
  

• 	1);
  

• ret |= regmap_write(map, TASDEVICE_REG(0, 0, 0x02), 0x1a);
  

• tas_dev->pstream = false;
  

• } else {

• /* FU23 Unmute, 0x40400108. */
  

• ret = regmap_write(map,
  

• 	SDW_SDCA_CTL(TAS2783_FUNC_TYPE_SMART_AMP,
  

• 	TAS2783_SDCA_ENT_FU23, TAS2783_SDCA_CTL_FU_MUTE, 0),
  

• 	0);
  

• ret |= regmap_write(map, TASDEVICE_REG(0, 0, 0x02), 0x0);
  

• if (direction == SNDRV_PCM_STREAM_PLAYBACK)
  

• 	tas_dev->pstream = true;
  

• }
• if (ret)

• dev_err(tas_dev->dev, "Mute or unmute %d failed %d.\n",
  

• 	mute, ret);
  

• return ret;

+}

+static const struct snd_soc_dai_ops tasdevice_dai_ops = {

• .mute_stream = tasdevice_mute,
• .hw_params = tasdevice_sdw_hw_params,
• .hw_free = tasdevice_sdw_pcm_hw_free,
• .set_stream = tasdevice_set_sdw_stream,
• .shutdown = tasdevice_sdw_shutdown,

+};

+static struct snd_soc_dai_driver tasdevice_dai_driver[] = {

• {

• .name = "tas2783-codec",
  

• .id = 0,
  

• .playback = {
  

• 	.stream_name	= "Playback",
  

• 	.channels_min	= 1,
  

• 	.channels_max	= 4,
  

• 	.rates		= TAS2783_DEVICE_RATES,
  

• 	.formats	= TAS2783_DEVICE_FORMATS,
  

• },
  

• .capture = {
  

• 	.stream_name	= "Capture",
  

• 	.channels_min	= 1,
  

• 	.channels_max	= 4,
  

• 	.rates		= TAS2783_DEVICE_RATES,
  

• 	.formats	= TAS2783_DEVICE_FORMATS,
  

• },
  

• .ops = &tasdevice_dai_ops,
  

• .symmetric_rate = 1,
  

• },

+};

+static void tas2783_reset(struct tasdevice_priv *tas_dev) +{

• struct regmap *map = tas_dev->regmap;
• int ret;
• ret = regmap_write(map, TAS2873_REG_SWRESET, 1);
• if (ret) {

• dev_err(tas_dev->dev, "Reset failed.\n");
  

• return;
  

• }
• usleep_range(1000, 1050);

+}

+static int tasdevice_component_probe(struct snd_soc_component *component) +{

• struct tasdevice_priv *tas_dev =

• snd_soc_component_get_drvdata(component);
  

• tas_dev->component = component;
• dev_dbg(tas_dev->dev, "%s was called.\n", __func__);
• return 0;

+}

+static const struct snd_soc_component_driver

• soc_codec_driver_tasdevice = {
• .probe = tasdevice_component_probe,
• .controls = tas2783_snd_controls,
• .num_controls = ARRAY_SIZE(tas2783_snd_controls),
• .dapm_widgets = tasdevice_dapm_widgets,
• .num_dapm_widgets = ARRAY_SIZE(tasdevice_dapm_widgets),
• .dapm_routes = tasdevice_audio_map,
• .num_dapm_routes = ARRAY_SIZE(tasdevice_audio_map),
• .idle_bias_on = 1,
• .endianness = 1,

+};

+static int tasdevice_init(struct tasdevice_priv *tas_dev) +{

• int ret;
• dev_set_drvdata(tas_dev->dev, tas_dev);
• mutex_init(&tas_dev->codec_lock);
• ret = devm_snd_soc_register_component(tas_dev->dev,

• &soc_codec_driver_tasdevice,
  

• tasdevice_dai_driver, ARRAY_SIZE(tasdevice_dai_driver));
  

• if (ret) {

• dev_err(tas_dev->dev, "%s: codec register error:%d.\n",
  

• 	__func__, ret);
  

return ret?

• }
• tas2783_reset(tas_dev);
• /* tas2783-8[9,...,f].bin was copied into /lib/firmware/ */
• scnprintf(tas_dev->rca_binaryname, 64, "tas2783-%01x.bin",

• tas_dev->sdw_peripheral->id.unique_id);
  

• ret = request_firmware_nowait(THIS_MODULE, FW_ACTION_UEVENT,

• tas_dev->rca_binaryname, tas_dev->dev, GFP_KERNEL,
  

• tas_dev, tasdevice_rca_ready);
  

• if (ret) {

• dev_dbg(tas_dev->dev,
  

• "%s: request_firmware %x open status: %d.\n",
  

• __func__, tas_dev->sdw_peripheral->id.unique_id, ret);
  

• }
• /* set autosuspend parameters */
• pm_runtime_set_autosuspend_delay(tas_dev->dev, 3000);
• pm_runtime_use_autosuspend(tas_dev->dev);
• /* make sure the device does not suspend immediately */
• pm_runtime_mark_last_busy(tas_dev->dev);
• pm_runtime_enable(tas_dev->dev);
• dev_dbg(tas_dev->dev, "%s was called for TAS2783.\n", __func__);
• return ret;

+}

+static int tasdevice_read_prop(struct sdw_slave *slave) +{

• struct sdw_slave_prop *prop = &slave->prop;
• int nval;
• int i, j;
• u32 bit;
• unsigned long addr;
• struct sdw_dpn_prop *dpn;
• prop->scp_int1_mask =

• SDW_SCP_INT1_BUS_CLASH | SDW_SCP_INT1_PARITY;
  

• prop->quirks = SDW_SLAVE_QUIRKS_INVALID_INITIAL_PARITY;
• prop->paging_support = true;
• /* first we need to allocate memory for set bits in port lists */
• prop->source_ports = BIT(2); /* BITMAP: 00000100 */
• prop->sink_ports = BIT(1); /* BITMAP: 00000010 */
• nval = hweight32(prop->source_ports);
• prop->src_dpn_prop = devm_kcalloc(&slave->dev, nval,

• sizeof(*prop->src_dpn_prop), GFP_KERNEL);
  

• if (!prop->src_dpn_prop)

• return -ENOMEM;
  

• i = 0;
• dpn = prop->src_dpn_prop;
• addr = prop->source_ports;
• for_each_set_bit(bit, &addr, 32) {

• dpn[i].num = bit;
  

• dpn[i].type = SDW_DPN_FULL;
  

• dpn[i].simple_ch_prep_sm = true;
  

• dpn[i].ch_prep_timeout = 10;
  

• i++;
  

• }
• /* do this again for sink now */
• nval = hweight32(prop->sink_ports);
• prop->sink_dpn_prop = devm_kcalloc(&slave->dev, nval,

• sizeof(*prop->sink_dpn_prop), GFP_KERNEL);
  

• if (!prop->sink_dpn_prop)

• return -ENOMEM;
  

• j = 0;
• dpn = prop->sink_dpn_prop;
• addr = prop->sink_ports;
• for_each_set_bit(bit, &addr, 32) {

• dpn[j].num = bit;
  

• dpn[j].type = SDW_DPN_FULL;
  

• dpn[j].simple_ch_prep_sm = true;
  

• dpn[j].ch_prep_timeout = 10;
  

• j++;
  

• }
• /* set the timeout values */
• prop->clk_stop_timeout = 20;
• return 0;

+}

+static int tasdevice_io_init(struct device *dev, struct sdw_slave *slave) +{

• struct tasdevice_priv *tas_priv = dev_get_drvdata(dev);
• if (tas_priv->hw_init)

• return 0;
  

• if (tas_priv->first_hw_init) {

• regcache_cache_only(tas_priv->regmap, false);
  

• regcache_cache_bypass(tas_priv->regmap, true);
  

• } else {

• /*
  

•  * PM runtime is only enabled when a Slave reports as Attached
  

•  */
  

• /* set autosuspend parameters */
  

• pm_runtime_set_autosuspend_delay(&slave->dev, 3000);
  

• pm_runtime_use_autosuspend(&slave->dev);
  

• /* update count of parent 'active' children */
  

• pm_runtime_set_active(&slave->dev);
  

• /* make sure the device does not suspend immediately */
  

• pm_runtime_mark_last_busy(&slave->dev);
  

• pm_runtime_enable(&slave->dev);
  

• }
• pm_runtime_get_noresume(&slave->dev);
• /* sw reset */
• regmap_write(tas_priv->regmap, 0x8001, 0x01);
• if (tas_priv->first_hw_init) {

• regcache_cache_bypass(tas_priv->regmap, false);
  

• regcache_mark_dirty(tas_priv->regmap);
  

• } else

• tas_priv->first_hw_init = true;
  

• /* Mark Slave initialization complete */
• tas_priv->hw_init = true;
• return 0;

+}

+static int tasdevice_update_status(struct sdw_slave *slave,

• enum sdw_slave_status status)

+{

• struct tasdevice_priv *tas_priv = dev_get_drvdata(&slave->dev);
• /* Update the status */
• tas_priv->status = status;
• if (status == SDW_SLAVE_UNATTACHED)

• tas_priv->hw_init = false;
  

• /* Perform initialization only if slave status

• * is present and hw_init flag is false
  

• */
  

• if (tas_priv->hw_init || tas_priv->status != SDW_SLAVE_ATTACHED)

• return 0;
  

• /* perform I/O transfers required for Slave initialization */
• return tasdevice_io_init(&slave->dev, slave);

+}

+/*

• • slave_ops: callbacks for get_clock_stop_mode, clock_stop and
• • port_prep are not defined for now
• */

+static const struct sdw_slave_ops tasdevice_sdw_ops = {

• .read_prop = tasdevice_read_prop,
• .update_status = tasdevice_update_status,

+};

+static void tasdevice_remove(struct tasdevice_priv *tas_dev) +{

• mutex_destroy(&tas_dev->codec_lock);

+}

+static int tasdevice_sdw_probe(struct sdw_slave *peripheral,

• const struct sdw_device_id *id)

+{

• struct device *dev = &peripheral->dev;
• struct tasdevice_priv *tas_dev;
• int ret;
• tas_dev = devm_kzalloc(dev, sizeof(*tas_dev), GFP_KERNEL);
• if (!tas_dev)

• return -ENOMEM;
  

• tas_dev->dev = dev;
• tas_dev->chip_id = id->driver_data;
• tas_dev->sdw_peripheral = peripheral;
• /*

• * Mark hw_init to false
  

• * HW init will be performed when device reports present
  

• */
  

• tas_dev->hw_init = false;
• tas_dev->first_hw_init = false;
• dev_set_drvdata(dev, tas_dev);
• tas_dev->regmap = devm_regmap_init_sdw(peripheral,

• &tasdevice_regmap);
  

• if (IS_ERR(tas_dev->regmap)) {

• ret = PTR_ERR(tas_dev->regmap);
  

• dev_err(dev, "Failed %d of devm_regmap_init_sdw.", ret);
  

return ret?

• } else

• ret = tasdevice_init(tas_dev);
  

• if (ret < 0)

• tasdevice_remove(tas_dev);
  

• return ret;

+}

+static int tasdevice_sdw_remove(struct sdw_slave *peripheral) +{

• struct tasdevice_priv *tas_dev = dev_get_drvdata(&peripheral->dev);
• if (tas_dev->first_hw_init)

• pm_runtime_disable(tas_dev->dev);
  

• tasdevice_remove(tas_dev);
• return 0;

+}

+static const struct sdw_device_id tasdevice_sdw_id[] = {

• SDW_SLAVE_ENTRY(0x0102, 0x0000, 0),
• {},

+};

+MODULE_DEVICE_TABLE(sdw, tasdevice_sdw_id);

+static int __maybe_unused tas2783_sdca_dev_suspend(struct device *dev) +{

• struct tasdevice_priv *tas_priv = dev_get_drvdata(dev);
• if (!tas_priv->hw_init)

• return 0;
  

• regcache_cache_only(tas_priv->regmap, true);
• return 0;

+}

+#define TAS2783_PROBE_TIMEOUT 5000

+static int __maybe_unused tas2783_sdca_dev_resume(struct device *dev) +{

• struct sdw_slave *slave = dev_to_sdw_dev(dev);
• struct tasdevice_priv *tas_priv = dev_get_drvdata(dev);
• unsigned long time;
• if (!tas_priv->first_hw_init)

• return 0;
  

• if (!slave->unattach_request)

• goto regmap_sync;
  

• time = wait_for_completion_timeout(&slave->initialization_complete,

• 		msecs_to_jiffies(TAS2783_PROBE_TIMEOUT));
  

• if (!time) {

• dev_err(&slave->dev, "Init not complete, timed out\n");
  

• sdw_show_ping_status(slave->bus, true);
  

• return -ETIMEDOUT;
  

• }

+regmap_sync:

• slave->unattach_request = 0;
• regcache_cache_only(tas_priv->regmap, false);
• regcache_sync(tas_priv->regmap);
• return 0;

+}

+static const struct dev_pm_ops tas2783_sdca_pm = {

• SET_SYSTEM_SLEEP_PM_OPS(tas2783_sdca_dev_suspend,

• tas2783_sdca_dev_resume)
  

• SET_RUNTIME_PM_OPS(tas2783_sdca_dev_suspend,

• tas2783_sdca_dev_resume, NULL)
  

+};

+static struct sdw_driver tasdevice_sdw_driver = {

• .driver = {

• .name = "slave-tas2783",
  

• .pm = &tas2783_sdca_pm,
  

• },
• .probe = tasdevice_sdw_probe,
• .remove = tasdevice_sdw_remove,
• .ops = &tasdevice_sdw_ops,
• .id_table = tasdevice_sdw_id,

+};

+module_sdw_driver(tasdevice_sdw_driver);

+MODULE_AUTHOR("Baojun Xu baojun.xu@ti.com"); +MODULE_AUTHOR("Shenghao Ding shenghao-ding@ti.com"); +MODULE_DESCRIPTION("ASoC TAS2783 SoundWire Driver"); +MODULE_LICENSE("GPL"); diff --git a/sound/soc/codecs/tas2783.h b/sound/soc/codecs/tas2783.h new file mode 100644 index 000000000000..703b2c0b78a6 --- /dev/null +++ b/sound/soc/codecs/tas2783.h @@ -0,0 +1,97 @@ +/* SPDX-License-Identifier: GPL-2.0

• • ALSA SoC Texas Instruments TAS2783 Audio Smart Amplifier
• • Copyright (C) 2023 - 2024 Texas Instruments Incorporated
• • https://www.ti.com
• • Author: Baojun Xu baojun.xu@ti.com
• • Shenghao Ding shenghao-ding@ti.com
• */

+#ifndef __TAS2783_H__ +#define __TAS2783_H__

+#define TAS2783_DEVICE_RATES (SNDRV_PCM_RATE_44100 | \

• 			SNDRV_PCM_RATE_48000 | \
  

• 			SNDRV_PCM_RATE_96000 | \
  

• 			SNDRV_PCM_RATE_88200)
  

+#define TAS2783_DEVICE_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | \

• 			SNDRV_PCM_FMTBIT_S24_LE | \
  

• 			SNDRV_PCM_FMTBIT_S32_LE)
  

+/* BOOK, PAGE Control Register */ +#define TASDEVICE_REG(book, page, reg) ((book * 256 * 256) + 0x8000 + \

• 			(page * 128) + reg)
  

+/*Software Reset */ +#define TAS2873_REG_SWRESET TASDEVICE_REG(0x0, 0X0, 0x01)

be consistent: TASDEVICE_REG(0x0, 0x0, 0x01)

+/* Volume control */ +#define TAS2783_DVC_LVL TASDEVICE_REG(0x0, 0x00, 0x1A)

0x0 for consistency

indentation is a bit weird in many lines

+#define TAS2783_AMP_LEVEL TASDEVICE_REG(0x0, 0x00, 0x03) +#define TAS2783_AMP_LEVEL_MASK GENMASK(5, 1)

+/* Calibration data */ +#define TAS2783_CALIBRATION_RE TASDEVICE_REG(0x0, 0x17, 0x74) +#define TAS2783_CALIBRATION_RE_LOW TASDEVICE_REG(0x0, 0x18, 0x14) +#define TAS2783_CALIBRATION_INV_RE TASDEVICE_REG(0x0, 0x18, 0x0c) +#define TAS2783_CALIBRATION_POW TASDEVICE_REG(0x0, 0x13, 0x70) +#define TAS2783_CALIBRATION_TLIMIT TASDEVICE_REG(0x0, 0x18, 0x7c)

+/* Unique id start */ +#define TAS2783_ID_MIN 0x08 +/* Unique id end */ +#define TAS2783_ID_MAX 0x0F

+/* TAS2783 SDCA Control - function number */ +#define TAS2783_FUNC_TYPE_SMART_AMP 0x01

+/* TAS2783 SDCA entity */ +#define TAS2783_SDCA_ENT_FU21 0x01 +#define TAS2783_SDCA_ENT_FU23 0x02

+/* TAS2783 SDCA control */ +#define TAS2783_SDCA_CTL_REQ_POWER_STATE 0x01 +#define TAS2783_SDCA_CTL_FU_MUTE 0x01 +#define TAS2783_SDCA_CTL_FU_VOLUME 0x02 +#define TAS2783_SDCA_CTL_UDMPU_CLUSTER 0x10

+#define TAS2783_DEVICE_CHANNEL_LEFT 1 +#define TAS2783_DEVICE_CHANNEL_RIGHT 2

+#define TAS2783_MAX_CALIDATA_SIZE 252

+struct tas2783_firmware_node {

• unsigned int vendor_id;
• unsigned int file_id;
• unsigned int version_id;
• unsigned int length;
• unsigned int download_addr;

+};

+struct calibration_data {

• unsigned long total_sz;
• unsigned char data[TAS2783_MAX_CALIDATA_SIZE];

+};

+struct tasdevice_priv {

• struct snd_soc_component *component;
• struct calibration_data cali_data;
• struct sdw_slave *sdw_peripheral;
• enum sdw_slave_status status;
• struct sdw_bus_params params;
• struct mutex codec_lock;
• struct regmap *regmap;
• struct device *dev;
• struct tm tm;
• unsigned char rca_binaryname[64];
• unsigned char dev_name[32];
• unsigned int chip_id;
• bool pstream;
• bool hw_init;
• bool first_hw_init;

+};

+#endif /*__TAS2783_H__ */

Regards, Gergo