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-video-upstream-ch2.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/slab.h>
35 #include <asm/uaccess.h>
37 MODULE_DESCRIPTION("v4l2 driver module for cx25821 based TV cards");
38 MODULE_AUTHOR("Hiep Huynh <hiep.huynh@conexant.com>");
39 MODULE_LICENSE("GPL");
41 static int _intr_msk
=
42 FLD_VID_SRC_RISC1
| FLD_VID_SRC_UF
| FLD_VID_SRC_SYNC
| FLD_VID_SRC_OPC_ERR
;
44 static __le32
*cx25821_update_riscprogram_ch2(struct cx25821_dev
*dev
,
45 __le32
* rp
, unsigned int offset
,
46 unsigned int bpl
, u32 sync_line
,
48 int fifo_enable
, int field_type
)
51 int dist_betwn_starts
= bpl
* 2;
53 *(rp
++) = cpu_to_le32(RISC_RESYNC
| sync_line
);
55 if (USE_RISC_NOOP_VIDEO
) {
56 for (i
= 0; i
< NUM_NO_OPS
; i
++) {
57 *(rp
++) = cpu_to_le32(RISC_NOOP
);
62 for (line
= 0; line
< lines
; line
++) {
63 *(rp
++) = cpu_to_le32(RISC_READ
| RISC_SOL
| RISC_EOL
| bpl
);
64 *(rp
++) = cpu_to_le32(dev
->_data_buf_phys_addr_ch2
+ offset
);
65 *(rp
++) = cpu_to_le32(0); /* bits 63-32 */
67 if ((lines
<= NTSC_FIELD_HEIGHT
)
68 || (line
< (NTSC_FIELD_HEIGHT
- 1))
69 || !(dev
->_isNTSC_ch2
)) {
70 offset
+= dist_betwn_starts
;
77 static __le32
*cx25821_risc_field_upstream_ch2(struct cx25821_dev
*dev
,
79 dma_addr_t databuf_phys_addr
,
81 u32 sync_line
, unsigned int bpl
,
83 int fifo_enable
, int field_type
)
86 struct sram_channel
*sram_ch
=
87 dev
->channels
[dev
->_channel2_upstream_select
].sram_channels
;
88 int dist_betwn_starts
= bpl
* 2;
90 /* sync instruction */
91 if (sync_line
!= NO_SYNC_LINE
) {
92 *(rp
++) = cpu_to_le32(RISC_RESYNC
| sync_line
);
95 if (USE_RISC_NOOP_VIDEO
) {
96 for (i
= 0; i
< NUM_NO_OPS
; i
++) {
97 *(rp
++) = cpu_to_le32(RISC_NOOP
);
102 for (line
= 0; line
< lines
; line
++) {
103 *(rp
++) = cpu_to_le32(RISC_READ
| RISC_SOL
| RISC_EOL
| bpl
);
104 *(rp
++) = cpu_to_le32(databuf_phys_addr
+ offset
);
105 *(rp
++) = cpu_to_le32(0); /* bits 63-32 */
107 if ((lines
<= NTSC_FIELD_HEIGHT
)
108 || (line
< (NTSC_FIELD_HEIGHT
- 1))
109 || !(dev
->_isNTSC_ch2
)) {
110 offset
+= dist_betwn_starts
;
114 check if we need to enable the FIFO after the first 4 lines
115 For the upstream video channel, the risc engine will enable
118 if (fifo_enable
&& line
== 3) {
119 *(rp
++) = RISC_WRITECR
;
120 *(rp
++) = sram_ch
->dma_ctl
;
121 *(rp
++) = FLD_VID_FIFO_EN
;
122 *(rp
++) = 0x00000001;
129 int cx25821_risc_buffer_upstream_ch2(struct cx25821_dev
*dev
,
131 unsigned int top_offset
, unsigned int bpl
,
136 int singlefield_lines
= lines
>> 1; /*get line count for single field */
137 int odd_num_lines
= singlefield_lines
;
140 int databuf_offset
= 0;
141 int risc_program_size
= 0;
142 int risc_flag
= RISC_CNT_RESET
;
143 unsigned int bottom_offset
= bpl
;
144 dma_addr_t risc_phys_jump_addr
;
146 if (dev
->_isNTSC_ch2
) {
147 odd_num_lines
= singlefield_lines
+ 1;
148 risc_program_size
= FRAME1_VID_PROG_SIZE
;
151 Y411_LINE_SZ
) ? FRAME_SIZE_NTSC_Y411
:
152 FRAME_SIZE_NTSC_Y422
;
154 risc_program_size
= PAL_VID_PROG_SIZE
;
157 Y411_LINE_SZ
) ? FRAME_SIZE_PAL_Y411
: FRAME_SIZE_PAL_Y422
;
160 /* Virtual address of Risc buffer program */
161 rp
= dev
->_dma_virt_addr_ch2
;
163 for (frame
= 0; frame
< NUM_FRAMES
; frame
++) {
164 databuf_offset
= frame_size
* frame
;
166 if (UNSET
!= top_offset
) {
167 fifo_enable
= (frame
== 0) ? FIFO_ENABLE
: FIFO_DISABLE
;
168 rp
= cx25821_risc_field_upstream_ch2(dev
, rp
,
170 _data_buf_phys_addr_ch2
178 fifo_enable
= FIFO_DISABLE
;
181 rp
= cx25821_risc_field_upstream_ch2(dev
, rp
,
183 _data_buf_phys_addr_ch2
+
185 bottom_offset
, 0x200, bpl
,
187 fifo_enable
, EVEN_FIELD
);
190 risc_flag
= RISC_CNT_RESET
;
191 risc_phys_jump_addr
=
192 dev
->_dma_phys_start_addr_ch2
+ risc_program_size
;
194 risc_flag
= RISC_CNT_INC
;
195 risc_phys_jump_addr
= dev
->_dma_phys_start_addr_ch2
;
199 Loop to 2ndFrameRISC or to Start of
200 Risc program & generate IRQ
202 *(rp
++) = cpu_to_le32(RISC_JUMP
| RISC_IRQ1
| risc_flag
);
203 *(rp
++) = cpu_to_le32(risc_phys_jump_addr
);
204 *(rp
++) = cpu_to_le32(0);
210 void cx25821_stop_upstream_video_ch2(struct cx25821_dev
*dev
)
212 struct sram_channel
*sram_ch
=
213 dev
->channels
[VID_UPSTREAM_SRAM_CHANNEL_J
].sram_channels
;
216 if (!dev
->_is_running_ch2
) {
218 ("cx25821: No video file is currently running so return!\n");
221 /* Disable RISC interrupts */
222 tmp
= cx_read(sram_ch
->int_msk
);
223 cx_write(sram_ch
->int_msk
, tmp
& ~_intr_msk
);
225 /* Turn OFF risc and fifo */
226 tmp
= cx_read(sram_ch
->dma_ctl
);
227 cx_write(sram_ch
->dma_ctl
, tmp
& ~(FLD_VID_FIFO_EN
| FLD_VID_RISC_EN
));
229 /* Clear data buffer memory */
230 if (dev
->_data_buf_virt_addr_ch2
)
231 memset(dev
->_data_buf_virt_addr_ch2
, 0,
232 dev
->_data_buf_size_ch2
);
234 dev
->_is_running_ch2
= 0;
235 dev
->_is_first_frame_ch2
= 0;
236 dev
->_frame_count_ch2
= 0;
237 dev
->_file_status_ch2
= END_OF_FILE
;
239 if (dev
->_irq_queues_ch2
) {
240 kfree(dev
->_irq_queues_ch2
);
241 dev
->_irq_queues_ch2
= NULL
;
244 if (dev
->_filename_ch2
!= NULL
)
245 kfree(dev
->_filename_ch2
);
247 tmp
= cx_read(VID_CH_MODE_SEL
);
248 cx_write(VID_CH_MODE_SEL
, tmp
& 0xFFFFFE00);
251 void cx25821_free_mem_upstream_ch2(struct cx25821_dev
*dev
)
253 if (dev
->_is_running_ch2
) {
254 cx25821_stop_upstream_video_ch2(dev
);
257 if (dev
->_dma_virt_addr_ch2
) {
258 pci_free_consistent(dev
->pci
, dev
->_risc_size_ch2
,
259 dev
->_dma_virt_addr_ch2
,
260 dev
->_dma_phys_addr_ch2
);
261 dev
->_dma_virt_addr_ch2
= NULL
;
264 if (dev
->_data_buf_virt_addr_ch2
) {
265 pci_free_consistent(dev
->pci
, dev
->_data_buf_size_ch2
,
266 dev
->_data_buf_virt_addr_ch2
,
267 dev
->_data_buf_phys_addr_ch2
);
268 dev
->_data_buf_virt_addr_ch2
= NULL
;
272 int cx25821_get_frame_ch2(struct cx25821_dev
*dev
, struct sram_channel
*sram_ch
)
275 int frame_index_temp
= dev
->_frame_index_ch2
;
278 (dev
->_pixel_format_ch2
==
279 PIXEL_FRMT_411
) ? Y411_LINE_SZ
: Y422_LINE_SZ
;
281 int frame_offset
= 0;
282 ssize_t vfs_read_retval
= 0;
283 char mybuf
[line_size
];
288 if (dev
->_file_status_ch2
== END_OF_FILE
)
291 if (dev
->_isNTSC_ch2
) {
294 Y411_LINE_SZ
) ? FRAME_SIZE_NTSC_Y411
:
295 FRAME_SIZE_NTSC_Y422
;
299 Y411_LINE_SZ
) ? FRAME_SIZE_PAL_Y411
: FRAME_SIZE_PAL_Y422
;
302 frame_offset
= (frame_index_temp
> 0) ? frame_size
: 0;
303 file_offset
= dev
->_frame_count_ch2
* frame_size
;
305 myfile
= filp_open(dev
->_filename_ch2
, O_RDONLY
| O_LARGEFILE
, 0);
307 if (IS_ERR(myfile
)) {
308 const int open_errno
= -PTR_ERR(myfile
);
309 printk("%s(): ERROR opening file(%s) with errno = %d! \n",
310 __func__
, dev
->_filename_ch2
, open_errno
);
311 return PTR_ERR(myfile
);
313 if (!(myfile
->f_op
)) {
314 printk("%s: File has no file operations registered!",
316 filp_close(myfile
, NULL
);
320 if (!myfile
->f_op
->read
) {
321 printk("%s: File has no READ operations registered!",
323 filp_close(myfile
, NULL
);
331 for (i
= 0; i
< dev
->_lines_count_ch2
; i
++) {
335 vfs_read(myfile
, mybuf
, line_size
, &pos
);
337 if (vfs_read_retval
> 0 && vfs_read_retval
== line_size
338 && dev
->_data_buf_virt_addr_ch2
!= NULL
) {
339 memcpy((void *)(dev
->_data_buf_virt_addr_ch2
+
340 frame_offset
/ 4), mybuf
,
344 file_offset
+= vfs_read_retval
;
345 frame_offset
+= vfs_read_retval
;
347 if (vfs_read_retval
< line_size
) {
349 "Done: exit %s() since no more bytes to read from Video file.\n",
356 dev
->_frame_count_ch2
++;
358 dev
->_file_status_ch2
=
359 (vfs_read_retval
== line_size
) ? IN_PROGRESS
: END_OF_FILE
;
362 filp_close(myfile
, NULL
);
368 static void cx25821_vidups_handler_ch2(struct work_struct
*work
)
370 struct cx25821_dev
*dev
=
371 container_of(work
, struct cx25821_dev
, _irq_work_entry_ch2
);
374 printk("ERROR %s(): since container_of(work_struct) FAILED! \n",
379 cx25821_get_frame_ch2(dev
,
381 _channel2_upstream_select
].sram_channels
);
384 int cx25821_openfile_ch2(struct cx25821_dev
*dev
, struct sram_channel
*sram_ch
)
389 (dev
->_pixel_format_ch2
==
390 PIXEL_FRMT_411
) ? Y411_LINE_SZ
: Y422_LINE_SZ
;
391 ssize_t vfs_read_retval
= 0;
392 char mybuf
[line_size
];
394 loff_t offset
= (unsigned long)0;
397 myfile
= filp_open(dev
->_filename_ch2
, O_RDONLY
| O_LARGEFILE
, 0);
399 if (IS_ERR(myfile
)) {
400 const int open_errno
= -PTR_ERR(myfile
);
401 printk("%s(): ERROR opening file(%s) with errno = %d! \n",
402 __func__
, dev
->_filename_ch2
, open_errno
);
403 return PTR_ERR(myfile
);
405 if (!(myfile
->f_op
)) {
406 printk("%s: File has no file operations registered!",
408 filp_close(myfile
, NULL
);
412 if (!myfile
->f_op
->read
) {
414 ("%s: File has no READ operations registered! Returning.",
416 filp_close(myfile
, NULL
);
424 for (j
= 0; j
< NUM_FRAMES
; j
++) {
425 for (i
= 0; i
< dev
->_lines_count_ch2
; i
++) {
429 vfs_read(myfile
, mybuf
, line_size
, &pos
);
431 if (vfs_read_retval
> 0
432 && vfs_read_retval
== line_size
433 && dev
->_data_buf_virt_addr_ch2
!= NULL
) {
434 memcpy((void *)(dev
->
435 _data_buf_virt_addr_ch2
436 + offset
/ 4), mybuf
,
440 offset
+= vfs_read_retval
;
442 if (vfs_read_retval
< line_size
) {
444 "Done: exit %s() since no more bytes to read from Video file.\n",
451 dev
->_frame_count_ch2
++;
453 if (vfs_read_retval
< line_size
) {
458 dev
->_file_status_ch2
=
459 (vfs_read_retval
== line_size
) ? IN_PROGRESS
: END_OF_FILE
;
463 filp_close(myfile
, NULL
);
469 static int cx25821_upstream_buffer_prepare_ch2(struct cx25821_dev
*dev
,
470 struct sram_channel
*sram_ch
,
475 dma_addr_t data_dma_addr
;
477 if (dev
->_dma_virt_addr_ch2
!= NULL
) {
478 pci_free_consistent(dev
->pci
, dev
->upstream_riscbuf_size_ch2
,
479 dev
->_dma_virt_addr_ch2
,
480 dev
->_dma_phys_addr_ch2
);
483 dev
->_dma_virt_addr_ch2
=
484 pci_alloc_consistent(dev
->pci
, dev
->upstream_riscbuf_size_ch2
,
486 dev
->_dma_virt_start_addr_ch2
= dev
->_dma_virt_addr_ch2
;
487 dev
->_dma_phys_start_addr_ch2
= dma_addr
;
488 dev
->_dma_phys_addr_ch2
= dma_addr
;
489 dev
->_risc_size_ch2
= dev
->upstream_riscbuf_size_ch2
;
491 if (!dev
->_dma_virt_addr_ch2
) {
493 ("cx25821: FAILED to allocate memory for Risc buffer! Returning.\n");
497 /* Iniitize at this address until n bytes to 0 */
498 memset(dev
->_dma_virt_addr_ch2
, 0, dev
->_risc_size_ch2
);
500 if (dev
->_data_buf_virt_addr_ch2
!= NULL
) {
501 pci_free_consistent(dev
->pci
, dev
->upstream_databuf_size_ch2
,
502 dev
->_data_buf_virt_addr_ch2
,
503 dev
->_data_buf_phys_addr_ch2
);
505 /* For Video Data buffer allocation */
506 dev
->_data_buf_virt_addr_ch2
=
507 pci_alloc_consistent(dev
->pci
, dev
->upstream_databuf_size_ch2
,
509 dev
->_data_buf_phys_addr_ch2
= data_dma_addr
;
510 dev
->_data_buf_size_ch2
= dev
->upstream_databuf_size_ch2
;
512 if (!dev
->_data_buf_virt_addr_ch2
) {
514 ("cx25821: FAILED to allocate memory for data buffer! Returning.\n");
518 /* Initialize at this address until n bytes to 0 */
519 memset(dev
->_data_buf_virt_addr_ch2
, 0, dev
->_data_buf_size_ch2
);
521 ret
= cx25821_openfile_ch2(dev
, sram_ch
);
525 /* Creating RISC programs */
527 cx25821_risc_buffer_upstream_ch2(dev
, dev
->pci
, 0, bpl
,
528 dev
->_lines_count_ch2
);
531 "cx25821: Failed creating Video Upstream Risc programs! \n");
541 int cx25821_video_upstream_irq_ch2(struct cx25821_dev
*dev
, int chan_num
,
545 struct sram_channel
*channel
= dev
->channels
[chan_num
].sram_channels
;
546 int singlefield_lines
= NTSC_FIELD_HEIGHT
;
547 int line_size_in_bytes
= Y422_LINE_SZ
;
548 int odd_risc_prog_size
= 0;
549 dma_addr_t risc_phys_jump_addr
;
552 if (status
& FLD_VID_SRC_RISC1
) {
553 /* We should only process one program per call */
554 u32 prog_cnt
= cx_read(channel
->gpcnt
);
557 Since we've identified our IRQ, clear our bits from the
558 interrupt mask and interrupt status registers
560 int_msk_tmp
= cx_read(channel
->int_msk
);
561 cx_write(channel
->int_msk
, int_msk_tmp
& ~_intr_msk
);
562 cx_write(channel
->int_stat
, _intr_msk
);
564 spin_lock(&dev
->slock
);
566 dev
->_frame_index_ch2
= prog_cnt
;
568 queue_work(dev
->_irq_queues_ch2
, &dev
->_irq_work_entry_ch2
);
570 if (dev
->_is_first_frame_ch2
) {
571 dev
->_is_first_frame_ch2
= 0;
573 if (dev
->_isNTSC_ch2
) {
574 singlefield_lines
+= 1;
575 odd_risc_prog_size
= ODD_FLD_NTSC_PROG_SIZE
;
577 singlefield_lines
= PAL_FIELD_HEIGHT
;
578 odd_risc_prog_size
= ODD_FLD_PAL_PROG_SIZE
;
581 if (dev
->_dma_virt_start_addr_ch2
!= NULL
) {
583 (dev
->_pixel_format_ch2
==
584 PIXEL_FRMT_411
) ? Y411_LINE_SZ
:
586 risc_phys_jump_addr
=
587 dev
->_dma_phys_start_addr_ch2
+
590 rp
= cx25821_update_riscprogram_ch2(dev
,
592 _dma_virt_start_addr_ch2
,
600 /* Jump to Even Risc program of 1st Frame */
601 *(rp
++) = cpu_to_le32(RISC_JUMP
);
602 *(rp
++) = cpu_to_le32(risc_phys_jump_addr
);
603 *(rp
++) = cpu_to_le32(0);
607 spin_unlock(&dev
->slock
);
610 if (dev
->_file_status_ch2
== END_OF_FILE
) {
611 printk("cx25821: EOF Channel 2 Framecount = %d\n",
612 dev
->_frame_count_ch2
);
615 /* ElSE, set the interrupt mask register, re-enable irq. */
616 int_msk_tmp
= cx_read(channel
->int_msk
);
617 cx_write(channel
->int_msk
, int_msk_tmp
|= _intr_msk
);
622 static irqreturn_t
cx25821_upstream_irq_ch2(int irq
, void *dev_id
)
624 struct cx25821_dev
*dev
= dev_id
;
625 u32 msk_stat
, vid_status
;
628 struct sram_channel
*sram_ch
;
633 channel_num
= VID_UPSTREAM_SRAM_CHANNEL_J
;
635 sram_ch
= dev
->channels
[channel_num
].sram_channels
;
637 msk_stat
= cx_read(sram_ch
->int_mstat
);
638 vid_status
= cx_read(sram_ch
->int_stat
);
640 /* Only deal with our interrupt */
643 cx25821_video_upstream_irq_ch2(dev
, channel_num
,
648 cx25821_stop_upstream_video_ch2(dev
);
653 return IRQ_RETVAL(handled
);
656 static void cx25821_set_pixelengine_ch2(struct cx25821_dev
*dev
,
657 struct sram_channel
*ch
, int pix_format
)
659 int width
= WIDTH_D1
;
660 int height
= dev
->_lines_count_ch2
;
661 int num_lines
, odd_num_lines
;
663 int vip_mode
= PIXEL_ENGINE_VIP1
;
665 value
= ((pix_format
& 0x3) << 12) | (vip_mode
& 0x7);
667 value
|= dev
->_isNTSC_ch2
? 0 : 0x10;
668 cx_write(ch
->vid_fmt_ctl
, value
);
671 set number of active pixels in each line. Default is 720
672 pixels in both NTSC and PAL format
674 cx_write(ch
->vid_active_ctl1
, width
);
676 num_lines
= (height
/ 2) & 0x3FF;
677 odd_num_lines
= num_lines
;
679 if (dev
->_isNTSC_ch2
) {
683 value
= (num_lines
<< 16) | odd_num_lines
;
685 /* set number of active lines in field 0 (top) and field 1 (bottom) */
686 cx_write(ch
->vid_active_ctl2
, value
);
688 cx_write(ch
->vid_cdt_size
, VID_CDT_SIZE
>> 3);
691 int cx25821_start_video_dma_upstream_ch2(struct cx25821_dev
*dev
,
692 struct sram_channel
*sram_ch
)
698 656/VIP SRC Upstream Channel I & J and 7 - Host Bus Interface
701 tmp
= cx_read(VID_CH_MODE_SEL
);
702 cx_write(VID_CH_MODE_SEL
, tmp
| 0x1B0001FF);
705 Set the physical start address of the RISC program in the initial
706 program counter(IPC) member of the cmds.
708 cx_write(sram_ch
->cmds_start
+ 0, dev
->_dma_phys_addr_ch2
);
709 cx_write(sram_ch
->cmds_start
+ 4, 0); /* Risc IPC High 64 bits 63-32 */
712 cx_write(sram_ch
->gpcnt_ctl
, 3);
714 /* Clear our bits from the interrupt status register. */
715 cx_write(sram_ch
->int_stat
, _intr_msk
);
717 /* Set the interrupt mask register, enable irq. */
718 cx_set(PCI_INT_MSK
, cx_read(PCI_INT_MSK
) | (1 << sram_ch
->irq_bit
));
719 tmp
= cx_read(sram_ch
->int_msk
);
720 cx_write(sram_ch
->int_msk
, tmp
|= _intr_msk
);
723 request_irq(dev
->pci
->irq
, cx25821_upstream_irq_ch2
,
724 IRQF_SHARED
| IRQF_DISABLED
, dev
->name
, dev
);
726 printk(KERN_ERR
"%s: can't get upstream IRQ %d\n", dev
->name
,
730 /* Start the DMA engine */
731 tmp
= cx_read(sram_ch
->dma_ctl
);
732 cx_set(sram_ch
->dma_ctl
, tmp
| FLD_VID_RISC_EN
);
734 dev
->_is_running_ch2
= 1;
735 dev
->_is_first_frame_ch2
= 1;
740 cx25821_dev_unregister(dev
);
744 int cx25821_vidupstream_init_ch2(struct cx25821_dev
*dev
, int channel_select
,
747 struct sram_channel
*sram_ch
;
751 int data_frame_size
= 0;
752 int risc_buffer_size
= 0;
755 if (dev
->_is_running_ch2
) {
756 printk("Video Channel is still running so return!\n");
760 dev
->_channel2_upstream_select
= channel_select
;
761 sram_ch
= dev
->channels
[channel_select
].sram_channels
;
763 INIT_WORK(&dev
->_irq_work_entry_ch2
, cx25821_vidups_handler_ch2
);
764 dev
->_irq_queues_ch2
=
765 create_singlethread_workqueue("cx25821_workqueue2");
767 if (!dev
->_irq_queues_ch2
) {
769 ("cx25821: create_singlethread_workqueue() for Video FAILED!\n");
773 656/VIP SRC Upstream Channel I & J and 7 -
774 Host Bus Interface for channel A-C
776 tmp
= cx_read(VID_CH_MODE_SEL
);
777 cx_write(VID_CH_MODE_SEL
, tmp
| 0x1B0001FF);
779 dev
->_is_running_ch2
= 0;
780 dev
->_frame_count_ch2
= 0;
781 dev
->_file_status_ch2
= RESET_STATUS
;
782 dev
->_lines_count_ch2
= dev
->_isNTSC_ch2
? 480 : 576;
783 dev
->_pixel_format_ch2
= pixel_format
;
784 dev
->_line_size_ch2
=
785 (dev
->_pixel_format_ch2
==
786 PIXEL_FRMT_422
) ? (WIDTH_D1
* 2) : (WIDTH_D1
* 3) / 2;
787 data_frame_size
= dev
->_isNTSC_ch2
? NTSC_DATA_BUF_SZ
: PAL_DATA_BUF_SZ
;
789 dev
->_isNTSC_ch2
? NTSC_RISC_BUF_SIZE
: PAL_RISC_BUF_SIZE
;
791 if (dev
->input_filename_ch2
) {
792 str_length
= strlen(dev
->input_filename_ch2
);
793 dev
->_filename_ch2
= kmalloc(str_length
+ 1, GFP_KERNEL
);
795 if (!dev
->_filename_ch2
)
798 memcpy(dev
->_filename_ch2
, dev
->input_filename_ch2
,
801 str_length
= strlen(dev
->_defaultname_ch2
);
802 dev
->_filename_ch2
= kmalloc(str_length
+ 1, GFP_KERNEL
);
804 if (!dev
->_filename_ch2
)
807 memcpy(dev
->_filename_ch2
, dev
->_defaultname_ch2
,
811 /* Default if filename is empty string */
812 if (strcmp(dev
->input_filename_ch2
, "") == 0) {
813 if (dev
->_isNTSC_ch2
) {
815 (dev
->_pixel_format_ch2
==
816 PIXEL_FRMT_411
) ? "/root/vid411.yuv" :
820 (dev
->_pixel_format_ch2
==
821 PIXEL_FRMT_411
) ? "/root/pal411.yuv" :
827 cx25821_sram_channel_setup_upstream(dev
, sram_ch
,
828 dev
->_line_size_ch2
, 0);
830 /* setup fifo + format */
831 cx25821_set_pixelengine_ch2(dev
, sram_ch
, dev
->_pixel_format_ch2
);
833 dev
->upstream_riscbuf_size_ch2
= risc_buffer_size
* 2;
834 dev
->upstream_databuf_size_ch2
= data_frame_size
* 2;
836 /* Allocating buffers and prepare RISC program */
838 cx25821_upstream_buffer_prepare_ch2(dev
, sram_ch
,
839 dev
->_line_size_ch2
);
842 "%s: Failed to set up Video upstream buffers!\n",
847 cx25821_start_video_dma_upstream_ch2(dev
, sram_ch
);
852 cx25821_dev_unregister(dev
);