1 // SPDX-License-Identifier: GPL-2.0-only 2 // 3 // sdw-mockup.c -- a mockup SoundWire codec for tests where only the host 4 // drives the bus. 5 // 6 // Copyright(c) 2021 Intel Corporation 7 // 8 // 9 10 #include <linux/device.h> 11 #include <linux/mod_devicetable.h> 12 #include <linux/module.h> 13 #include <linux/soundwire/sdw.h> 14 #include <linux/soundwire/sdw_type.h> 15 #include <linux/soundwire/sdw_registers.h> 16 #include <sound/core.h> 17 #include <sound/pcm.h> 18 #include <sound/pcm_params.h> 19 #include <sound/sdw.h> 20 #include <sound/soc.h> 21 22 struct sdw_mockup_priv { 23 struct sdw_slave *slave; 24 }; 25 26 static int sdw_mockup_component_probe(struct snd_soc_component *component) 27 { 28 return 0; 29 } 30 31 static void sdw_mockup_component_remove(struct snd_soc_component *component) 32 { 33 } 34 35 static const struct snd_soc_component_driver snd_soc_sdw_mockup_component = { 36 .probe = sdw_mockup_component_probe, 37 .remove = sdw_mockup_component_remove, 38 .endianness = 1, 39 }; 40 41 static int sdw_mockup_set_sdw_stream(struct snd_soc_dai *dai, void *sdw_stream, 42 int direction) 43 { 44 snd_soc_dai_dma_data_set(dai, direction, sdw_stream); 45 46 return 0; 47 } 48 49 static void sdw_mockup_shutdown(struct snd_pcm_substream *substream, 50 struct snd_soc_dai *dai) 51 { 52 snd_soc_dai_set_dma_data(dai, substream, NULL); 53 } 54 55 static int sdw_mockup_pcm_hw_params(struct snd_pcm_substream *substream, 56 struct snd_pcm_hw_params *params, 57 struct snd_soc_dai *dai) 58 { 59 struct snd_soc_component *component = dai->component; 60 struct sdw_mockup_priv *sdw_mockup = snd_soc_component_get_drvdata(component); 61 struct sdw_stream_config stream_config = {0}; 62 struct sdw_port_config port_config = {0}; 63 struct sdw_stream_runtime *sdw_stream = snd_soc_dai_get_dma_data(dai, substream); 64 int ret; 65 66 if (!sdw_stream) 67 return -EINVAL; 68 69 if (!sdw_mockup->slave) 70 return -EINVAL; 71 72 /* SoundWire specific configuration */ 73 snd_sdw_params_to_config(substream, params, &stream_config, &port_config); 74 75 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 76 port_config.num = 1; 77 else 78 port_config.num = 8; 79 80 ret = sdw_stream_add_slave(sdw_mockup->slave, &stream_config, 81 &port_config, 1, sdw_stream); 82 if (ret) 83 dev_err(dai->dev, "Unable to configure port\n"); 84 85 return ret; 86 } 87 88 static int sdw_mockup_pcm_hw_free(struct snd_pcm_substream *substream, 89 struct snd_soc_dai *dai) 90 { 91 struct snd_soc_component *component = dai->component; 92 struct sdw_mockup_priv *sdw_mockup = snd_soc_component_get_drvdata(component); 93 struct sdw_stream_runtime *sdw_stream = snd_soc_dai_get_dma_data(dai, substream); 94 95 if (!sdw_mockup->slave) 96 return -EINVAL; 97 98 sdw_stream_remove_slave(sdw_mockup->slave, sdw_stream); 99 return 0; 100 } 101 102 static const struct snd_soc_dai_ops sdw_mockup_ops = { 103 .hw_params = sdw_mockup_pcm_hw_params, 104 .hw_free = sdw_mockup_pcm_hw_free, 105 .set_stream = sdw_mockup_set_sdw_stream, 106 .shutdown = sdw_mockup_shutdown, 107 }; 108 109 static struct snd_soc_dai_driver sdw_mockup_dai[] = { 110 { 111 .name = "sdw-mockup-aif1", 112 .id = 1, 113 .playback = { 114 .stream_name = "DP1 Playback", 115 .channels_min = 1, 116 .channels_max = 2, 117 }, 118 .capture = { 119 .stream_name = "DP8 Capture", 120 .channels_min = 1, 121 .channels_max = 2, 122 }, 123 .ops = &sdw_mockup_ops, 124 }, 125 }; 126 127 static int sdw_mockup_update_status(struct sdw_slave *slave, 128 enum sdw_slave_status status) 129 { 130 return 0; 131 } 132 133 static int sdw_mockup_read_prop(struct sdw_slave *slave) 134 { 135 struct sdw_slave_prop *prop = &slave->prop; 136 int nval; 137 int i, j; 138 u32 bit; 139 unsigned long addr; 140 struct sdw_dpn_prop *dpn; 141 142 prop->paging_support = false; 143 144 /* 145 * first we need to allocate memory for set bits in port lists 146 * the port allocation is completely arbitrary: 147 * DP0 is not supported 148 * DP1 is sink 149 * DP8 is source 150 */ 151 prop->source_ports = BIT(8); 152 prop->sink_ports = BIT(1); 153 154 nval = hweight32(prop->source_ports); 155 prop->src_dpn_prop = devm_kcalloc(&slave->dev, nval, 156 sizeof(*prop->src_dpn_prop), 157 GFP_KERNEL); 158 if (!prop->src_dpn_prop) 159 return -ENOMEM; 160 161 i = 0; 162 dpn = prop->src_dpn_prop; 163 addr = prop->source_ports; 164 for_each_set_bit(bit, &addr, 32) { 165 dpn[i].num = bit; 166 dpn[i].type = SDW_DPN_FULL; 167 dpn[i].simple_ch_prep_sm = true; 168 i++; 169 } 170 171 /* do this again for sink now */ 172 nval = hweight32(prop->sink_ports); 173 prop->sink_dpn_prop = devm_kcalloc(&slave->dev, nval, 174 sizeof(*prop->sink_dpn_prop), 175 GFP_KERNEL); 176 if (!prop->sink_dpn_prop) 177 return -ENOMEM; 178 179 j = 0; 180 dpn = prop->sink_dpn_prop; 181 addr = prop->sink_ports; 182 for_each_set_bit(bit, &addr, 32) { 183 dpn[j].num = bit; 184 dpn[j].type = SDW_DPN_FULL; 185 dpn[j].simple_ch_prep_sm = true; 186 j++; 187 } 188 189 prop->simple_clk_stop_capable = true; 190 191 /* wake-up event */ 192 prop->wake_capable = 0; 193 194 return 0; 195 } 196 197 static int sdw_mockup_bus_config(struct sdw_slave *slave, 198 struct sdw_bus_params *params) 199 { 200 return 0; 201 } 202 203 static int sdw_mockup_interrupt_callback(struct sdw_slave *slave, 204 struct sdw_slave_intr_status *status) 205 { 206 return 0; 207 } 208 209 static const struct sdw_slave_ops sdw_mockup_slave_ops = { 210 .read_prop = sdw_mockup_read_prop, 211 .interrupt_callback = sdw_mockup_interrupt_callback, 212 .update_status = sdw_mockup_update_status, 213 .bus_config = sdw_mockup_bus_config, 214 }; 215 216 static int sdw_mockup_sdw_probe(struct sdw_slave *slave, 217 const struct sdw_device_id *id) 218 { 219 struct device *dev = &slave->dev; 220 struct sdw_mockup_priv *sdw_mockup; 221 int ret; 222 223 sdw_mockup = devm_kzalloc(dev, sizeof(*sdw_mockup), GFP_KERNEL); 224 if (!sdw_mockup) 225 return -ENOMEM; 226 227 dev_set_drvdata(dev, sdw_mockup); 228 sdw_mockup->slave = slave; 229 230 slave->is_mockup_device = true; 231 232 ret = devm_snd_soc_register_component(dev, 233 &snd_soc_sdw_mockup_component, 234 sdw_mockup_dai, 235 ARRAY_SIZE(sdw_mockup_dai)); 236 237 return ret; 238 } 239 240 static int sdw_mockup_sdw_remove(struct sdw_slave *slave) 241 { 242 return 0; 243 } 244 245 /* 246 * Intel reserved parts ID with the following mapping expected: 247 * 0xAAAA: generic full-duplex codec 248 * 0xAA55: headset codec (mock-up of RT711/RT5682) - full-duplex 249 * 0x55AA: amplifier (mock-up of RT1308/Maxim 98373) - playback only with 250 * IV feedback 251 * 0x5555: mic codec (mock-up of RT715) - capture-only 252 */ 253 static const struct sdw_device_id sdw_mockup_id[] = { 254 SDW_SLAVE_ENTRY_EXT(0x0105, 0xAAAA, 0x0, 0, 0), 255 SDW_SLAVE_ENTRY_EXT(0x0105, 0xAA55, 0x0, 0, 0), 256 SDW_SLAVE_ENTRY_EXT(0x0105, 0x55AA, 0x0, 0, 0), 257 SDW_SLAVE_ENTRY_EXT(0x0105, 0x5555, 0x0, 0, 0), 258 {}, 259 }; 260 MODULE_DEVICE_TABLE(sdw, sdw_mockup_id); 261 262 static struct sdw_driver sdw_mockup_sdw_driver = { 263 .driver = { 264 .name = "sdw-mockup", 265 .owner = THIS_MODULE, 266 }, 267 .probe = sdw_mockup_sdw_probe, 268 .remove = sdw_mockup_sdw_remove, 269 .ops = &sdw_mockup_slave_ops, 270 .id_table = sdw_mockup_id, 271 }; 272 module_sdw_driver(sdw_mockup_sdw_driver); 273 274 MODULE_DESCRIPTION("ASoC SDW mockup codec driver"); 275 MODULE_AUTHOR("Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>"); 276 MODULE_LICENSE("GPL"); 277