aboutsummaryrefslogtreecommitdiffstats
path: root/sound/soc
diff options
context:
space:
mode:
Diffstat (limited to 'sound/soc')
-rw-r--r--sound/soc/jz4740/Kconfig1
-rw-r--r--sound/soc/jz4740/jz4740-i2s.c54
-rw-r--r--sound/soc/jz4740/jz4740-pcm.c358
-rw-r--r--sound/soc/jz4740/jz4740-pcm.h20
-rw-r--r--sound/soc/jz4740/qi_lb60.c2
5 files changed, 24 insertions, 411 deletions
diff --git a/sound/soc/jz4740/Kconfig b/sound/soc/jz4740/Kconfig
index 5351cba66c9e..29f76af5d963 100644
--- a/sound/soc/jz4740/Kconfig
+++ b/sound/soc/jz4740/Kconfig
@@ -1,6 +1,7 @@
1config SND_JZ4740_SOC 1config SND_JZ4740_SOC
2 tristate "SoC Audio for Ingenic JZ4740 SoC" 2 tristate "SoC Audio for Ingenic JZ4740 SoC"
3 depends on MACH_JZ4740 && SND_SOC 3 depends on MACH_JZ4740 && SND_SOC
4 select SND_SOC_GENERIC_DMAENGINE_PCM
4 help 5 help
5 Say Y or M if you want to add support for codecs attached to 6 Say Y or M if you want to add support for codecs attached to
6 the JZ4740 I2S interface. You will also need to select the audio 7 the JZ4740 I2S interface. You will also need to select the audio
diff --git a/sound/soc/jz4740/jz4740-i2s.c b/sound/soc/jz4740/jz4740-i2s.c
index a0b6a85d89cf..8f220009e0f6 100644
--- a/sound/soc/jz4740/jz4740-i2s.c
+++ b/sound/soc/jz4740/jz4740-i2s.c
@@ -29,9 +29,11 @@
29#include <sound/pcm_params.h> 29#include <sound/pcm_params.h>
30#include <sound/soc.h> 30#include <sound/soc.h>
31#include <sound/initval.h> 31#include <sound/initval.h>
32#include <sound/dmaengine_pcm.h>
33
34#include <asm/mach-jz4740/dma.h>
32 35
33#include "jz4740-i2s.h" 36#include "jz4740-i2s.h"
34#include "jz4740-pcm.h"
35 37
36#define JZ_REG_AIC_CONF 0x00 38#define JZ_REG_AIC_CONF 0x00
37#define JZ_REG_AIC_CTRL 0x04 39#define JZ_REG_AIC_CTRL 0x04
@@ -89,8 +91,8 @@ struct jz4740_i2s {
89 struct clk *clk_aic; 91 struct clk *clk_aic;
90 struct clk *clk_i2s; 92 struct clk *clk_i2s;
91 93
92 struct jz4740_pcm_config pcm_config_playback; 94 struct snd_dmaengine_dai_dma_data playback_dma_data;
93 struct jz4740_pcm_config pcm_config_capture; 95 struct snd_dmaengine_dai_dma_data capture_dma_data;
94}; 96};
95 97
96static inline uint32_t jz4740_i2s_read(const struct jz4740_i2s *i2s, 98static inline uint32_t jz4740_i2s_read(const struct jz4740_i2s *i2s,
@@ -233,8 +235,6 @@ static int jz4740_i2s_hw_params(struct snd_pcm_substream *substream,
233 struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) 235 struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
234{ 236{
235 struct jz4740_i2s *i2s = snd_soc_dai_get_drvdata(dai); 237 struct jz4740_i2s *i2s = snd_soc_dai_get_drvdata(dai);
236 enum jz4740_dma_width dma_width;
237 struct jz4740_pcm_config *pcm_config;
238 unsigned int sample_size; 238 unsigned int sample_size;
239 uint32_t ctrl; 239 uint32_t ctrl;
240 240
@@ -243,11 +243,9 @@ static int jz4740_i2s_hw_params(struct snd_pcm_substream *substream,
243 switch (params_format(params)) { 243 switch (params_format(params)) {
244 case SNDRV_PCM_FORMAT_S8: 244 case SNDRV_PCM_FORMAT_S8:
245 sample_size = 0; 245 sample_size = 0;
246 dma_width = JZ4740_DMA_WIDTH_8BIT;
247 break; 246 break;
248 case SNDRV_PCM_FORMAT_S16: 247 case SNDRV_PCM_FORMAT_S16:
249 sample_size = 1; 248 sample_size = 1;
250 dma_width = JZ4740_DMA_WIDTH_16BIT;
251 break; 249 break;
252 default: 250 default:
253 return -EINVAL; 251 return -EINVAL;
@@ -260,22 +258,13 @@ static int jz4740_i2s_hw_params(struct snd_pcm_substream *substream,
260 ctrl |= JZ_AIC_CTRL_MONO_TO_STEREO; 258 ctrl |= JZ_AIC_CTRL_MONO_TO_STEREO;
261 else 259 else
262 ctrl &= ~JZ_AIC_CTRL_MONO_TO_STEREO; 260 ctrl &= ~JZ_AIC_CTRL_MONO_TO_STEREO;
263
264 pcm_config = &i2s->pcm_config_playback;
265 pcm_config->dma_config.dst_width = dma_width;
266
267 } else { 261 } else {
268 ctrl &= ~JZ_AIC_CTRL_INPUT_SAMPLE_SIZE_MASK; 262 ctrl &= ~JZ_AIC_CTRL_INPUT_SAMPLE_SIZE_MASK;
269 ctrl |= sample_size << JZ_AIC_CTRL_INPUT_SAMPLE_SIZE_OFFSET; 263 ctrl |= sample_size << JZ_AIC_CTRL_INPUT_SAMPLE_SIZE_OFFSET;
270
271 pcm_config = &i2s->pcm_config_capture;
272 pcm_config->dma_config.src_width = dma_width;
273 } 264 }
274 265
275 jz4740_i2s_write(i2s, JZ_REG_AIC_CTRL, ctrl); 266 jz4740_i2s_write(i2s, JZ_REG_AIC_CTRL, ctrl);
276 267
277 snd_soc_dai_set_dma_data(dai, substream, pcm_config);
278
279 return 0; 268 return 0;
280} 269}
281 270
@@ -342,25 +331,19 @@ static int jz4740_i2s_resume(struct snd_soc_dai *dai)
342 331
343static void jz4740_i2c_init_pcm_config(struct jz4740_i2s *i2s) 332static void jz4740_i2c_init_pcm_config(struct jz4740_i2s *i2s)
344{ 333{
345 struct jz4740_dma_config *dma_config; 334 struct snd_dmaengine_dai_dma_data *dma_data;
346 335
347 /* Playback */ 336 /* Playback */
348 dma_config = &i2s->pcm_config_playback.dma_config; 337 dma_data = &i2s->playback_dma_data;
349 dma_config->src_width = JZ4740_DMA_WIDTH_32BIT; 338 dma_data->maxburst = 16;
350 dma_config->transfer_size = JZ4740_DMA_TRANSFER_SIZE_16BYTE; 339 dma_data->slave_id = JZ4740_DMA_TYPE_AIC_TRANSMIT;
351 dma_config->request_type = JZ4740_DMA_TYPE_AIC_TRANSMIT; 340 dma_data->addr = i2s->phys_base + JZ_REG_AIC_FIFO;
352 dma_config->flags = JZ4740_DMA_SRC_AUTOINC;
353 dma_config->mode = JZ4740_DMA_MODE_SINGLE;
354 i2s->pcm_config_playback.fifo_addr = i2s->phys_base + JZ_REG_AIC_FIFO;
355 341
356 /* Capture */ 342 /* Capture */
357 dma_config = &i2s->pcm_config_capture.dma_config; 343 dma_data = &i2s->capture_dma_data;
358 dma_config->dst_width = JZ4740_DMA_WIDTH_32BIT; 344 dma_data->maxburst = 16;
359 dma_config->transfer_size = JZ4740_DMA_TRANSFER_SIZE_16BYTE; 345 dma_data->slave_id = JZ4740_DMA_TYPE_AIC_RECEIVE;
360 dma_config->request_type = JZ4740_DMA_TYPE_AIC_RECEIVE; 346 dma_data->addr = i2s->phys_base + JZ_REG_AIC_FIFO;
361 dma_config->flags = JZ4740_DMA_DST_AUTOINC;
362 dma_config->mode = JZ4740_DMA_MODE_SINGLE;
363 i2s->pcm_config_capture.fifo_addr = i2s->phys_base + JZ_REG_AIC_FIFO;
364} 347}
365 348
366static int jz4740_i2s_dai_probe(struct snd_soc_dai *dai) 349static int jz4740_i2s_dai_probe(struct snd_soc_dai *dai)
@@ -371,6 +354,8 @@ static int jz4740_i2s_dai_probe(struct snd_soc_dai *dai)
371 clk_prepare_enable(i2s->clk_aic); 354 clk_prepare_enable(i2s->clk_aic);
372 355
373 jz4740_i2c_init_pcm_config(i2s); 356 jz4740_i2c_init_pcm_config(i2s);
357 snd_soc_dai_init_dma_data(dai, &i2s->playback_dma_data,
358 &i2s->capture_dma_data);
374 359
375 conf = (7 << JZ_AIC_CONF_FIFO_RX_THRESHOLD_OFFSET) | 360 conf = (7 << JZ_AIC_CONF_FIFO_RX_THRESHOLD_OFFSET) |
376 (8 << JZ_AIC_CONF_FIFO_TX_THRESHOLD_OFFSET) | 361 (8 << JZ_AIC_CONF_FIFO_TX_THRESHOLD_OFFSET) |
@@ -456,8 +441,13 @@ static int jz4740_i2s_dev_probe(struct platform_device *pdev)
456 441
457 platform_set_drvdata(pdev, i2s); 442 platform_set_drvdata(pdev, i2s);
458 443
459 return devm_snd_soc_register_component(&pdev->dev, 444 ret = devm_snd_soc_register_component(&pdev->dev,
460 &jz4740_i2s_component, &jz4740_i2s_dai, 1); 445 &jz4740_i2s_component, &jz4740_i2s_dai, 1);
446 if (ret)
447 return ret;
448
449 return devm_snd_dmaengine_pcm_register(&pdev->dev, NULL,
450 SND_DMAENGINE_PCM_FLAG_COMPAT);
461} 451}
462 452
463static struct platform_driver jz4740_i2s_driver = { 453static struct platform_driver jz4740_i2s_driver = {
diff --git a/sound/soc/jz4740/jz4740-pcm.c b/sound/soc/jz4740/jz4740-pcm.c
deleted file mode 100644
index 1d7ef28585e1..000000000000
--- a/sound/soc/jz4740/jz4740-pcm.c
+++ /dev/null
@@ -1,358 +0,0 @@
1/*
2 * Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License as published by the
6 * Free Software Foundation; either version 2 of the License, or (at your
7 * option) any later version.
8 *
9 * You should have received a copy of the GNU General Public License along
10 * with this program; if not, write to the Free Software Foundation, Inc.,
11 * 675 Mass Ave, Cambridge, MA 02139, USA.
12 *
13 */
14
15#include <linux/init.h>
16#include <linux/interrupt.h>
17#include <linux/kernel.h>
18#include <linux/module.h>
19#include <linux/platform_device.h>
20#include <linux/slab.h>
21
22#include <linux/dma-mapping.h>
23
24#include <sound/core.h>
25#include <sound/pcm.h>
26#include <sound/pcm_params.h>
27#include <sound/soc.h>
28
29#include <asm/mach-jz4740/dma.h>
30#include "jz4740-pcm.h"
31
32struct jz4740_runtime_data {
33 unsigned long dma_period;
34 dma_addr_t dma_start;
35 dma_addr_t dma_pos;
36 dma_addr_t dma_end;
37
38 struct jz4740_dma_chan *dma;
39
40 dma_addr_t fifo_addr;
41};
42
43/* identify hardware playback capabilities */
44static const struct snd_pcm_hardware jz4740_pcm_hardware = {
45 .info = SNDRV_PCM_INFO_MMAP |
46 SNDRV_PCM_INFO_MMAP_VALID |
47 SNDRV_PCM_INFO_INTERLEAVED |
48 SNDRV_PCM_INFO_BLOCK_TRANSFER,
49 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8,
50
51 .rates = SNDRV_PCM_RATE_8000_48000,
52 .channels_min = 1,
53 .channels_max = 2,
54 .period_bytes_min = 16,
55 .period_bytes_max = 2 * PAGE_SIZE,
56 .periods_min = 2,
57 .periods_max = 128,
58 .buffer_bytes_max = 128 * 2 * PAGE_SIZE,
59 .fifo_size = 32,
60};
61
62static void jz4740_pcm_start_transfer(struct jz4740_runtime_data *prtd,
63 struct snd_pcm_substream *substream)
64{
65 unsigned long count;
66
67 if (prtd->dma_pos == prtd->dma_end)
68 prtd->dma_pos = prtd->dma_start;
69
70 if (prtd->dma_pos + prtd->dma_period > prtd->dma_end)
71 count = prtd->dma_end - prtd->dma_pos;
72 else
73 count = prtd->dma_period;
74
75 jz4740_dma_disable(prtd->dma);
76
77 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
78 jz4740_dma_set_src_addr(prtd->dma, prtd->dma_pos);
79 jz4740_dma_set_dst_addr(prtd->dma, prtd->fifo_addr);
80 } else {
81 jz4740_dma_set_src_addr(prtd->dma, prtd->fifo_addr);
82 jz4740_dma_set_dst_addr(prtd->dma, prtd->dma_pos);
83 }
84
85 jz4740_dma_set_transfer_count(prtd->dma, count);
86
87 prtd->dma_pos += count;
88
89 jz4740_dma_enable(prtd->dma);
90}
91
92static void jz4740_pcm_dma_transfer_done(struct jz4740_dma_chan *dma, int err,
93 void *dev_id)
94{
95 struct snd_pcm_substream *substream = dev_id;
96 struct snd_pcm_runtime *runtime = substream->runtime;
97 struct jz4740_runtime_data *prtd = runtime->private_data;
98
99 snd_pcm_period_elapsed(substream);
100
101 jz4740_pcm_start_transfer(prtd, substream);
102}
103
104static int jz4740_pcm_hw_params(struct snd_pcm_substream *substream,
105 struct snd_pcm_hw_params *params)
106{
107 struct snd_pcm_runtime *runtime = substream->runtime;
108 struct jz4740_runtime_data *prtd = runtime->private_data;
109 struct snd_soc_pcm_runtime *rtd = substream->private_data;
110 struct jz4740_pcm_config *config;
111
112 config = snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);
113
114 if (!config)
115 return 0;
116
117 if (!prtd->dma) {
118 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
119 prtd->dma = jz4740_dma_request(substream, "PCM Capture");
120 else
121 prtd->dma = jz4740_dma_request(substream, "PCM Playback");
122 }
123
124 if (!prtd->dma)
125 return -EBUSY;
126
127 jz4740_dma_configure(prtd->dma, &config->dma_config);
128 prtd->fifo_addr = config->fifo_addr;
129
130 jz4740_dma_set_complete_cb(prtd->dma, jz4740_pcm_dma_transfer_done);
131
132 snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
133 runtime->dma_bytes = params_buffer_bytes(params);
134
135 prtd->dma_period = params_period_bytes(params);
136 prtd->dma_start = runtime->dma_addr;
137 prtd->dma_pos = prtd->dma_start;
138 prtd->dma_end = prtd->dma_start + runtime->dma_bytes;
139
140 return 0;
141}
142
143static int jz4740_pcm_hw_free(struct snd_pcm_substream *substream)
144{
145 struct jz4740_runtime_data *prtd = substream->runtime->private_data;
146
147 snd_pcm_set_runtime_buffer(substream, NULL);
148 if (prtd->dma) {
149 jz4740_dma_free(prtd->dma);
150 prtd->dma = NULL;
151 }
152
153 return 0;
154}
155
156static int jz4740_pcm_prepare(struct snd_pcm_substream *substream)
157{
158 struct jz4740_runtime_data *prtd = substream->runtime->private_data;
159
160 if (!prtd->dma)
161 return -EBUSY;
162
163 prtd->dma_pos = prtd->dma_start;
164
165 return 0;
166}
167
168static int jz4740_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
169{
170 struct snd_pcm_runtime *runtime = substream->runtime;
171 struct jz4740_runtime_data *prtd = runtime->private_data;
172
173 switch (cmd) {
174 case SNDRV_PCM_TRIGGER_START:
175 case SNDRV_PCM_TRIGGER_RESUME:
176 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
177 jz4740_pcm_start_transfer(prtd, substream);
178 break;
179 case SNDRV_PCM_TRIGGER_STOP:
180 case SNDRV_PCM_TRIGGER_SUSPEND:
181 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
182 jz4740_dma_disable(prtd->dma);
183 break;
184 default:
185 break;
186 }
187
188 return 0;
189}
190
191static snd_pcm_uframes_t jz4740_pcm_pointer(struct snd_pcm_substream *substream)
192{
193 struct snd_pcm_runtime *runtime = substream->runtime;
194 struct jz4740_runtime_data *prtd = runtime->private_data;
195 unsigned long byte_offset;
196 snd_pcm_uframes_t offset;
197 struct jz4740_dma_chan *dma = prtd->dma;
198
199 /* prtd->dma_pos points to the end of the current transfer. So by
200 * subtracting prdt->dma_start we get the offset to the end of the
201 * current period in bytes. By subtracting the residue of the transfer
202 * we get the current offset in bytes. */
203 byte_offset = prtd->dma_pos - prtd->dma_start;
204 byte_offset -= jz4740_dma_get_residue(dma);
205
206 offset = bytes_to_frames(runtime, byte_offset);
207 if (offset >= runtime->buffer_size)
208 offset = 0;
209
210 return offset;
211}
212
213static int jz4740_pcm_open(struct snd_pcm_substream *substream)
214{
215 struct snd_pcm_runtime *runtime = substream->runtime;
216 struct jz4740_runtime_data *prtd;
217
218 prtd = kzalloc(sizeof(*prtd), GFP_KERNEL);
219 if (prtd == NULL)
220 return -ENOMEM;
221
222 snd_soc_set_runtime_hwparams(substream, &jz4740_pcm_hardware);
223
224 runtime->private_data = prtd;
225
226 return 0;
227}
228
229static int jz4740_pcm_close(struct snd_pcm_substream *substream)
230{
231 struct snd_pcm_runtime *runtime = substream->runtime;
232 struct jz4740_runtime_data *prtd = runtime->private_data;
233
234 kfree(prtd);
235
236 return 0;
237}
238
239static int jz4740_pcm_mmap(struct snd_pcm_substream *substream,
240 struct vm_area_struct *vma)
241{
242 return remap_pfn_range(vma, vma->vm_start,
243 substream->dma_buffer.addr >> PAGE_SHIFT,
244 vma->vm_end - vma->vm_start, vma->vm_page_prot);
245}
246
247static struct snd_pcm_ops jz4740_pcm_ops = {
248 .open = jz4740_pcm_open,
249 .close = jz4740_pcm_close,
250 .ioctl = snd_pcm_lib_ioctl,
251 .hw_params = jz4740_pcm_hw_params,
252 .hw_free = jz4740_pcm_hw_free,
253 .prepare = jz4740_pcm_prepare,
254 .trigger = jz4740_pcm_trigger,
255 .pointer = jz4740_pcm_pointer,
256 .mmap = jz4740_pcm_mmap,
257};
258
259static int jz4740_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, int stream)
260{
261 struct snd_pcm_substream *substream = pcm->streams[stream].substream;
262 struct snd_dma_buffer *buf = &substream->dma_buffer;
263 size_t size = jz4740_pcm_hardware.buffer_bytes_max;
264
265 buf->dev.type = SNDRV_DMA_TYPE_DEV;
266 buf->dev.dev = pcm->card->dev;
267 buf->private_data = NULL;
268
269 buf->area = dma_alloc_noncoherent(pcm->card->dev, size,
270 &buf->addr, GFP_KERNEL);
271 if (!buf->area)
272 return -ENOMEM;
273
274 buf->bytes = size;
275
276 return 0;
277}
278
279static void jz4740_pcm_free(struct snd_pcm *pcm)
280{
281 struct snd_pcm_substream *substream;
282 struct snd_dma_buffer *buf;
283 int stream;
284
285 for (stream = 0; stream < SNDRV_PCM_STREAM_LAST; ++stream) {
286 substream = pcm->streams[stream].substream;
287 if (!substream)
288 continue;
289
290 buf = &substream->dma_buffer;
291 if (!buf->area)
292 continue;
293
294 dma_free_noncoherent(pcm->card->dev, buf->bytes, buf->area,
295 buf->addr);
296 buf->area = NULL;
297 }
298}
299
300static int jz4740_pcm_new(struct snd_soc_pcm_runtime *rtd)
301{
302 struct snd_card *card = rtd->card->snd_card;
303 struct snd_pcm *pcm = rtd->pcm;
304 int ret;
305
306 ret = dma_coerce_mask_and_coherent(card->dev, DMA_BIT_MASK(32));
307 if (ret)
308 return ret;
309
310 if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream) {
311 ret = jz4740_pcm_preallocate_dma_buffer(pcm,
312 SNDRV_PCM_STREAM_PLAYBACK);
313 if (ret)
314 goto err;
315 }
316
317 if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream) {
318 ret = jz4740_pcm_preallocate_dma_buffer(pcm,
319 SNDRV_PCM_STREAM_CAPTURE);
320 if (ret)
321 goto err;
322 }
323
324err:
325 return ret;
326}
327
328static struct snd_soc_platform_driver jz4740_soc_platform = {
329 .ops = &jz4740_pcm_ops,
330 .pcm_new = jz4740_pcm_new,
331 .pcm_free = jz4740_pcm_free,
332};
333
334static int jz4740_pcm_probe(struct platform_device *pdev)
335{
336 return snd_soc_register_platform(&pdev->dev, &jz4740_soc_platform);
337}
338
339static int jz4740_pcm_remove(struct platform_device *pdev)
340{
341 snd_soc_unregister_platform(&pdev->dev);
342 return 0;
343}
344
345static struct platform_driver jz4740_pcm_driver = {
346 .probe = jz4740_pcm_probe,
347 .remove = jz4740_pcm_remove,
348 .driver = {
349 .name = "jz4740-pcm-audio",
350 .owner = THIS_MODULE,
351 },
352};
353
354module_platform_driver(jz4740_pcm_driver);
355
356MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
357MODULE_DESCRIPTION("Ingenic SoC JZ4740 PCM driver");
358MODULE_LICENSE("GPL");
diff --git a/sound/soc/jz4740/jz4740-pcm.h b/sound/soc/jz4740/jz4740-pcm.h
deleted file mode 100644
index 1220cbb4382c..000000000000
--- a/sound/soc/jz4740/jz4740-pcm.h
+++ /dev/null
@@ -1,20 +0,0 @@
1/*
2 *
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License version 2 as
5 * published by the Free Software Foundation.
6 */
7
8#ifndef _JZ4740_PCM_H
9#define _JZ4740_PCM_H
10
11#include <linux/dma-mapping.h>
12#include <asm/mach-jz4740/dma.h>
13
14
15struct jz4740_pcm_config {
16 struct jz4740_dma_config dma_config;
17 phys_addr_t fifo_addr;
18};
19
20#endif
diff --git a/sound/soc/jz4740/qi_lb60.c b/sound/soc/jz4740/qi_lb60.c
index 55fd6b5df55f..82b5f37cd2c7 100644
--- a/sound/soc/jz4740/qi_lb60.c
+++ b/sound/soc/jz4740/qi_lb60.c
@@ -73,7 +73,7 @@ static struct snd_soc_dai_link qi_lb60_dai = {
73 .name = "jz4740", 73 .name = "jz4740",
74 .stream_name = "jz4740", 74 .stream_name = "jz4740",
75 .cpu_dai_name = "jz4740-i2s", 75 .cpu_dai_name = "jz4740-i2s",
76 .platform_name = "jz4740-pcm-audio", 76 .platform_name = "jz4740-i2s",
77 .codec_dai_name = "jz4740-hifi", 77 .codec_dai_name = "jz4740-hifi",
78 .codec_name = "jz4740-codec", 78 .codec_name = "jz4740-codec",
79 .init = qi_lb60_codec_init, 79 .init = qi_lb60_codec_init,
generated by cgit v1.2.2 (git 2.25.0) at 2024-10-13 11:30:31 -0400