2 * Driver for the Conexant CX25821 PCIe bridge
4 * Copyright (C) 2009 Conexant Systems Inc.
5 * Authors <hiep.huynh@conexant.com>, <shu.lin@conexant.com>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
25 #include "cx25821-video.h"
26 #include "cx25821-audio-upstream.h"
29 #include <linux/errno.h>
30 #include <linux/kernel.h>
31 #include <linux/init.h>
32 #include <linux/module.h>
33 #include <linux/syscalls.h>
34 #include <linux/file.h>
35 #include <linux/fcntl.h>
36 #include <linux/delay.h>
37 #include <linux/slab.h>
38 #include <linux/uaccess.h>
40 MODULE_DESCRIPTION("v4l2 driver module for cx25821 based TV cards");
41 MODULE_AUTHOR("Hiep Huynh <hiep.huynh@conexant.com>");
42 MODULE_LICENSE("GPL");
44 static int _intr_msk
= FLD_AUD_SRC_RISCI1
| FLD_AUD_SRC_OF
|
45 FLD_AUD_SRC_SYNC
| FLD_AUD_SRC_OPC_ERR
;
47 int cx25821_sram_channel_setup_upstream_audio(struct cx25821_dev
*dev
,
48 struct sram_channel
*ch
,
49 unsigned int bpl
, u32 risc
)
51 unsigned int i
, lines
;
54 if (ch
->cmds_start
== 0) {
55 cx_write(ch
->ptr1_reg
, 0);
56 cx_write(ch
->ptr2_reg
, 0);
57 cx_write(ch
->cnt2_reg
, 0);
58 cx_write(ch
->cnt1_reg
, 0);
62 bpl
= (bpl
+ 7) & ~7; /* alignment */
64 lines
= ch
->fifo_size
/ bpl
;
72 for (i
= 0; i
< lines
; i
++) {
73 cx_write(cdt
+ 16 * i
, ch
->fifo_start
+ bpl
* i
);
74 cx_write(cdt
+ 16 * i
+ 4, 0);
75 cx_write(cdt
+ 16 * i
+ 8, 0);
76 cx_write(cdt
+ 16 * i
+ 12, 0);
80 cx_write(ch
->cmds_start
+ 0, risc
);
82 cx_write(ch
->cmds_start
+ 4, 0);
83 cx_write(ch
->cmds_start
+ 8, cdt
);
84 cx_write(ch
->cmds_start
+ 12, AUDIO_CDT_SIZE_QW
);
85 cx_write(ch
->cmds_start
+ 16, ch
->ctrl_start
);
88 cx_write(ch
->cmds_start
+ 20, AUDIO_IQ_SIZE_DW
);
90 for (i
= 24; i
< 80; i
+= 4)
91 cx_write(ch
->cmds_start
+ i
, 0);
94 cx_write(ch
->ptr1_reg
, ch
->fifo_start
);
95 cx_write(ch
->ptr2_reg
, cdt
);
96 cx_write(ch
->cnt2_reg
, AUDIO_CDT_SIZE_QW
);
97 cx_write(ch
->cnt1_reg
, AUDIO_CLUSTER_SIZE_QW
- 1);
102 static __le32
*cx25821_risc_field_upstream_audio(struct cx25821_dev
*dev
,
104 dma_addr_t databuf_phys_addr
,
109 struct sram_channel
*sram_ch
=
110 dev
->channels
[dev
->_audio_upstream_channel
].sram_channels
;
114 for (line
= 0; line
< LINES_PER_AUDIO_BUFFER
; line
++) {
115 *(rp
++) = cpu_to_le32(RISC_READ
| RISC_SOL
| RISC_EOL
| bpl
);
116 *(rp
++) = cpu_to_le32(databuf_phys_addr
+ offset
);
117 *(rp
++) = cpu_to_le32(0); /* bits 63-32 */
119 /* Check if we need to enable the FIFO
120 * after the first 3 lines.
121 * For the upstream audio channel,
122 * the risc engine will enable the FIFO */
123 if (fifo_enable
&& line
== 2) {
124 *(rp
++) = RISC_WRITECR
;
125 *(rp
++) = sram_ch
->dma_ctl
;
126 *(rp
++) = sram_ch
->fld_aud_fifo_en
;
127 *(rp
++) = 0x00000020;
130 offset
+= AUDIO_LINE_SIZE
;
136 int cx25821_risc_buffer_upstream_audio(struct cx25821_dev
*dev
,
138 unsigned int bpl
, unsigned int lines
)
142 int frame
= 0, i
= 0;
143 int frame_size
= AUDIO_DATA_BUF_SZ
;
144 int databuf_offset
= 0;
145 int risc_flag
= RISC_CNT_INC
;
146 dma_addr_t risc_phys_jump_addr
;
148 /* Virtual address of Risc buffer program */
149 rp
= dev
->_risc_virt_addr
;
151 /* sync instruction */
152 *(rp
++) = cpu_to_le32(RISC_RESYNC
| AUDIO_SYNC_LINE
);
154 for (frame
= 0; frame
< NUM_AUDIO_FRAMES
; frame
++) {
155 databuf_offset
= frame_size
* frame
;
159 risc_flag
= RISC_CNT_RESET
;
162 risc_flag
= RISC_CNT_INC
;
165 /* Calculate physical jump address */
166 if ((frame
+ 1) == NUM_AUDIO_FRAMES
) {
167 risc_phys_jump_addr
=
168 dev
->_risc_phys_start_addr
+
169 RISC_SYNC_INSTRUCTION_SIZE
;
171 risc_phys_jump_addr
=
172 dev
->_risc_phys_start_addr
+
173 RISC_SYNC_INSTRUCTION_SIZE
+
174 AUDIO_RISC_DMA_BUF_SIZE
* (frame
+ 1);
177 rp
= cx25821_risc_field_upstream_audio(dev
, rp
,
178 dev
->_audiodata_buf_phys_addr
+ databuf_offset
,
181 if (USE_RISC_NOOP_AUDIO
) {
182 for (i
= 0; i
< NUM_NO_OPS
; i
++)
183 *(rp
++) = cpu_to_le32(RISC_NOOP
);
186 /* Loop to (Nth)FrameRISC or to Start of Risc program &
188 *(rp
++) = cpu_to_le32(RISC_JUMP
| RISC_IRQ1
| risc_flag
);
189 *(rp
++) = cpu_to_le32(risc_phys_jump_addr
);
190 *(rp
++) = cpu_to_le32(0);
192 /* Recalculate virtual address based on frame index */
193 rp
= dev
->_risc_virt_addr
+ RISC_SYNC_INSTRUCTION_SIZE
/ 4 +
194 (AUDIO_RISC_DMA_BUF_SIZE
* (frame
+ 1) / 4);
200 void cx25821_free_memory_audio(struct cx25821_dev
*dev
)
202 if (dev
->_risc_virt_addr
) {
203 pci_free_consistent(dev
->pci
, dev
->_audiorisc_size
,
204 dev
->_risc_virt_addr
, dev
->_risc_phys_addr
);
205 dev
->_risc_virt_addr
= NULL
;
208 if (dev
->_audiodata_buf_virt_addr
) {
209 pci_free_consistent(dev
->pci
, dev
->_audiodata_buf_size
,
210 dev
->_audiodata_buf_virt_addr
,
211 dev
->_audiodata_buf_phys_addr
);
212 dev
->_audiodata_buf_virt_addr
= NULL
;
216 void cx25821_stop_upstream_audio(struct cx25821_dev
*dev
)
218 struct sram_channel
*sram_ch
=
219 dev
->channels
[AUDIO_UPSTREAM_SRAM_CHANNEL_B
].sram_channels
;
222 if (!dev
->_audio_is_running
) {
224 pr_fmt("No audio file is currently running so return!\n"));
227 /* Disable RISC interrupts */
228 cx_write(sram_ch
->int_msk
, 0);
230 /* Turn OFF risc and fifo enable in AUD_DMA_CNTRL */
231 tmp
= cx_read(sram_ch
->dma_ctl
);
232 cx_write(sram_ch
->dma_ctl
,
233 tmp
& ~(sram_ch
->fld_aud_fifo_en
| sram_ch
->fld_aud_risc_en
));
235 /* Clear data buffer memory */
236 if (dev
->_audiodata_buf_virt_addr
)
237 memset(dev
->_audiodata_buf_virt_addr
, 0,
238 dev
->_audiodata_buf_size
);
240 dev
->_audio_is_running
= 0;
241 dev
->_is_first_audio_frame
= 0;
242 dev
->_audioframe_count
= 0;
243 dev
->_audiofile_status
= END_OF_FILE
;
245 kfree(dev
->_irq_audio_queues
);
246 dev
->_irq_audio_queues
= NULL
;
248 kfree(dev
->_audiofilename
);
251 void cx25821_free_mem_upstream_audio(struct cx25821_dev
*dev
)
253 if (dev
->_audio_is_running
)
254 cx25821_stop_upstream_audio(dev
);
256 cx25821_free_memory_audio(dev
);
259 int cx25821_get_audio_data(struct cx25821_dev
*dev
,
260 struct sram_channel
*sram_ch
)
263 int frame_index_temp
= dev
->_audioframe_index
;
265 int line_size
= AUDIO_LINE_SIZE
;
266 int frame_size
= AUDIO_DATA_BUF_SZ
;
267 int frame_offset
= frame_size
* frame_index_temp
;
268 ssize_t vfs_read_retval
= 0;
269 char mybuf
[line_size
];
270 loff_t file_offset
= dev
->_audioframe_count
* frame_size
;
274 if (dev
->_audiofile_status
== END_OF_FILE
)
277 myfile
= filp_open(dev
->_audiofilename
, O_RDONLY
| O_LARGEFILE
, 0);
279 if (IS_ERR(myfile
)) {
280 const int open_errno
= -PTR_ERR(myfile
);
281 pr_err("%s(): ERROR opening file(%s) with errno = %d!\n",
282 __func__
, dev
->_audiofilename
, open_errno
);
283 return PTR_ERR(myfile
);
285 if (!(myfile
->f_op
)) {
286 pr_err("%s(): File has no file operations registered!\n",
288 filp_close(myfile
, NULL
);
292 if (!myfile
->f_op
->read
) {
293 pr_err("%s(): File has no READ operations registered!\n",
295 filp_close(myfile
, NULL
);
303 for (i
= 0; i
< dev
->_audio_lines_count
; i
++) {
306 vfs_read_retval
= vfs_read(myfile
, mybuf
, line_size
,
309 if (vfs_read_retval
> 0 && vfs_read_retval
== line_size
310 && dev
->_audiodata_buf_virt_addr
!= NULL
) {
311 memcpy((void *)(dev
->_audiodata_buf_virt_addr
+
312 frame_offset
/ 4), mybuf
,
316 file_offset
+= vfs_read_retval
;
317 frame_offset
+= vfs_read_retval
;
319 if (vfs_read_retval
< line_size
) {
320 pr_info("Done: exit %s() since no more bytes to read from Audio file\n",
327 dev
->_audioframe_count
++;
329 dev
->_audiofile_status
= (vfs_read_retval
== line_size
) ?
330 IN_PROGRESS
: END_OF_FILE
;
333 filp_close(myfile
, NULL
);
339 static void cx25821_audioups_handler(struct work_struct
*work
)
341 struct cx25821_dev
*dev
= container_of(work
, struct cx25821_dev
,
345 pr_err("ERROR %s(): since container_of(work_struct) FAILED!\n",
350 cx25821_get_audio_data(dev
, dev
->channels
[dev
->_audio_upstream_channel
].
354 int cx25821_openfile_audio(struct cx25821_dev
*dev
,
355 struct sram_channel
*sram_ch
)
359 int line_size
= AUDIO_LINE_SIZE
;
360 ssize_t vfs_read_retval
= 0;
361 char mybuf
[line_size
];
363 loff_t offset
= (unsigned long)0;
366 myfile
= filp_open(dev
->_audiofilename
, O_RDONLY
| O_LARGEFILE
, 0);
368 if (IS_ERR(myfile
)) {
369 const int open_errno
= -PTR_ERR(myfile
);
370 pr_err("%s(): ERROR opening file(%s) with errno = %d!\n",
371 __func__
, dev
->_audiofilename
, open_errno
);
372 return PTR_ERR(myfile
);
374 if (!(myfile
->f_op
)) {
375 pr_err("%s(): File has no file operations registered!\n",
377 filp_close(myfile
, NULL
);
381 if (!myfile
->f_op
->read
) {
382 pr_err("%s(): File has no READ operations registered!\n",
384 filp_close(myfile
, NULL
);
392 for (j
= 0; j
< NUM_AUDIO_FRAMES
; j
++) {
393 for (i
= 0; i
< dev
->_audio_lines_count
; i
++) {
396 vfs_read_retval
= vfs_read(myfile
, mybuf
,
399 if (vfs_read_retval
> 0 &&
400 vfs_read_retval
== line_size
&&
401 dev
->_audiodata_buf_virt_addr
!= NULL
) {
402 memcpy((void *)(dev
->
403 _audiodata_buf_virt_addr
404 + offset
/ 4), mybuf
,
408 offset
+= vfs_read_retval
;
410 if (vfs_read_retval
< line_size
) {
411 pr_info("Done: exit %s() since no more bytes to read from Audio file\n",
418 dev
->_audioframe_count
++;
420 if (vfs_read_retval
< line_size
)
424 dev
->_audiofile_status
= (vfs_read_retval
== line_size
) ?
425 IN_PROGRESS
: END_OF_FILE
;
429 filp_close(myfile
, NULL
);
435 static int cx25821_audio_upstream_buffer_prepare(struct cx25821_dev
*dev
,
436 struct sram_channel
*sram_ch
,
441 dma_addr_t data_dma_addr
;
443 cx25821_free_memory_audio(dev
);
445 dev
->_risc_virt_addr
= pci_alloc_consistent(dev
->pci
,
446 dev
->audio_upstream_riscbuf_size
, &dma_addr
);
447 dev
->_risc_virt_start_addr
= dev
->_risc_virt_addr
;
448 dev
->_risc_phys_start_addr
= dma_addr
;
449 dev
->_risc_phys_addr
= dma_addr
;
450 dev
->_audiorisc_size
= dev
->audio_upstream_riscbuf_size
;
452 if (!dev
->_risc_virt_addr
) {
454 pr_fmt("ERROR: pci_alloc_consistent() FAILED to allocate memory for RISC program! Returning\n"));
457 /* Clear out memory at address */
458 memset(dev
->_risc_virt_addr
, 0, dev
->_audiorisc_size
);
460 /* For Audio Data buffer allocation */
461 dev
->_audiodata_buf_virt_addr
= pci_alloc_consistent(dev
->pci
,
462 dev
->audio_upstream_databuf_size
, &data_dma_addr
);
463 dev
->_audiodata_buf_phys_addr
= data_dma_addr
;
464 dev
->_audiodata_buf_size
= dev
->audio_upstream_databuf_size
;
466 if (!dev
->_audiodata_buf_virt_addr
) {
468 pr_fmt("ERROR: pci_alloc_consistent() FAILED to allocate memory for data buffer! Returning\n"));
471 /* Clear out memory at address */
472 memset(dev
->_audiodata_buf_virt_addr
, 0, dev
->_audiodata_buf_size
);
474 ret
= cx25821_openfile_audio(dev
, sram_ch
);
478 /* Creating RISC programs */
479 ret
= cx25821_risc_buffer_upstream_audio(dev
, dev
->pci
, bpl
,
480 dev
->_audio_lines_count
);
483 pr_fmt("ERROR creating audio upstream RISC programs!\n"));
493 int cx25821_audio_upstream_irq(struct cx25821_dev
*dev
, int chan_num
,
498 struct sram_channel
*channel
= dev
->channels
[chan_num
].sram_channels
;
499 dma_addr_t risc_phys_jump_addr
;
502 if (status
& FLD_AUD_SRC_RISCI1
) {
503 /* Get interrupt_index of the program that interrupted */
504 u32 prog_cnt
= cx_read(channel
->gpcnt
);
506 /* Since we've identified our IRQ, clear our bits from the
507 * interrupt mask and interrupt status registers */
508 cx_write(channel
->int_msk
, 0);
509 cx_write(channel
->int_stat
, cx_read(channel
->int_stat
));
511 spin_lock(&dev
->slock
);
513 while (prog_cnt
!= dev
->_last_index_irq
) {
514 /* Update _last_index_irq */
515 if (dev
->_last_index_irq
< (NUMBER_OF_PROGRAMS
- 1))
516 dev
->_last_index_irq
++;
518 dev
->_last_index_irq
= 0;
520 dev
->_audioframe_index
= dev
->_last_index_irq
;
522 queue_work(dev
->_irq_audio_queues
,
523 &dev
->_audio_work_entry
);
526 if (dev
->_is_first_audio_frame
) {
527 dev
->_is_first_audio_frame
= 0;
529 if (dev
->_risc_virt_start_addr
!= NULL
) {
530 risc_phys_jump_addr
=
531 dev
->_risc_phys_start_addr
+
532 RISC_SYNC_INSTRUCTION_SIZE
+
533 AUDIO_RISC_DMA_BUF_SIZE
;
535 rp
= cx25821_risc_field_upstream_audio(dev
,
536 dev
->_risc_virt_start_addr
+ 1,
537 dev
->_audiodata_buf_phys_addr
,
538 AUDIO_LINE_SIZE
, FIFO_DISABLE
);
540 if (USE_RISC_NOOP_AUDIO
) {
541 for (i
= 0; i
< NUM_NO_OPS
; i
++) {
543 cpu_to_le32(RISC_NOOP
);
546 /* Jump to 2nd Audio Frame */
547 *(rp
++) = cpu_to_le32(RISC_JUMP
| RISC_IRQ1
|
549 *(rp
++) = cpu_to_le32(risc_phys_jump_addr
);
550 *(rp
++) = cpu_to_le32(0);
554 spin_unlock(&dev
->slock
);
556 if (status
& FLD_AUD_SRC_OF
)
557 pr_warn("%s(): Audio Received Overflow Error Interrupt!\n",
560 if (status
& FLD_AUD_SRC_SYNC
)
561 pr_warn("%s(): Audio Received Sync Error Interrupt!\n",
564 if (status
& FLD_AUD_SRC_OPC_ERR
)
565 pr_warn("%s(): Audio Received OpCode Error Interrupt!\n",
568 /* Read and write back the interrupt status register to clear
570 cx_write(channel
->int_stat
, cx_read(channel
->int_stat
));
573 if (dev
->_audiofile_status
== END_OF_FILE
) {
574 pr_warn("EOF Channel Audio Framecount = %d\n",
575 dev
->_audioframe_count
);
578 /* ElSE, set the interrupt mask register, re-enable irq. */
579 int_msk_tmp
= cx_read(channel
->int_msk
);
580 cx_write(channel
->int_msk
, int_msk_tmp
|= _intr_msk
);
585 static irqreturn_t
cx25821_upstream_irq_audio(int irq
, void *dev_id
)
587 struct cx25821_dev
*dev
= dev_id
;
588 u32 msk_stat
, audio_status
;
590 struct sram_channel
*sram_ch
;
595 sram_ch
= dev
->channels
[dev
->_audio_upstream_channel
].sram_channels
;
597 msk_stat
= cx_read(sram_ch
->int_mstat
);
598 audio_status
= cx_read(sram_ch
->int_stat
);
600 /* Only deal with our interrupt */
602 handled
= cx25821_audio_upstream_irq(dev
,
603 dev
->_audio_upstream_channel
, audio_status
);
607 cx25821_stop_upstream_audio(dev
);
611 return IRQ_RETVAL(handled
);
614 static void cx25821_wait_fifo_enable(struct cx25821_dev
*dev
,
615 struct sram_channel
*sram_ch
)
621 /* Wait 10 microsecond before checking to see if the FIFO is
625 tmp
= cx_read(sram_ch
->dma_ctl
);
627 /* 10 millisecond timeout */
628 if (count
++ > 1000) {
629 pr_err("ERROR: %s() fifo is NOT turned on. Timeout!\n",
634 } while (!(tmp
& sram_ch
->fld_aud_fifo_en
));
638 int cx25821_start_audio_dma_upstream(struct cx25821_dev
*dev
,
639 struct sram_channel
*sram_ch
)
644 /* Set the physical start address of the RISC program in the initial
645 * program counter(IPC) member of the CMDS. */
646 cx_write(sram_ch
->cmds_start
+ 0, dev
->_risc_phys_addr
);
647 /* Risc IPC High 64 bits 63-32 */
648 cx_write(sram_ch
->cmds_start
+ 4, 0);
651 cx_write(sram_ch
->gpcnt_ctl
, 3);
653 /* Set the line length (It looks like we do not need to set the
655 cx_write(sram_ch
->aud_length
, AUDIO_LINE_SIZE
& FLD_AUD_DST_LN_LNGTH
);
657 /* Set the input mode to 16-bit */
658 tmp
= cx_read(sram_ch
->aud_cfg
);
659 tmp
|= FLD_AUD_SRC_ENABLE
| FLD_AUD_DST_PK_MODE
| FLD_AUD_CLK_ENABLE
|
660 FLD_AUD_MASTER_MODE
| FLD_AUD_CLK_SELECT_PLL_D
|
662 cx_write(sram_ch
->aud_cfg
, tmp
);
664 /* Read and write back the interrupt status register to clear it */
665 tmp
= cx_read(sram_ch
->int_stat
);
666 cx_write(sram_ch
->int_stat
, tmp
);
668 /* Clear our bits from the interrupt status register. */
669 cx_write(sram_ch
->int_stat
, _intr_msk
);
671 /* Set the interrupt mask register, enable irq. */
672 cx_set(PCI_INT_MSK
, cx_read(PCI_INT_MSK
) | (1 << sram_ch
->irq_bit
));
673 tmp
= cx_read(sram_ch
->int_msk
);
674 cx_write(sram_ch
->int_msk
, tmp
|= _intr_msk
);
676 err
= request_irq(dev
->pci
->irq
, cx25821_upstream_irq_audio
,
677 IRQF_SHARED
, dev
->name
, dev
);
679 pr_err("%s: can't get upstream IRQ %d\n", dev
->name
,
684 /* Start the DMA engine */
685 tmp
= cx_read(sram_ch
->dma_ctl
);
686 cx_set(sram_ch
->dma_ctl
, tmp
| sram_ch
->fld_aud_risc_en
);
688 dev
->_audio_is_running
= 1;
689 dev
->_is_first_audio_frame
= 1;
691 /* The fifo_en bit turns on by the first Risc program */
692 cx25821_wait_fifo_enable(dev
, sram_ch
);
697 cx25821_dev_unregister(dev
);
701 int cx25821_audio_upstream_init(struct cx25821_dev
*dev
, int channel_select
)
703 struct sram_channel
*sram_ch
;
708 if (dev
->_audio_is_running
) {
709 pr_warn("Audio Channel is still running so return!\n");
713 dev
->_audio_upstream_channel
= channel_select
;
714 sram_ch
= dev
->channels
[channel_select
].sram_channels
;
717 INIT_WORK(&dev
->_audio_work_entry
, cx25821_audioups_handler
);
718 dev
->_irq_audio_queues
=
719 create_singlethread_workqueue("cx25821_audioworkqueue");
721 if (!dev
->_irq_audio_queues
) {
723 pr_fmt("ERROR: create_singlethread_workqueue() for Audio FAILED!\n"));
727 dev
->_last_index_irq
= 0;
728 dev
->_audio_is_running
= 0;
729 dev
->_audioframe_count
= 0;
730 dev
->_audiofile_status
= RESET_STATUS
;
731 dev
->_audio_lines_count
= LINES_PER_AUDIO_BUFFER
;
732 _line_size
= AUDIO_LINE_SIZE
;
734 if (dev
->input_audiofilename
) {
735 str_length
= strlen(dev
->input_audiofilename
);
736 dev
->_audiofilename
= kmemdup(dev
->input_audiofilename
,
737 str_length
+ 1, GFP_KERNEL
);
739 if (!dev
->_audiofilename
)
742 /* Default if filename is empty string */
743 if (strcmp(dev
->input_audiofilename
, "") == 0)
744 dev
->_audiofilename
= "/root/audioGOOD.wav";
746 str_length
= strlen(_defaultAudioName
);
747 dev
->_audiofilename
= kmemdup(_defaultAudioName
,
748 str_length
+ 1, GFP_KERNEL
);
750 if (!dev
->_audiofilename
)
754 retval
= cx25821_sram_channel_setup_upstream_audio(dev
, sram_ch
,
757 dev
->audio_upstream_riscbuf_size
=
758 AUDIO_RISC_DMA_BUF_SIZE
* NUM_AUDIO_PROGS
+
759 RISC_SYNC_INSTRUCTION_SIZE
;
760 dev
->audio_upstream_databuf_size
= AUDIO_DATA_BUF_SZ
* NUM_AUDIO_PROGS
;
762 /* Allocating buffers and prepare RISC program */
763 retval
= cx25821_audio_upstream_buffer_prepare(dev
, sram_ch
,
766 pr_err("%s: Failed to set up Audio upstream buffers!\n",
770 /* Start RISC engine */
771 cx25821_start_audio_dma_upstream(dev
, sram_ch
);
776 cx25821_dev_unregister(dev
);