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 #include "cx25821-video.h"
24 #include "cx25821-audio-upstream.h"
27 #include <linux/errno.h>
28 #include <linux/kernel.h>
29 #include <linux/init.h>
30 #include <linux/module.h>
31 #include <linux/syscalls.h>
32 #include <linux/file.h>
33 #include <linux/fcntl.h>
34 #include <linux/delay.h>
35 #include <linux/slab.h>
36 #include <linux/uaccess.h>
38 MODULE_DESCRIPTION("v4l2 driver module for cx25821 based TV cards");
39 MODULE_AUTHOR("Hiep Huynh <hiep.huynh@conexant.com>");
40 MODULE_LICENSE("GPL");
42 static int _intr_msk
=
43 FLD_AUD_SRC_RISCI1
| FLD_AUD_SRC_OF
| FLD_AUD_SRC_SYNC
|
46 int cx25821_sram_channel_setup_upstream_audio(struct cx25821_dev
*dev
,
47 struct sram_channel
*ch
,
48 unsigned int bpl
, u32 risc
)
50 unsigned int i
, lines
;
53 if (ch
->cmds_start
== 0) {
54 cx_write(ch
->ptr1_reg
, 0);
55 cx_write(ch
->ptr2_reg
, 0);
56 cx_write(ch
->cnt2_reg
, 0);
57 cx_write(ch
->cnt1_reg
, 0);
61 bpl
= (bpl
+ 7) & ~7; /* alignment */
63 lines
= ch
->fifo_size
/ bpl
;
71 for (i
= 0; i
< lines
; i
++) {
72 cx_write(cdt
+ 16 * i
, ch
->fifo_start
+ bpl
* i
);
73 cx_write(cdt
+ 16 * i
+ 4, 0);
74 cx_write(cdt
+ 16 * i
+ 8, 0);
75 cx_write(cdt
+ 16 * i
+ 12, 0);
79 cx_write(ch
->cmds_start
+ 0, risc
);
81 cx_write(ch
->cmds_start
+ 4, 0);
82 cx_write(ch
->cmds_start
+ 8, cdt
);
83 cx_write(ch
->cmds_start
+ 12, AUDIO_CDT_SIZE_QW
);
84 cx_write(ch
->cmds_start
+ 16, ch
->ctrl_start
);
87 cx_write(ch
->cmds_start
+ 20, AUDIO_IQ_SIZE_DW
);
89 for (i
= 24; i
< 80; i
+= 4)
90 cx_write(ch
->cmds_start
+ i
, 0);
93 cx_write(ch
->ptr1_reg
, ch
->fifo_start
);
94 cx_write(ch
->ptr2_reg
, cdt
);
95 cx_write(ch
->cnt2_reg
, AUDIO_CDT_SIZE_QW
);
96 cx_write(ch
->cnt1_reg
, AUDIO_CLUSTER_SIZE_QW
- 1);
101 static __le32
*cx25821_risc_field_upstream_audio(struct cx25821_dev
*dev
,
103 dma_addr_t databuf_phys_addr
,
108 struct sram_channel
*sram_ch
=
109 dev
->channels
[dev
->_audio_upstream_channel_select
].sram_channels
;
113 for (line
= 0; line
< LINES_PER_AUDIO_BUFFER
; line
++) {
114 *(rp
++) = cpu_to_le32(RISC_READ
| RISC_SOL
| RISC_EOL
| bpl
);
115 *(rp
++) = cpu_to_le32(databuf_phys_addr
+ offset
);
116 *(rp
++) = cpu_to_le32(0); /* bits 63-32 */
118 /* Check if we need to enable the FIFO
119 * after the first 3 lines.
120 * For the upstream audio channel,
121 * the risc engine will enable the FIFO */
122 if (fifo_enable
&& line
== 2) {
123 *(rp
++) = RISC_WRITECR
;
124 *(rp
++) = sram_ch
->dma_ctl
;
125 *(rp
++) = sram_ch
->fld_aud_fifo_en
;
126 *(rp
++) = 0x00000020;
129 offset
+= AUDIO_LINE_SIZE
;
135 int cx25821_risc_buffer_upstream_audio(struct cx25821_dev
*dev
,
137 unsigned int bpl
, unsigned int lines
)
141 int frame
= 0, i
= 0;
142 int frame_size
= AUDIO_DATA_BUF_SZ
;
143 int databuf_offset
= 0;
144 int risc_flag
= RISC_CNT_INC
;
145 dma_addr_t risc_phys_jump_addr
;
147 /* Virtual address of Risc buffer program */
148 rp
= dev
->_risc_virt_addr
;
150 /* sync instruction */
151 *(rp
++) = cpu_to_le32(RISC_RESYNC
| AUDIO_SYNC_LINE
);
153 for (frame
= 0; frame
< NUM_AUDIO_FRAMES
; frame
++) {
154 databuf_offset
= frame_size
* frame
;
158 risc_flag
= RISC_CNT_RESET
;
161 risc_flag
= RISC_CNT_INC
;
164 /* Calculate physical jump address */
165 if ((frame
+ 1) == NUM_AUDIO_FRAMES
) {
166 risc_phys_jump_addr
=
167 dev
->_risc_phys_start_addr
+
168 RISC_SYNC_INSTRUCTION_SIZE
;
170 risc_phys_jump_addr
=
171 dev
->_risc_phys_start_addr
+
172 RISC_SYNC_INSTRUCTION_SIZE
+
173 AUDIO_RISC_DMA_BUF_SIZE
* (frame
+ 1);
176 rp
= cx25821_risc_field_upstream_audio(dev
, rp
,
178 _audiodata_buf_phys_addr
179 + databuf_offset
, bpl
,
182 if (USE_RISC_NOOP_AUDIO
) {
183 for (i
= 0; i
< NUM_NO_OPS
; i
++)
184 *(rp
++) = cpu_to_le32(RISC_NOOP
);
187 /* Loop to (Nth)FrameRISC or to Start of Risc program &
189 *(rp
++) = cpu_to_le32(RISC_JUMP
| RISC_IRQ1
| risc_flag
);
190 *(rp
++) = cpu_to_le32(risc_phys_jump_addr
);
191 *(rp
++) = cpu_to_le32(0);
193 /* Recalculate virtual address based on frame index */
194 rp
= dev
->_risc_virt_addr
+ RISC_SYNC_INSTRUCTION_SIZE
/ 4 +
195 (AUDIO_RISC_DMA_BUF_SIZE
* (frame
+ 1) / 4);
201 void cx25821_free_memory_audio(struct cx25821_dev
*dev
)
203 if (dev
->_risc_virt_addr
) {
204 pci_free_consistent(dev
->pci
, dev
->_audiorisc_size
,
205 dev
->_risc_virt_addr
, dev
->_risc_phys_addr
);
206 dev
->_risc_virt_addr
= NULL
;
209 if (dev
->_audiodata_buf_virt_addr
) {
210 pci_free_consistent(dev
->pci
, dev
->_audiodata_buf_size
,
211 dev
->_audiodata_buf_virt_addr
,
212 dev
->_audiodata_buf_phys_addr
);
213 dev
->_audiodata_buf_virt_addr
= NULL
;
217 void cx25821_stop_upstream_audio(struct cx25821_dev
*dev
)
219 struct sram_channel
*sram_ch
=
220 dev
->channels
[AUDIO_UPSTREAM_SRAM_CHANNEL_B
].sram_channels
;
223 if (!dev
->_audio_is_running
) {
225 "cx25821: No audio file is currently running so return!\n");
228 /* Disable RISC interrupts */
229 cx_write(sram_ch
->int_msk
, 0);
231 /* Turn OFF risc and fifo enable in AUD_DMA_CNTRL */
232 tmp
= cx_read(sram_ch
->dma_ctl
);
233 cx_write(sram_ch
->dma_ctl
,
234 tmp
& ~(sram_ch
->fld_aud_fifo_en
| sram_ch
->fld_aud_risc_en
));
236 /* Clear data buffer memory */
237 if (dev
->_audiodata_buf_virt_addr
)
238 memset(dev
->_audiodata_buf_virt_addr
, 0,
239 dev
->_audiodata_buf_size
);
241 dev
->_audio_is_running
= 0;
242 dev
->_is_first_audio_frame
= 0;
243 dev
->_audioframe_count
= 0;
244 dev
->_audiofile_status
= END_OF_FILE
;
246 if (dev
->_irq_audio_queues
) {
247 kfree(dev
->_irq_audio_queues
);
248 dev
->_irq_audio_queues
= NULL
;
251 if (dev
->_audiofilename
!= NULL
)
252 kfree(dev
->_audiofilename
);
255 void cx25821_free_mem_upstream_audio(struct cx25821_dev
*dev
)
257 if (dev
->_audio_is_running
)
258 cx25821_stop_upstream_audio(dev
);
260 cx25821_free_memory_audio(dev
);
263 int cx25821_get_audio_data(struct cx25821_dev
*dev
,
264 struct sram_channel
*sram_ch
)
267 int frame_index_temp
= dev
->_audioframe_index
;
269 int line_size
= AUDIO_LINE_SIZE
;
270 int frame_size
= AUDIO_DATA_BUF_SZ
;
271 int frame_offset
= frame_size
* frame_index_temp
;
272 ssize_t vfs_read_retval
= 0;
273 char mybuf
[line_size
];
274 loff_t file_offset
= dev
->_audioframe_count
* frame_size
;
278 if (dev
->_audiofile_status
== END_OF_FILE
)
281 myfile
= filp_open(dev
->_audiofilename
, O_RDONLY
| O_LARGEFILE
, 0);
283 if (IS_ERR(myfile
)) {
284 const int open_errno
= -PTR_ERR(myfile
);
285 printk(KERN_ERR
"%s(): ERROR opening file(%s) with errno = %d!\n",
286 __func__
, dev
->_audiofilename
, open_errno
);
287 return PTR_ERR(myfile
);
289 if (!(myfile
->f_op
)) {
290 printk(KERN_ERR
"%s: File has no file operations registered!\n",
292 filp_close(myfile
, NULL
);
296 if (!myfile
->f_op
->read
) {
297 printk(KERN_ERR
"%s: File has no READ operations registered!\n",
299 filp_close(myfile
, NULL
);
307 for (i
= 0; i
< dev
->_audio_lines_count
; i
++) {
311 vfs_read(myfile
, mybuf
, line_size
, &pos
);
313 if (vfs_read_retval
> 0 && vfs_read_retval
== line_size
314 && dev
->_audiodata_buf_virt_addr
!= NULL
) {
315 memcpy((void *)(dev
->_audiodata_buf_virt_addr
+
316 frame_offset
/ 4), mybuf
,
320 file_offset
+= vfs_read_retval
;
321 frame_offset
+= vfs_read_retval
;
323 if (vfs_read_retval
< line_size
) {
325 "Done: exit %s() since no more bytes to read from Audio file.\n",
332 dev
->_audioframe_count
++;
334 dev
->_audiofile_status
=
335 (vfs_read_retval
== line_size
) ? IN_PROGRESS
: END_OF_FILE
;
338 filp_close(myfile
, NULL
);
344 static void cx25821_audioups_handler(struct work_struct
*work
)
346 struct cx25821_dev
*dev
=
347 container_of(work
, struct cx25821_dev
, _audio_work_entry
);
350 printk(KERN_ERR
"ERROR %s(): since container_of(work_struct) FAILED!\n",
355 cx25821_get_audio_data(dev
,
357 _audio_upstream_channel_select
].
361 int cx25821_openfile_audio(struct cx25821_dev
*dev
,
362 struct sram_channel
*sram_ch
)
366 int line_size
= AUDIO_LINE_SIZE
;
367 ssize_t vfs_read_retval
= 0;
368 char mybuf
[line_size
];
370 loff_t offset
= (unsigned long)0;
373 myfile
= filp_open(dev
->_audiofilename
, O_RDONLY
| O_LARGEFILE
, 0);
375 if (IS_ERR(myfile
)) {
376 const int open_errno
= -PTR_ERR(myfile
);
377 printk(KERN_ERR
"%s(): ERROR opening file(%s) with errno = %d!\n",
378 __func__
, dev
->_audiofilename
, open_errno
);
379 return PTR_ERR(myfile
);
381 if (!(myfile
->f_op
)) {
382 printk(KERN_ERR
"%s: File has no file operations registered!\n",
384 filp_close(myfile
, NULL
);
388 if (!myfile
->f_op
->read
) {
389 printk(KERN_ERR
"%s: File has no READ operations registered!\n",
391 filp_close(myfile
, NULL
);
399 for (j
= 0; j
< NUM_AUDIO_FRAMES
; j
++) {
400 for (i
= 0; i
< dev
->_audio_lines_count
; i
++) {
404 vfs_read(myfile
, mybuf
, line_size
, &pos
);
406 if (vfs_read_retval
> 0
407 && vfs_read_retval
== line_size
408 && dev
->_audiodata_buf_virt_addr
!= NULL
) {
409 memcpy((void *)(dev
->
410 _audiodata_buf_virt_addr
411 + offset
/ 4), mybuf
,
415 offset
+= vfs_read_retval
;
417 if (vfs_read_retval
< line_size
) {
419 "Done: exit %s() since no more bytes to read from Audio file.\n",
426 dev
->_audioframe_count
++;
428 if (vfs_read_retval
< line_size
)
432 dev
->_audiofile_status
=
433 (vfs_read_retval
== line_size
) ? IN_PROGRESS
: END_OF_FILE
;
437 filp_close(myfile
, NULL
);
443 static int cx25821_audio_upstream_buffer_prepare(struct cx25821_dev
*dev
,
444 struct sram_channel
*sram_ch
,
449 dma_addr_t data_dma_addr
;
451 cx25821_free_memory_audio(dev
);
453 dev
->_risc_virt_addr
=
454 pci_alloc_consistent(dev
->pci
, dev
->audio_upstream_riscbuf_size
,
456 dev
->_risc_virt_start_addr
= dev
->_risc_virt_addr
;
457 dev
->_risc_phys_start_addr
= dma_addr
;
458 dev
->_risc_phys_addr
= dma_addr
;
459 dev
->_audiorisc_size
= dev
->audio_upstream_riscbuf_size
;
461 if (!dev
->_risc_virt_addr
) {
463 "cx25821 ERROR: pci_alloc_consistent() FAILED to allocate memory for RISC program! Returning.\n");
466 /* Clear out memory at address */
467 memset(dev
->_risc_virt_addr
, 0, dev
->_audiorisc_size
);
469 /* For Audio Data buffer allocation */
470 dev
->_audiodata_buf_virt_addr
=
471 pci_alloc_consistent(dev
->pci
, dev
->audio_upstream_databuf_size
,
473 dev
->_audiodata_buf_phys_addr
= data_dma_addr
;
474 dev
->_audiodata_buf_size
= dev
->audio_upstream_databuf_size
;
476 if (!dev
->_audiodata_buf_virt_addr
) {
478 "cx25821 ERROR: pci_alloc_consistent() FAILED to allocate memory for data buffer! Returning.\n");
481 /* Clear out memory at address */
482 memset(dev
->_audiodata_buf_virt_addr
, 0, dev
->_audiodata_buf_size
);
484 ret
= cx25821_openfile_audio(dev
, sram_ch
);
488 /* Creating RISC programs */
490 cx25821_risc_buffer_upstream_audio(dev
, dev
->pci
, bpl
,
491 dev
->_audio_lines_count
);
494 "cx25821 ERROR creating audio upstream RISC programs!\n");
504 int cx25821_audio_upstream_irq(struct cx25821_dev
*dev
, int chan_num
,
509 struct sram_channel
*channel
= dev
->channels
[chan_num
].sram_channels
;
510 dma_addr_t risc_phys_jump_addr
;
513 if (status
& FLD_AUD_SRC_RISCI1
) {
514 /* Get interrupt_index of the program that interrupted */
515 u32 prog_cnt
= cx_read(channel
->gpcnt
);
517 /* Since we've identified our IRQ, clear our bits from the
518 * interrupt mask and interrupt status registers */
519 cx_write(channel
->int_msk
, 0);
520 cx_write(channel
->int_stat
, cx_read(channel
->int_stat
));
522 spin_lock(&dev
->slock
);
524 while (prog_cnt
!= dev
->_last_index_irq
) {
525 /* Update _last_index_irq */
526 if (dev
->_last_index_irq
< (NUMBER_OF_PROGRAMS
- 1))
527 dev
->_last_index_irq
++;
529 dev
->_last_index_irq
= 0;
531 dev
->_audioframe_index
= dev
->_last_index_irq
;
533 queue_work(dev
->_irq_audio_queues
,
534 &dev
->_audio_work_entry
);
537 if (dev
->_is_first_audio_frame
) {
538 dev
->_is_first_audio_frame
= 0;
540 if (dev
->_risc_virt_start_addr
!= NULL
) {
541 risc_phys_jump_addr
=
542 dev
->_risc_phys_start_addr
+
543 RISC_SYNC_INSTRUCTION_SIZE
+
544 AUDIO_RISC_DMA_BUF_SIZE
;
546 rp
= cx25821_risc_field_upstream_audio(dev
,
548 _risc_virt_start_addr
551 _audiodata_buf_phys_addr
,
555 if (USE_RISC_NOOP_AUDIO
) {
556 for (i
= 0; i
< NUM_NO_OPS
; i
++) {
558 cpu_to_le32(RISC_NOOP
);
561 /* Jump to 2nd Audio Frame */
563 cpu_to_le32(RISC_JUMP
| RISC_IRQ1
|
565 *(rp
++) = cpu_to_le32(risc_phys_jump_addr
);
566 *(rp
++) = cpu_to_le32(0);
570 spin_unlock(&dev
->slock
);
572 if (status
& FLD_AUD_SRC_OF
)
573 printk(KERN_WARNING
"%s: Audio Received Overflow Error Interrupt!\n",
576 if (status
& FLD_AUD_SRC_SYNC
)
577 printk(KERN_WARNING
"%s: Audio Received Sync Error Interrupt!\n",
580 if (status
& FLD_AUD_SRC_OPC_ERR
)
581 printk(KERN_WARNING
"%s: Audio Received OpCode Error Interrupt!\n",
584 /* Read and write back the interrupt status register to clear
586 cx_write(channel
->int_stat
, cx_read(channel
->int_stat
));
589 if (dev
->_audiofile_status
== END_OF_FILE
) {
590 printk(KERN_WARNING
"cx25821: EOF Channel Audio Framecount = %d\n",
591 dev
->_audioframe_count
);
594 /* ElSE, set the interrupt mask register, re-enable irq. */
595 int_msk_tmp
= cx_read(channel
->int_msk
);
596 cx_write(channel
->int_msk
, int_msk_tmp
|= _intr_msk
);
601 static irqreturn_t
cx25821_upstream_irq_audio(int irq
, void *dev_id
)
603 struct cx25821_dev
*dev
= dev_id
;
604 u32 msk_stat
, audio_status
;
606 struct sram_channel
*sram_ch
;
611 sram_ch
= dev
->channels
[dev
->_audio_upstream_channel_select
].
614 msk_stat
= cx_read(sram_ch
->int_mstat
);
615 audio_status
= cx_read(sram_ch
->int_stat
);
617 /* Only deal with our interrupt */
620 cx25821_audio_upstream_irq(dev
,
622 _audio_upstream_channel_select
,
627 cx25821_stop_upstream_audio(dev
);
631 return IRQ_RETVAL(handled
);
634 static void cx25821_wait_fifo_enable(struct cx25821_dev
*dev
,
635 struct sram_channel
*sram_ch
)
641 /* Wait 10 microsecond before checking to see if the FIFO is
645 tmp
= cx_read(sram_ch
->dma_ctl
);
647 /* 10 millisecond timeout */
648 if (count
++ > 1000) {
650 "cx25821 ERROR: %s() fifo is NOT turned on. Timeout!\n",
655 } while (!(tmp
& sram_ch
->fld_aud_fifo_en
));
659 int cx25821_start_audio_dma_upstream(struct cx25821_dev
*dev
,
660 struct sram_channel
*sram_ch
)
665 /* Set the physical start address of the RISC program in the initial
666 * program counter(IPC) member of the CMDS. */
667 cx_write(sram_ch
->cmds_start
+ 0, dev
->_risc_phys_addr
);
668 /* Risc IPC High 64 bits 63-32 */
669 cx_write(sram_ch
->cmds_start
+ 4, 0);
672 cx_write(sram_ch
->gpcnt_ctl
, 3);
674 /* Set the line length (It looks like we do not need to set the
676 cx_write(sram_ch
->aud_length
, AUDIO_LINE_SIZE
& FLD_AUD_DST_LN_LNGTH
);
678 /* Set the input mode to 16-bit */
679 tmp
= cx_read(sram_ch
->aud_cfg
);
681 FLD_AUD_SRC_ENABLE
| FLD_AUD_DST_PK_MODE
| FLD_AUD_CLK_ENABLE
|
682 FLD_AUD_MASTER_MODE
| FLD_AUD_CLK_SELECT_PLL_D
| FLD_AUD_SONY_MODE
;
683 cx_write(sram_ch
->aud_cfg
, tmp
);
685 /* Read and write back the interrupt status register to clear it */
686 tmp
= cx_read(sram_ch
->int_stat
);
687 cx_write(sram_ch
->int_stat
, tmp
);
689 /* Clear our bits from the interrupt status register. */
690 cx_write(sram_ch
->int_stat
, _intr_msk
);
692 /* Set the interrupt mask register, enable irq. */
693 cx_set(PCI_INT_MSK
, cx_read(PCI_INT_MSK
) | (1 << sram_ch
->irq_bit
));
694 tmp
= cx_read(sram_ch
->int_msk
);
695 cx_write(sram_ch
->int_msk
, tmp
|= _intr_msk
);
698 request_irq(dev
->pci
->irq
, cx25821_upstream_irq_audio
,
699 IRQF_SHARED
| IRQF_DISABLED
, dev
->name
, dev
);
701 printk(KERN_ERR
"%s: can't get upstream IRQ %d\n", dev
->name
,
706 /* Start the DMA engine */
707 tmp
= cx_read(sram_ch
->dma_ctl
);
708 cx_set(sram_ch
->dma_ctl
, tmp
| sram_ch
->fld_aud_risc_en
);
710 dev
->_audio_is_running
= 1;
711 dev
->_is_first_audio_frame
= 1;
713 /* The fifo_en bit turns on by the first Risc program */
714 cx25821_wait_fifo_enable(dev
, sram_ch
);
719 cx25821_dev_unregister(dev
);
723 int cx25821_audio_upstream_init(struct cx25821_dev
*dev
, int channel_select
)
725 struct sram_channel
*sram_ch
;
730 if (dev
->_audio_is_running
) {
731 printk(KERN_WARNING
"Audio Channel is still running so return!\n");
735 dev
->_audio_upstream_channel_select
= channel_select
;
736 sram_ch
= dev
->channels
[channel_select
].sram_channels
;
739 INIT_WORK(&dev
->_audio_work_entry
, cx25821_audioups_handler
);
740 dev
->_irq_audio_queues
=
741 create_singlethread_workqueue("cx25821_audioworkqueue");
743 if (!dev
->_irq_audio_queues
) {
745 "cx25821 ERROR: create_singlethread_workqueue() for Audio FAILED!\n");
749 dev
->_last_index_irq
= 0;
750 dev
->_audio_is_running
= 0;
751 dev
->_audioframe_count
= 0;
752 dev
->_audiofile_status
= RESET_STATUS
;
753 dev
->_audio_lines_count
= LINES_PER_AUDIO_BUFFER
;
754 _line_size
= AUDIO_LINE_SIZE
;
756 if (dev
->input_audiofilename
) {
757 str_length
= strlen(dev
->input_audiofilename
);
758 dev
->_audiofilename
= kmalloc(str_length
+ 1, GFP_KERNEL
);
760 if (!dev
->_audiofilename
)
763 memcpy(dev
->_audiofilename
, dev
->input_audiofilename
,
766 /* Default if filename is empty string */
767 if (strcmp(dev
->input_audiofilename
, "") == 0) {
768 dev
->_audiofilename
= "/root/audioGOOD.wav";
771 str_length
= strlen(_defaultAudioName
);
772 dev
->_audiofilename
= kmalloc(str_length
+ 1, GFP_KERNEL
);
774 if (!dev
->_audiofilename
)
777 memcpy(dev
->_audiofilename
, _defaultAudioName
, str_length
+ 1);
781 cx25821_sram_channel_setup_upstream_audio(dev
, sram_ch
, _line_size
,
784 dev
->audio_upstream_riscbuf_size
=
785 AUDIO_RISC_DMA_BUF_SIZE
* NUM_AUDIO_PROGS
+
786 RISC_SYNC_INSTRUCTION_SIZE
;
787 dev
->audio_upstream_databuf_size
= AUDIO_DATA_BUF_SZ
* NUM_AUDIO_PROGS
;
789 /* Allocating buffers and prepare RISC program */
791 cx25821_audio_upstream_buffer_prepare(dev
, sram_ch
, _line_size
);
794 "%s: Failed to set up Audio upstream buffers!\n",
798 /* Start RISC engine */
799 cx25821_start_audio_dma_upstream(dev
, sram_ch
);
804 cx25821_dev_unregister(dev
);