mirrors/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2024-08-21 08:19:28 +00:00
Code Issues Releases Wiki Activity

V4L/DVB (12732): cx25821: fix bad whitespacing

Browse source 
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
This commit is contained in:
Mauro Carvalho Chehab 2009-09-13 11:25:45 -03:00
parent 466a1c15b5
commit bb4c9a74b8
29 changed files with 3806 additions and 3807 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
drivers/staging/cx25821/Kconfig
View file

@ -15,7 +15,7 @@ config VIDEO_CX25821
To compile this driver as a module, choose M here: the To compile this driver as a module, choose M here: the
module will be called cx25821 module will be called cx25821
config VIDEO_CX25821_ALSA config VIDEO_CX25821_ALSA
tristate "Conexant 25821 DMA audio support" tristate "Conexant 25821 DMA audio support"
depends on VIDEO_CX25821 && SND && EXPERIMENTAL depends on VIDEO_CX25821 && SND && EXPERIMENTAL
@ -30,5 +30,5 @@ config VIDEO_CX25821_ALSA
PCI device. PCI device.
To compile this driver as a module, choose M here: the To compile this driver as a module, choose M here: the
module will be called cx25821-alsa. module will be called cx25821-alsa.

2
drivers/staging/cx25821/cx25821-alsa.c
View file

@ -72,7 +72,7 @@ struct cx25821_audio_dev {
unsigned long iobase; unsigned long iobase;
spinlock_t reg_lock; spinlock_t reg_lock;
atomic_t count; atomic_t count;
unsigned int dma_size; unsigned int dma_size;
unsigned int period_size; unsigned int period_size;

581
drivers/staging/cx25821/cx25821-audio-upstream.c
View file

@ -45,8 +45,8 @@ static int _intr_msk = FLD_AUD_SRC_RISCI1 | FLD_AUD_SRC_OF | FLD_AUD_SRC_SYNC |
int cx25821_sram_channel_setup_upstream_audio(struct cx25821_dev *dev, int cx25821_sram_channel_setup_upstream_audio(struct cx25821_dev *dev,
struct sram_channel *ch, struct sram_channel *ch,
unsigned int bpl, u32 risc) unsigned int bpl, u32 risc)
{ {
unsigned int i, lines; unsigned int i, lines;
u32 cdt; u32 cdt;
@ -66,7 +66,7 @@ int cx25821_sram_channel_setup_upstream_audio(struct cx25821_dev *dev,
if (lines > 3) if (lines > 3)
{ {
lines = 3; lines = 3;
} }
BUG_ON(lines < 2); BUG_ON(lines < 2);
@ -87,7 +87,7 @@ int cx25821_sram_channel_setup_upstream_audio(struct cx25821_dev *dev,
cx_write(ch->cmds_start + 8, cdt); cx_write(ch->cmds_start + 8, cdt);
cx_write(ch->cmds_start + 12, AUDIO_CDT_SIZE_QW); cx_write(ch->cmds_start + 12, AUDIO_CDT_SIZE_QW);
cx_write(ch->cmds_start + 16, ch->ctrl_start); cx_write(ch->cmds_start + 16, ch->ctrl_start);
//IQ size //IQ size
cx_write(ch->cmds_start + 20, AUDIO_IQ_SIZE_DW); cx_write(ch->cmds_start + 20, AUDIO_IQ_SIZE_DW);
@ -105,40 +105,40 @@ int cx25821_sram_channel_setup_upstream_audio(struct cx25821_dev *dev,
static __le32 *cx25821_risc_field_upstream_audio( struct cx25821_dev *dev, __le32 *rp, static __le32 *cx25821_risc_field_upstream_audio( struct cx25821_dev *dev, __le32 *rp,
dma_addr_t databuf_phys_addr, dma_addr_t databuf_phys_addr,
unsigned int bpl, int fifo_enable) unsigned int bpl, int fifo_enable)
{ {
unsigned int line; unsigned int line;
struct sram_channel *sram_ch = &dev->sram_channels[dev->_audio_upstream_channel_select]; struct sram_channel *sram_ch = &dev->sram_channels[dev->_audio_upstream_channel_select];
int offset = 0; int offset = 0;
/* scan lines */ /* scan lines */
for (line = 0; line < LINES_PER_AUDIO_BUFFER; line++) for (line = 0; line < LINES_PER_AUDIO_BUFFER; line++)
{ {
*(rp++) = cpu_to_le32(RISC_READ|RISC_SOL|RISC_EOL|bpl); *(rp++) = cpu_to_le32(RISC_READ|RISC_SOL|RISC_EOL|bpl);
*(rp++) = cpu_to_le32(databuf_phys_addr + offset); *(rp++) = cpu_to_le32(databuf_phys_addr + offset);
*(rp++) = cpu_to_le32(0); /* bits 63-32 */ *(rp++) = cpu_to_le32(0); /* bits 63-32 */
// Check if we need to enable the FIFO after the first 3 lines // Check if we need to enable the FIFO after the first 3 lines
// For the upstream audio channel, the risc engine will enable the FIFO. // For the upstream audio channel, the risc engine will enable the FIFO.
if ( fifo_enable && line == 2 ) if ( fifo_enable && line == 2 )
{ {
*(rp++) = RISC_WRITECR; *(rp++) = RISC_WRITECR;
*(rp++) = sram_ch->dma_ctl; *(rp++) = sram_ch->dma_ctl;
*(rp++) = sram_ch->fld_aud_fifo_en; *(rp++) = sram_ch->fld_aud_fifo_en;
*(rp++) = 0x00000020; *(rp++) = 0x00000020;
} }
offset += AUDIO_LINE_SIZE; offset += AUDIO_LINE_SIZE;
} }
return rp; return rp;
} }
int cx25821_risc_buffer_upstream_audio( struct cx25821_dev *dev, int cx25821_risc_buffer_upstream_audio( struct cx25821_dev *dev,
struct pci_dev *pci, struct pci_dev *pci,
unsigned int bpl, unsigned int lines) unsigned int bpl, unsigned int lines)
{ {
__le32 *rp; __le32 *rp;
int fifo_enable = 0; int fifo_enable = 0;
@ -148,7 +148,7 @@ int cx25821_risc_buffer_upstream_audio( struct cx25821_dev *dev,
int risc_flag = RISC_CNT_INC; int risc_flag = RISC_CNT_INC;
dma_addr_t risc_phys_jump_addr; dma_addr_t risc_phys_jump_addr;
/* Virtual address of Risc buffer program */ /* Virtual address of Risc buffer program */
rp = dev->_risc_virt_addr; rp = dev->_risc_virt_addr;
@ -158,48 +158,48 @@ int cx25821_risc_buffer_upstream_audio( struct cx25821_dev *dev,
for( frame = 0; frame < NUM_AUDIO_FRAMES; frame++ ) for( frame = 0; frame < NUM_AUDIO_FRAMES; frame++ )
{ {
databuf_offset = frame_size * frame; databuf_offset = frame_size * frame;
if( frame == 0 ) if( frame == 0 )
{ {
fifo_enable = 1; fifo_enable = 1;
risc_flag = RISC_CNT_RESET; risc_flag = RISC_CNT_RESET;
} }
else else
{ {
fifo_enable = 0; fifo_enable = 0;
risc_flag = RISC_CNT_INC; risc_flag = RISC_CNT_INC;
} }
//Calculate physical jump address //Calculate physical jump address
if( (frame+1) == NUM_AUDIO_FRAMES ) if( (frame+1) == NUM_AUDIO_FRAMES )
{ {
risc_phys_jump_addr = dev->_risc_phys_start_addr + RISC_SYNC_INSTRUCTION_SIZE; risc_phys_jump_addr = dev->_risc_phys_start_addr + RISC_SYNC_INSTRUCTION_SIZE;
} }
else else
{ {
risc_phys_jump_addr = dev->_risc_phys_start_addr + RISC_SYNC_INSTRUCTION_SIZE + AUDIO_RISC_DMA_BUF_SIZE*(frame+1); risc_phys_jump_addr = dev->_risc_phys_start_addr + RISC_SYNC_INSTRUCTION_SIZE + AUDIO_RISC_DMA_BUF_SIZE*(frame+1);
} }
rp = cx25821_risc_field_upstream_audio(dev, rp, dev->_audiodata_buf_phys_addr+databuf_offset, bpl, fifo_enable); rp = cx25821_risc_field_upstream_audio(dev, rp, dev->_audiodata_buf_phys_addr+databuf_offset, bpl, fifo_enable);
if( USE_RISC_NOOP_AUDIO ) if( USE_RISC_NOOP_AUDIO )
{ {
for( i = 0; i < NUM_NO_OPS; i++ ) for( i = 0; i < NUM_NO_OPS; i++ )
{ {
*(rp++) = cpu_to_le32(RISC_NOOP); *(rp++) = cpu_to_le32(RISC_NOOP);
} }
} }
// Loop to (Nth)FrameRISC or to Start of Risc program & generate IRQ // Loop to (Nth)FrameRISC or to Start of Risc program & generate IRQ
*(rp++) = cpu_to_le32(RISC_JUMP|RISC_IRQ1|risc_flag); *(rp++) = cpu_to_le32(RISC_JUMP|RISC_IRQ1|risc_flag);
*(rp++) = cpu_to_le32(risc_phys_jump_addr); *(rp++) = cpu_to_le32(risc_phys_jump_addr);
*(rp++) = cpu_to_le32(0); *(rp++) = cpu_to_le32(0);
//Recalculate virtual address based on frame index //Recalculate virtual address based on frame index
rp = dev->_risc_virt_addr + RISC_SYNC_INSTRUCTION_SIZE/4 + (AUDIO_RISC_DMA_BUF_SIZE*(frame+1)/4 ) ; rp = dev->_risc_virt_addr + RISC_SYNC_INSTRUCTION_SIZE/4 + (AUDIO_RISC_DMA_BUF_SIZE*(frame+1)/4 ) ;
} }
return 0; return 0;
@ -228,10 +228,10 @@ void cx25821_stop_upstream_audio(struct cx25821_dev *dev)
if( !dev->_audio_is_running ) if( !dev->_audio_is_running )
{ {
printk("cx25821: No audio file is currently running so return!\n"); printk("cx25821: No audio file is currently running so return!\n");
return; return;
} }
//Disable RISC interrupts //Disable RISC interrupts
cx_write( sram_ch->int_msk, 0 ); cx_write( sram_ch->int_msk, 0 );
@ -241,8 +241,8 @@ void cx25821_stop_upstream_audio(struct cx25821_dev *dev)
//Clear data buffer memory //Clear data buffer memory
if( dev->_audiodata_buf_virt_addr ) if( dev->_audiodata_buf_virt_addr )
memset( dev->_audiodata_buf_virt_addr, 0, dev->_audiodata_buf_size ); memset( dev->_audiodata_buf_virt_addr, 0, dev->_audiodata_buf_size );
dev->_audio_is_running = 0; dev->_audio_is_running = 0;
dev->_is_first_audio_frame = 0; dev->_is_first_audio_frame = 0;
dev->_audioframe_count = 0; dev->_audioframe_count = 0;
@ -250,12 +250,12 @@ void cx25821_stop_upstream_audio(struct cx25821_dev *dev)
if( dev->_irq_audio_queues ) if( dev->_irq_audio_queues )
{ {
kfree(dev->_irq_audio_queues); kfree(dev->_irq_audio_queues);
dev->_irq_audio_queues = NULL; dev->_irq_audio_queues = NULL;
} }
if( dev->_audiofilename != NULL ) if( dev->_audiofilename != NULL )
kfree(dev->_audiofilename); kfree(dev->_audiofilename);
} }
@ -263,7 +263,7 @@ void cx25821_free_mem_upstream_audio(struct cx25821_dev *dev)
{ {
if( dev->_audio_is_running ) if( dev->_audio_is_running )
{ {
cx25821_stop_upstream_audio(dev); cx25821_stop_upstream_audio(dev);
} }
cx25821_free_memory_audio(dev); cx25821_free_memory_audio(dev);
@ -286,69 +286,69 @@ int cx25821_get_audio_data(struct cx25821_dev *dev, struct sram_channel *sram_ch
if( dev->_audiofile_status == END_OF_FILE ) if( dev->_audiofile_status == END_OF_FILE )
return 0; return 0;
myfile = filp_open( dev->_audiofilename, O_RDONLY | O_LARGEFILE, 0 ); myfile = filp_open( dev->_audiofilename, O_RDONLY | O_LARGEFILE, 0 );
if (IS_ERR(myfile)) if (IS_ERR(myfile))
{ {
const int open_errno = -PTR_ERR(myfile); const int open_errno = -PTR_ERR(myfile);
printk("%s(): ERROR opening file(%s) with errno = %d! \n", __func__, dev->_audiofilename, open_errno); printk("%s(): ERROR opening file(%s) with errno = %d! \n", __func__, dev->_audiofilename, open_errno);
return PTR_ERR(myfile); return PTR_ERR(myfile);
} }
else else
{ {
if( !(myfile->f_op) ) if( !(myfile->f_op) )
{ {
printk("%s: File has no file operations registered!\n", __func__); printk("%s: File has no file operations registered!\n", __func__);
filp_close(myfile, NULL); filp_close(myfile, NULL);
return -EIO; return -EIO;
} }
if( !myfile->f_op->read ) if( !myfile->f_op->read )
{ {
printk("%s: File has no READ operations registered! \n", __func__); printk("%s: File has no READ operations registered! \n", __func__);
filp_close(myfile, NULL); filp_close(myfile, NULL);
return -EIO; return -EIO;
} }
pos = myfile->f_pos; pos = myfile->f_pos;
old_fs = get_fs(); old_fs = get_fs();
set_fs(KERNEL_DS); set_fs(KERNEL_DS);
for( i = 0; i < dev->_audio_lines_count; i++ ) for( i = 0; i < dev->_audio_lines_count; i++ )
{ {
pos = file_offset; pos = file_offset;
vfs_read_retval = vfs_read(myfile, mybuf, line_size, &pos); vfs_read_retval = vfs_read(myfile, mybuf, line_size, &pos);
if( vfs_read_retval > 0 && vfs_read_retval == line_size && dev->_audiodata_buf_virt_addr != NULL ) if( vfs_read_retval > 0 && vfs_read_retval == line_size && dev->_audiodata_buf_virt_addr != NULL )
{ {
memcpy( (void*)(dev->_audiodata_buf_virt_addr+frame_offset/4), mybuf, vfs_read_retval); memcpy( (void*)(dev->_audiodata_buf_virt_addr+frame_offset/4), mybuf, vfs_read_retval);
} }
file_offset += vfs_read_retval; file_offset += vfs_read_retval;
frame_offset += vfs_read_retval; frame_offset += vfs_read_retval;
if( vfs_read_retval < line_size ) if( vfs_read_retval < line_size )
{ {
printk(KERN_INFO "Done: exit %s() since no more bytes to read from Audio file.\n", __func__ ); printk(KERN_INFO "Done: exit %s() since no more bytes to read from Audio file.\n", __func__ );
break; break;
} }
} }
if( i > 0 ) if( i > 0 )
dev->_audioframe_count++; dev->_audioframe_count++;
dev->_audiofile_status = (vfs_read_retval == line_size) ? IN_PROGRESS : END_OF_FILE; dev->_audiofile_status = (vfs_read_retval == line_size) ? IN_PROGRESS : END_OF_FILE;
set_fs(old_fs); set_fs(old_fs);
filp_close(myfile, NULL); filp_close(myfile, NULL);
} }
return 0; return 0;
@ -360,8 +360,8 @@ static void cx25821_audioups_handler(struct work_struct *work)
if( !dev ) if( !dev )
{ {
printk("ERROR %s(): since container_of(work_struct) FAILED! \n", __func__ ); printk("ERROR %s(): since container_of(work_struct) FAILED! \n", __func__ );
return; return;
} }
cx25821_get_audio_data( dev, &dev->sram_channels[dev->_audio_upstream_channel_select] ); cx25821_get_audio_data( dev, &dev->sram_channels[dev->_audio_upstream_channel_select] );
@ -377,91 +377,91 @@ int cx25821_openfile_audio(struct cx25821_dev *dev, struct sram_channel *sram_ch
loff_t pos; loff_t pos;
loff_t offset = (unsigned long)0; loff_t offset = (unsigned long)0;
mm_segment_t old_fs; mm_segment_t old_fs;
myfile = filp_open( dev->_audiofilename, O_RDONLY | O_LARGEFILE, 0 ); myfile = filp_open( dev->_audiofilename, O_RDONLY | O_LARGEFILE, 0 );
if (IS_ERR(myfile)) if (IS_ERR(myfile))
{ {
const int open_errno = -PTR_ERR(myfile); const int open_errno = -PTR_ERR(myfile);
printk("%s(): ERROR opening file(%s) with errno = %d! \n", __func__, dev->_audiofilename, open_errno); printk("%s(): ERROR opening file(%s) with errno = %d! \n", __func__, dev->_audiofilename, open_errno);
return PTR_ERR(myfile); return PTR_ERR(myfile);
} }
else else
{ {
if( !(myfile->f_op) ) if( !(myfile->f_op) )
{ {
printk("%s: File has no file operations registered! \n", __func__); printk("%s: File has no file operations registered! \n", __func__);
filp_close(myfile, NULL); filp_close(myfile, NULL);
return -EIO; return -EIO;
} }
if( !myfile->f_op->read ) if( !myfile->f_op->read )
{ {
printk("%s: File has no READ operations registered! \n", __func__); printk("%s: File has no READ operations registered! \n", __func__);
filp_close(myfile, NULL); filp_close(myfile, NULL);
return -EIO; return -EIO;
} }
pos = myfile->f_pos; pos = myfile->f_pos;
old_fs = get_fs(); old_fs = get_fs();
set_fs(KERNEL_DS); set_fs(KERNEL_DS);
for( j = 0; j < NUM_AUDIO_FRAMES; j++ ) for( j = 0; j < NUM_AUDIO_FRAMES; j++ )
{ {
for( i = 0; i < dev->_audio_lines_count; i++ ) for( i = 0; i < dev->_audio_lines_count; i++ )
{ {
pos = offset; pos = offset;
vfs_read_retval = vfs_read(myfile, mybuf, line_size, &pos); vfs_read_retval = vfs_read(myfile, mybuf, line_size, &pos);
if( vfs_read_retval > 0 && vfs_read_retval == line_size && dev->_audiodata_buf_virt_addr != NULL ) if( vfs_read_retval > 0 && vfs_read_retval == line_size && dev->_audiodata_buf_virt_addr != NULL )
{ {
memcpy( (void*)(dev->_audiodata_buf_virt_addr+offset/4), mybuf, vfs_read_retval); memcpy( (void*)(dev->_audiodata_buf_virt_addr+offset/4), mybuf, vfs_read_retval);
} }
offset += vfs_read_retval; offset += vfs_read_retval;
if( vfs_read_retval < line_size ) if( vfs_read_retval < line_size )
{ {
printk(KERN_INFO "Done: exit %s() since no more bytes to read from Audio file.\n", __func__ ); printk(KERN_INFO "Done: exit %s() since no more bytes to read from Audio file.\n", __func__ );
break; break;
} }
} }
if( i > 0 ) if( i > 0 )
{ {
dev->_audioframe_count++; dev->_audioframe_count++;
} }
if( vfs_read_retval < line_size ) if( vfs_read_retval < line_size )
{ {
break; break;
} }
} }
dev->_audiofile_status = (vfs_read_retval == line_size) ? IN_PROGRESS : END_OF_FILE; dev->_audiofile_status = (vfs_read_retval == line_size) ? IN_PROGRESS : END_OF_FILE;
set_fs(old_fs); set_fs(old_fs);
myfile->f_pos = 0; myfile->f_pos = 0;
filp_close(myfile, NULL); filp_close(myfile, NULL);
} }
return 0; return 0;
} }
static int cx25821_audio_upstream_buffer_prepare(struct cx25821_dev *dev, static int cx25821_audio_upstream_buffer_prepare(struct cx25821_dev *dev,
struct sram_channel *sram_ch, struct sram_channel *sram_ch,
int bpl) int bpl)
{ {
int ret = 0; int ret = 0;
dma_addr_t dma_addr; dma_addr_t dma_addr;
dma_addr_t data_dma_addr; dma_addr_t data_dma_addr;
cx25821_free_memory_audio(dev); cx25821_free_memory_audio(dev);
@ -474,7 +474,7 @@ static int cx25821_audio_upstream_buffer_prepare(struct cx25821_dev *dev,
if (!dev->_risc_virt_addr) if (!dev->_risc_virt_addr)
{ {
printk("cx25821 ERROR: pci_alloc_consistent() FAILED to allocate memory for RISC program! Returning.\n"); printk("cx25821 ERROR: pci_alloc_consistent() FAILED to allocate memory for RISC program! Returning.\n");
return -ENOMEM; return -ENOMEM;
} }
@ -489,7 +489,7 @@ static int cx25821_audio_upstream_buffer_prepare(struct cx25821_dev *dev,
if (!dev->_audiodata_buf_virt_addr) if (!dev->_audiodata_buf_virt_addr)
{ {
printk("cx25821 ERROR: pci_alloc_consistent() FAILED to allocate memory for data buffer! Returning. \n"); printk("cx25821 ERROR: pci_alloc_consistent() FAILED to allocate memory for data buffer! Returning. \n");
return -ENOMEM; return -ENOMEM;
} }
@ -499,8 +499,8 @@ static int cx25821_audio_upstream_buffer_prepare(struct cx25821_dev *dev,
ret = cx25821_openfile_audio(dev, sram_ch); ret = cx25821_openfile_audio(dev, sram_ch);
if( ret < 0 ) if( ret < 0 )
return ret; return ret;
//Creating RISC programs //Creating RISC programs
ret = cx25821_risc_buffer_upstream_audio(dev, dev->pci, bpl, dev->_audio_lines_count ); ret = cx25821_risc_buffer_upstream_audio(dev, dev->pci, bpl, dev->_audio_lines_count );
@ -528,86 +528,86 @@ int cx25821_audio_upstream_irq(struct cx25821_dev *dev, int chan_num, u32 status
if (status & FLD_AUD_SRC_RISCI1) if (status & FLD_AUD_SRC_RISCI1)
{ {
//Get interrupt_index of the program that interrupted //Get interrupt_index of the program that interrupted
u32 prog_cnt = cx_read( channel->gpcnt ); u32 prog_cnt = cx_read( channel->gpcnt );
//Since we've identified our IRQ, clear our bits from the interrupt mask and interrupt status registers //Since we've identified our IRQ, clear our bits from the interrupt mask and interrupt status registers
cx_write(channel->int_msk, 0); cx_write(channel->int_msk, 0);
cx_write(channel->int_stat, cx_read(channel->int_stat) ); cx_write(channel->int_stat, cx_read(channel->int_stat) );
spin_lock(&dev->slock); spin_lock(&dev->slock);
while(prog_cnt != dev->_last_index_irq) while(prog_cnt != dev->_last_index_irq)
{ {
//Update _last_index_irq //Update _last_index_irq
if(dev->_last_index_irq < (NUMBER_OF_PROGRAMS-1)) if(dev->_last_index_irq < (NUMBER_OF_PROGRAMS-1))
{ {
dev->_last_index_irq++; dev->_last_index_irq++;
} }
else else
{ {
dev->_last_index_irq = 0; dev->_last_index_irq = 0;
} }
dev->_audioframe_index = dev->_last_index_irq; dev->_audioframe_index = dev->_last_index_irq;
queue_work(dev->_irq_audio_queues, &dev->_audio_work_entry); queue_work(dev->_irq_audio_queues, &dev->_audio_work_entry);
} }
if ( dev->_is_first_audio_frame ) if ( dev->_is_first_audio_frame )
{ {
dev->_is_first_audio_frame = 0; dev->_is_first_audio_frame = 0;
if( dev->_risc_virt_start_addr != NULL ) if( dev->_risc_virt_start_addr != NULL )
{ {
risc_phys_jump_addr = dev->_risc_phys_start_addr + RISC_SYNC_INSTRUCTION_SIZE + AUDIO_RISC_DMA_BUF_SIZE; risc_phys_jump_addr = dev->_risc_phys_start_addr + RISC_SYNC_INSTRUCTION_SIZE + AUDIO_RISC_DMA_BUF_SIZE;
rp = cx25821_risc_field_upstream_audio(dev, dev->_risc_virt_start_addr+1, dev->_audiodata_buf_phys_addr, AUDIO_LINE_SIZE, FIFO_DISABLE); rp = cx25821_risc_field_upstream_audio(dev, dev->_risc_virt_start_addr+1, dev->_audiodata_buf_phys_addr, AUDIO_LINE_SIZE, FIFO_DISABLE);
if( USE_RISC_NOOP_AUDIO ) if( USE_RISC_NOOP_AUDIO )
{ {
for( i = 0; i < NUM_NO_OPS; i++ ) for( i = 0; i < NUM_NO_OPS; i++ )
{ {
*(rp++) = cpu_to_le32(RISC_NOOP); *(rp++) = cpu_to_le32(RISC_NOOP);
} }
} }
// Jump to 2nd Audio Frame // Jump to 2nd Audio Frame
*(rp++) = cpu_to_le32(RISC_JUMP | RISC_IRQ1 | RISC_CNT_RESET); *(rp++) = cpu_to_le32(RISC_JUMP | RISC_IRQ1 | RISC_CNT_RESET);
*(rp++) = cpu_to_le32(risc_phys_jump_addr); *(rp++) = cpu_to_le32(risc_phys_jump_addr);
*(rp++) = cpu_to_le32(0); *(rp++) = cpu_to_le32(0);
} }
} }
spin_unlock(&dev->slock); spin_unlock(&dev->slock);
} }
else else
{ {
if(status & FLD_AUD_SRC_OF) if(status & FLD_AUD_SRC_OF)
printk("%s: Audio Received Overflow Error Interrupt!\n", __func__); printk("%s: Audio Received Overflow Error Interrupt!\n", __func__);
if(status & FLD_AUD_SRC_SYNC) if(status & FLD_AUD_SRC_SYNC)
printk("%s: Audio Received Sync Error Interrupt!\n", __func__); printk("%s: Audio Received Sync Error Interrupt!\n", __func__);
if(status & FLD_AUD_SRC_OPC_ERR) if(status & FLD_AUD_SRC_OPC_ERR)
printk("%s: Audio Received OpCode Error Interrupt!\n", __func__); printk("%s: Audio Received OpCode Error Interrupt!\n", __func__);
// Read and write back the interrupt status register to clear our bits // Read and write back the interrupt status register to clear our bits
cx_write(channel->int_stat, cx_read(channel->int_stat) ); cx_write(channel->int_stat, cx_read(channel->int_stat) );
} }
if( dev->_audiofile_status == END_OF_FILE ) if( dev->_audiofile_status == END_OF_FILE )
{ {
printk("cx25821: EOF Channel Audio Framecount = %d\n", dev->_audioframe_count ); printk("cx25821: EOF Channel Audio Framecount = %d\n", dev->_audioframe_count );
return -1; return -1;
} }
//ElSE, set the interrupt mask register, re-enable irq. //ElSE, set the interrupt mask register, re-enable irq.
int_msk_tmp = cx_read( channel->int_msk ); int_msk_tmp = cx_read( channel->int_msk );
cx_write( channel->int_msk, int_msk_tmp |= _intr_msk ); cx_write( channel->int_msk, int_msk_tmp |= _intr_msk );
return 0; return 0;
} }
@ -620,8 +620,8 @@ static irqreturn_t cx25821_upstream_irq_audio(int irq, void *dev_id)
if( !dev ) if( !dev )
return -1; return -1;
sram_ch = &dev->sram_channels[dev->_audio_upstream_channel_select]; sram_ch = &dev->sram_channels[dev->_audio_upstream_channel_select];
@ -631,17 +631,17 @@ static irqreturn_t cx25821_upstream_irq_audio(int irq, void *dev_id)
// Only deal with our interrupt // Only deal with our interrupt
if(audio_status) if(audio_status)
{ {
handled = cx25821_audio_upstream_irq(dev, dev->_audio_upstream_channel_select, audio_status); handled = cx25821_audio_upstream_irq(dev, dev->_audio_upstream_channel_select, audio_status);
} }
if( handled < 0 ) if( handled < 0 )
{ {
cx25821_stop_upstream_audio(dev); cx25821_stop_upstream_audio(dev);
} }
else else
{ {
handled += handled; handled += handled;
} }
return IRQ_RETVAL(handled); return IRQ_RETVAL(handled);
@ -655,24 +655,24 @@ static void cx25821_wait_fifo_enable(struct cx25821_dev *dev, struct sram_channe
do do
{ {
//Wait 10 microsecond before checking to see if the FIFO is turned ON. //Wait 10 microsecond before checking to see if the FIFO is turned ON.
udelay(10); udelay(10);
tmp = cx_read( sram_ch->dma_ctl ); tmp = cx_read( sram_ch->dma_ctl );
if(count++ > 1000) //10 millisecond timeout if(count++ > 1000) //10 millisecond timeout
{ {
printk("cx25821 ERROR: %s() fifo is NOT turned on. Timeout!\n", __func__); printk("cx25821 ERROR: %s() fifo is NOT turned on. Timeout!\n", __func__);
return; return;
} }
} while( !(tmp & sram_ch->fld_aud_fifo_en) ); } while( !(tmp & sram_ch->fld_aud_fifo_en) );
} }
int cx25821_start_audio_dma_upstream(struct cx25821_dev *dev, int cx25821_start_audio_dma_upstream(struct cx25821_dev *dev,
struct sram_channel *sram_ch) struct sram_channel *sram_ch)
{ {
u32 tmp = 0; u32 tmp = 0;
int err = 0; int err = 0;
@ -744,10 +744,10 @@ int cx25821_audio_upstream_init(struct cx25821_dev *dev, int channel_select)
if( dev->_audio_is_running ) if( dev->_audio_is_running )
{ {
printk("Audio Channel is still running so return!\n"); printk("Audio Channel is still running so return!\n");
return 0; return 0;
} }
dev->_audio_upstream_channel_select = channel_select; dev->_audio_upstream_channel_select = channel_select;
sram_ch = &dev->sram_channels[channel_select]; sram_ch = &dev->sram_channels[channel_select];
@ -757,10 +757,10 @@ int cx25821_audio_upstream_init(struct cx25821_dev *dev, int channel_select)
if(!dev->_irq_audio_queues) if(!dev->_irq_audio_queues)
{ {
printk("cx25821 ERROR: create_singlethread_workqueue() for Audio FAILED!\n"); printk("cx25821 ERROR: create_singlethread_workqueue() for Audio FAILED!\n");
return -ENOMEM; return -ENOMEM;
} }
dev->_last_index_irq = 0; dev->_last_index_irq = 0;
dev->_audio_is_running = 0; dev->_audio_is_running = 0;
@ -769,32 +769,32 @@ int cx25821_audio_upstream_init(struct cx25821_dev *dev, int channel_select)
dev->_audio_lines_count = LINES_PER_AUDIO_BUFFER; dev->_audio_lines_count = LINES_PER_AUDIO_BUFFER;
_line_size = AUDIO_LINE_SIZE; _line_size = AUDIO_LINE_SIZE;
if( dev->input_audiofilename ) if( dev->input_audiofilename )
{ {
str_length = strlen(dev->input_audiofilename); str_length = strlen(dev->input_audiofilename);
dev->_audiofilename = (char *) kmalloc(str_length + 1, GFP_KERNEL); dev->_audiofilename = (char *) kmalloc(str_length + 1, GFP_KERNEL);
if( !dev->_audiofilename ) if( !dev->_audiofilename )
goto error; goto error;
memcpy(dev->_audiofilename, dev->input_audiofilename, str_length + 1); memcpy(dev->_audiofilename, dev->input_audiofilename, str_length + 1);
//Default if filename is empty string //Default if filename is empty string
if( strcmp(dev->input_audiofilename,"") == 0) if( strcmp(dev->input_audiofilename,"") == 0)
{ {
dev->_audiofilename = "/root/audioGOOD.wav"; dev->_audiofilename = "/root/audioGOOD.wav";
} }
} }
else else
{ {
str_length = strlen(_defaultAudioName); str_length = strlen(_defaultAudioName);
dev->_audiofilename = (char *) kmalloc(str_length + 1, GFP_KERNEL); dev->_audiofilename = (char *) kmalloc(str_length + 1, GFP_KERNEL);
if( !dev->_audiofilename ) if( !dev->_audiofilename )
goto error; goto error;
memcpy(dev->_audiofilename, _defaultAudioName, str_length + 1); memcpy(dev->_audiofilename, _defaultAudioName, str_length + 1);
} }
@ -822,4 +822,3 @@ int cx25821_audio_upstream_init(struct cx25821_dev *dev, int channel_select)
return err; return err;
} }

208
drivers/staging/cx25821/cx25821-audups11.c
View file

@ -1,7 +1,7 @@
/* /*
* Driver for the Conexant CX25821 PCIe bridge * Driver for the Conexant CX25821 PCIe bridge
* *
* Copyright (C) 2009 Conexant Systems Inc. * Copyright (C) 2009 Conexant Systems Inc.
* Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com> * Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com>
* Based on Steven Toth <stoth@linuxtv.org> cx23885 driver * Based on Steven Toth <stoth@linuxtv.org> cx23885 driver
* *
@ -40,37 +40,37 @@ static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
dprintk(2, "jmp to stopper (0x%x)\n", buf->risc.jmp[1]); dprintk(2, "jmp to stopper (0x%x)\n", buf->risc.jmp[1]);
if (!list_empty(&q->queued)) { if (!list_empty(&q->queued)) {
list_add_tail(&buf->vb.queue, &q->queued); list_add_tail(&buf->vb.queue, &q->queued);
buf->vb.state = VIDEOBUF_QUEUED; buf->vb.state = VIDEOBUF_QUEUED;
dprintk(2, "[%p/%d] buffer_queue - append to queued\n", buf, buf->vb.i); dprintk(2, "[%p/%d] buffer_queue - append to queued\n", buf, buf->vb.i);
} else if (list_empty(&q->active)) { } else if (list_empty(&q->active)) {
list_add_tail(&buf->vb.queue, &q->active); list_add_tail(&buf->vb.queue, &q->active);
cx25821_start_video_dma(dev, q, buf, &dev->sram_channels[SRAM_CH11]); cx25821_start_video_dma(dev, q, buf, &dev->sram_channels[SRAM_CH11]);
buf->vb.state = VIDEOBUF_ACTIVE; buf->vb.state = VIDEOBUF_ACTIVE;
buf->count = q->count++; buf->count = q->count++;
mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT); mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
dprintk(2, "[%p/%d] buffer_queue - first active, buf cnt = %d, q->count = %d\n", dprintk(2, "[%p/%d] buffer_queue - first active, buf cnt = %d, q->count = %d\n",
buf, buf->vb. i, buf->count, q->count); buf, buf->vb. i, buf->count, q->count);
} else { } else {
prev = list_entry(q->active.prev, struct cx25821_buffer, vb.queue); prev = list_entry(q->active.prev, struct cx25821_buffer, vb.queue);
if (prev->vb.width == buf->vb.width && if (prev->vb.width == buf->vb.width &&
prev->vb.height == buf->vb.height && prev->vb.height == buf->vb.height &&
prev->fmt == buf->fmt) { prev->fmt == buf->fmt) {
list_add_tail(&buf->vb.queue, &q->active); list_add_tail(&buf->vb.queue, &q->active);
buf->vb.state = VIDEOBUF_ACTIVE; buf->vb.state = VIDEOBUF_ACTIVE;
buf->count = q->count++; buf->count = q->count++;
prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma); prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
/* 64 bit bits 63-32 */ /* 64 bit bits 63-32 */
prev->risc.jmp[2] = cpu_to_le32(0); prev->risc.jmp[2] = cpu_to_le32(0);
dprintk(2, "[%p/%d] buffer_queue - append to active, buf->count=%d\n", buf, buf->vb.i, buf->count); dprintk(2, "[%p/%d] buffer_queue - append to active, buf->count=%d\n", buf, buf->vb.i, buf->count);
} else { } else {
list_add_tail(&buf->vb.queue, &q->queued); list_add_tail(&buf->vb.queue, &q->queued);
buf->vb.state = VIDEOBUF_QUEUED; buf->vb.state = VIDEOBUF_QUEUED;
dprintk(2, "[%p/%d] buffer_queue - first queued\n", buf, buf->vb.i); dprintk(2, "[%p/%d] buffer_queue - first queued\n", buf, buf->vb.i);
} }
} }
if (list_empty(&q->active)) if (list_empty(&q->active))
@ -99,18 +99,18 @@ static int video_open(struct file *file)
lock_kernel(); lock_kernel();
list_for_each(list, &cx25821_devlist) list_for_each(list, &cx25821_devlist)
{ {
h = list_entry(list, struct cx25821_dev, devlist); h = list_entry(list, struct cx25821_dev, devlist);
if (h->video_dev[SRAM_CH11] && h->video_dev[SRAM_CH11]->minor == minor) if (h->video_dev[SRAM_CH11] && h->video_dev[SRAM_CH11]->minor == minor)
{ {
dev = h; dev = h;
type = V4L2_BUF_TYPE_VIDEO_CAPTURE; type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
} }
} }
if (NULL == dev) { if (NULL == dev) {
unlock_kernel(); unlock_kernel();
return -ENODEV; return -ENODEV;
} }
printk("open minor=%d type=%s\n", minor, v4l2_type_names[type]); printk("open minor=%d type=%s\n", minor, v4l2_type_names[type]);
@ -118,8 +118,8 @@ static int video_open(struct file *file)
/* allocate + initialize per filehandle data */ /* allocate + initialize per filehandle data */
fh = kzalloc(sizeof(*fh), GFP_KERNEL); fh = kzalloc(sizeof(*fh), GFP_KERNEL);
if (NULL == fh) { if (NULL == fh) {
unlock_kernel(); unlock_kernel();
return -ENOMEM; return -ENOMEM;
} }
file->private_data = fh; file->private_data = fh;
@ -128,21 +128,21 @@ static int video_open(struct file *file)
fh->width = 720; fh->width = 720;
if(dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK) if(dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK)
fh->height = 576; fh->height = 576;
else else
fh->height = 480; fh->height = 480;
dev->channel_opened = 10; dev->channel_opened = 10;
fh->fmt = format_by_fourcc(V4L2_PIX_FMT_YUYV); fh->fmt = format_by_fourcc(V4L2_PIX_FMT_YUYV);
v4l2_prio_open(&dev->prio,&fh->prio); v4l2_prio_open(&dev->prio,&fh->prio);
videobuf_queue_sg_init(&fh->vidq, &cx25821_video_qops, videobuf_queue_sg_init(&fh->vidq, &cx25821_video_qops,
&dev->pci->dev, &dev->slock, &dev->pci->dev, &dev->slock,
V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_BUF_TYPE_VIDEO_CAPTURE,
V4L2_FIELD_INTERLACED, V4L2_FIELD_INTERLACED,
sizeof(struct cx25821_buffer), sizeof(struct cx25821_buffer),
fh); fh);
dprintk(1, "post videobuf_queue_init()\n"); dprintk(1, "post videobuf_queue_init()\n");
unlock_kernel(); unlock_kernel();
@ -156,15 +156,15 @@ static ssize_t video_read(struct file *file, char __user *data, size_t count, lo
switch (fh->type) switch (fh->type)
{ {
case V4L2_BUF_TYPE_VIDEO_CAPTURE: case V4L2_BUF_TYPE_VIDEO_CAPTURE:
if (res_locked(fh->dev, RESOURCE_VIDEO11)) if (res_locked(fh->dev, RESOURCE_VIDEO11))
return -EBUSY; return -EBUSY;
return videobuf_read_one(&fh->vidq, data, count, ppos, file->f_flags & O_NONBLOCK); return videobuf_read_one(&fh->vidq, data, count, ppos, file->f_flags & O_NONBLOCK);
default: default:
BUG(); BUG();
return 0; return 0;
} }
} }
@ -174,21 +174,21 @@ static unsigned int video_poll(struct file *file, struct poll_table_struct *wait
struct cx25821_buffer *buf; struct cx25821_buffer *buf;
if (res_check(fh, RESOURCE_VIDEO11)) { if (res_check(fh, RESOURCE_VIDEO11)) {
/* streaming capture */ /* streaming capture */
if (list_empty(&fh->vidq.stream)) if (list_empty(&fh->vidq.stream))
return POLLERR; return POLLERR;
buf = list_entry(fh->vidq.stream.next, buf = list_entry(fh->vidq.stream.next,
struct cx25821_buffer, vb.stream); struct cx25821_buffer, vb.stream);
} else { } else {
/* read() capture */ /* read() capture */
buf = (struct cx25821_buffer *)fh->vidq.read_buf; buf = (struct cx25821_buffer *)fh->vidq.read_buf;
if (NULL == buf) if (NULL == buf)
return POLLERR; return POLLERR;
} }
poll_wait(file, &buf->vb.done, wait); poll_wait(file, &buf->vb.done, wait);
if (buf->vb.state == VIDEOBUF_DONE || buf->vb.state == VIDEOBUF_ERROR) if (buf->vb.state == VIDEOBUF_DONE || buf->vb.state == VIDEOBUF_ERROR)
return POLLIN|POLLRDNORM; return POLLIN|POLLRDNORM;
return 0; return 0;
} }
@ -199,17 +199,17 @@ static int video_release(struct file *file)
struct cx25821_dev *dev = fh->dev; struct cx25821_dev *dev = fh->dev;
//stop the risc engine and fifo //stop the risc engine and fifo
//cx_write(channel11->dma_ctl, 0); //cx_write(channel11->dma_ctl, 0);
/* stop video capture */ /* stop video capture */
if (res_check(fh, RESOURCE_VIDEO11)) { if (res_check(fh, RESOURCE_VIDEO11)) {
videobuf_queue_cancel(&fh->vidq); videobuf_queue_cancel(&fh->vidq);
res_free(dev, fh, RESOURCE_VIDEO11); res_free(dev, fh, RESOURCE_VIDEO11);
} }
if (fh->vidq.read_buf) { if (fh->vidq.read_buf) {
buffer_release(&fh->vidq, fh->vidq.read_buf); buffer_release(&fh->vidq, fh->vidq.read_buf);
kfree(fh->vidq.read_buf); kfree(fh->vidq.read_buf);
} }
videobuf_mmap_free(&fh->vidq); videobuf_mmap_free(&fh->vidq);
@ -230,17 +230,17 @@ static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
if (unlikely(fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)) if (unlikely(fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE))
{ {
return -EINVAL; return -EINVAL;
} }
if (unlikely(i != fh->type)) if (unlikely(i != fh->type))
{ {
return -EINVAL; return -EINVAL;
} }
if (unlikely(!res_get(dev, fh, get_resource(fh, RESOURCE_VIDEO11)))) if (unlikely(!res_get(dev, fh, get_resource(fh, RESOURCE_VIDEO11))))
{ {
return -EBUSY; return -EBUSY;
} }
return videobuf_streamon(get_queue(fh)); return videobuf_streamon(get_queue(fh));
@ -253,14 +253,14 @@ static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
int err, res; int err, res;
if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
return -EINVAL; return -EINVAL;
if (i != fh->type) if (i != fh->type)
return -EINVAL; return -EINVAL;
res = get_resource(fh, RESOURCE_VIDEO11); res = get_resource(fh, RESOURCE_VIDEO11);
err = videobuf_streamoff(get_queue(fh)); err = videobuf_streamoff(get_queue(fh));
if (err < 0) if (err < 0)
return err; return err;
res_free(dev, fh, res); res_free(dev, fh, res);
return 0; return 0;
} }
@ -272,18 +272,18 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, struct v4l2_forma
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
int err; int err;
if (fh) if (fh)
{ {
err = v4l2_prio_check(&dev->prio, &fh->prio); err = v4l2_prio_check(&dev->prio, &fh->prio);
if (0 != err) if (0 != err)
return err; return err;
} }
dprintk(2, "%s()\n", __func__); dprintk(2, "%s()\n", __func__);
err = vidioc_try_fmt_vid_cap(file, priv, f); err = vidioc_try_fmt_vid_cap(file, priv, f);
if (0 != err) if (0 != err)
return err; return err;
fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat); fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat);
fh->width = f->fmt.pix.width; fh->width = f->fmt.pix.width;
fh->height = f->fmt.pix.height; fh->height = f->fmt.pix.height;
@ -293,30 +293,30 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, struct v4l2_forma
return 0; return 0;
} }
static long video_ioctl_upstream11(struct file *file, unsigned int cmd, unsigned long arg) static long video_ioctl_upstream11(struct file *file, unsigned int cmd, unsigned long arg)
{ {
struct cx25821_fh *fh = file->private_data; struct cx25821_fh *fh = file->private_data;
struct cx25821_dev *dev = fh->dev; struct cx25821_dev *dev = fh->dev;
int command = 0; int command = 0;
struct upstream_user_struct *data_from_user; struct upstream_user_struct *data_from_user;
data_from_user = (struct upstream_user_struct *)arg; data_from_user = (struct upstream_user_struct *)arg;
if( !data_from_user ) if( !data_from_user )
{ {
printk("cx25821 in %s(): Upstream data is INVALID. Returning.\n", __func__); printk("cx25821 in %s(): Upstream data is INVALID. Returning.\n", __func__);
return 0; return 0;
} }
command = data_from_user->command; command = data_from_user->command;
if( command != UPSTREAM_START_AUDIO && command != UPSTREAM_STOP_AUDIO ) if( command != UPSTREAM_START_AUDIO && command != UPSTREAM_STOP_AUDIO )
{ {
return 0; return 0;
} }
dev->input_filename = data_from_user->input_filename; dev->input_filename = data_from_user->input_filename;
dev->input_audiofilename = data_from_user->input_filename; dev->input_audiofilename = data_from_user->input_filename;
dev->vid_stdname = data_from_user->vid_stdname; dev->vid_stdname = data_from_user->vid_stdname;
@ -324,18 +324,18 @@ static long video_ioctl_upstream11(struct file *file, unsigned int cmd, unsigned
dev->channel_select = data_from_user->channel_select; dev->channel_select = data_from_user->channel_select;
dev->command = data_from_user->command; dev->command = data_from_user->command;
switch(command)
{
case UPSTREAM_START_AUDIO:
cx25821_start_upstream_audio(dev, data_from_user);
break;
case UPSTREAM_STOP_AUDIO: switch(command)
cx25821_stop_upstream_audio(dev); {
break; case UPSTREAM_START_AUDIO:
cx25821_start_upstream_audio(dev, data_from_user);
break;
case UPSTREAM_STOP_AUDIO:
cx25821_stop_upstream_audio(dev);
break;
} }
return 0; return 0;
} }
@ -366,11 +366,11 @@ static int vidioc_s_ctrl(struct file *file, void *priv,
struct cx25821_dev *dev = fh->dev; struct cx25821_dev *dev = fh->dev;
int err; int err;
if (fh) if (fh)
{ {
err = v4l2_prio_check(&dev->prio, &fh->prio); err = v4l2_prio_check(&dev->prio, &fh->prio);
if (0 != err) if (0 != err)
return err; return err;
} }
return 0; return 0;
} }
@ -382,7 +382,7 @@ static const struct v4l2_file_operations video_fops = {
.read = video_read, .read = video_read,
.poll = video_poll, .poll = video_poll,
.mmap = video_mmap, .mmap = video_mmap,
.ioctl = video_ioctl_upstream11, .ioctl = video_ioctl_upstream11,
}; };
static const struct v4l2_ioctl_ops video_ioctl_ops = { static const struct v4l2_ioctl_ops video_ioctl_ops = {

10
drivers/staging/cx25821/cx25821-cards.c
View file

@ -30,12 +30,12 @@
#include "cx25821.h" #include "cx25821.h"
#include "tuner-xc2028.h" #include "tuner-xc2028.h"
// board config info // board config info
struct cx25821_board cx25821_boards[] = { struct cx25821_board cx25821_boards[] = {
[UNKNOWN_BOARD] = { [UNKNOWN_BOARD] = {
.name = "UNKNOWN/GENERIC", .name = "UNKNOWN/GENERIC",
// Ensure safe default for unknown boards // Ensure safe default for unknown boards
.clk_freq = 0, .clk_freq = 0,
}, },
@ -43,8 +43,8 @@ struct cx25821_board cx25821_boards[] = {
.name = "CX25821", .name = "CX25821",
.portb = CX25821_RAW, .portb = CX25821_RAW,
.portc = CX25821_264, .portc = CX25821_264,
.input[0].type = CX25821_VMUX_COMPOSITE, .input[0].type = CX25821_VMUX_COMPOSITE,
}, },
}; };
@ -63,7 +63,7 @@ void cx25821_card_setup(struct cx25821_dev *dev)
{ {
static u8 eeprom[256]; static u8 eeprom[256];
if (dev->i2c_bus[0].i2c_rc == 0) if (dev->i2c_bus[0].i2c_rc == 0)
{ {
dev->i2c_bus[0].i2c_client.addr = 0xa0 >> 1; dev->i2c_bus[0].i2c_client.addr = 0xa0 >> 1;
tveeprom_read(&dev->i2c_bus[0].i2c_client, eeprom, sizeof(eeprom)); tveeprom_read(&dev->i2c_bus[0].i2c_client, eeprom, sizeof(eeprom));

1424
drivers/staging/cx25821/cx25821-core.c
View file

File diff suppressed because it is too large Load diff

50
drivers/staging/cx25821/cx25821-gpio.c
View file

@ -25,17 +25,17 @@
/********************* GPIO stuffs *********************/ /********************* GPIO stuffs *********************/
void cx25821_set_gpiopin_direction( struct cx25821_dev *dev, void cx25821_set_gpiopin_direction( struct cx25821_dev *dev,
int pin_number, int pin_number,
int pin_logic_value) int pin_logic_value)
{ {
int bit = pin_number; int bit = pin_number;
u32 gpio_oe_reg = GPIO_LO_OE; u32 gpio_oe_reg = GPIO_LO_OE;
u32 gpio_register = 0; u32 gpio_register = 0;
u32 value = 0; u32 value = 0;
// Check for valid pinNumber // Check for valid pinNumber
if ( pin_number >= 47 ) if ( pin_number >= 47 )
return; return;
if ( pin_number > 31 ) if ( pin_number > 31 )
@ -46,32 +46,32 @@ void cx25821_set_gpiopin_direction( struct cx25821_dev *dev,
// Here we will make sure that the GPIOs 0 and 1 are output. keep the rest as is // Here we will make sure that the GPIOs 0 and 1 are output. keep the rest as is
gpio_register = cx_read( gpio_oe_reg ); gpio_register = cx_read( gpio_oe_reg );
if (pin_logic_value == 1) if (pin_logic_value == 1)
{ {
value = gpio_register | Set_GPIO_Bit(bit) ; value = gpio_register | Set_GPIO_Bit(bit) ;
} }
else else
{ {
value = gpio_register & Clear_GPIO_Bit(bit) ; value = gpio_register & Clear_GPIO_Bit(bit) ;
} }
cx_write( gpio_oe_reg, value ); cx_write( gpio_oe_reg, value );
} }
static void cx25821_set_gpiopin_logicvalue( struct cx25821_dev *dev, static void cx25821_set_gpiopin_logicvalue( struct cx25821_dev *dev,
int pin_number, int pin_number,
int pin_logic_value) int pin_logic_value)
{ {
int bit = pin_number; int bit = pin_number;
u32 gpio_reg = GPIO_LO; u32 gpio_reg = GPIO_LO;
u32 value = 0; u32 value = 0;
// Check for valid pinNumber // Check for valid pinNumber
if (pin_number >= 47) if (pin_number >= 47)
return; return;
cx25821_set_gpiopin_direction(dev, pin_number, 0); // change to output direction cx25821_set_gpiopin_direction(dev, pin_number, 0); // change to output direction
@ -82,15 +82,15 @@ static void cx25821_set_gpiopin_logicvalue( struct cx25821_dev *dev,
} }
value = cx_read( gpio_reg ); value = cx_read( gpio_reg );
if (pin_logic_value == 0) if (pin_logic_value == 0)
{ {
value &= Clear_GPIO_Bit(bit); value &= Clear_GPIO_Bit(bit);
} }
else else
{ {
value |= Set_GPIO_Bit(bit); value |= Set_GPIO_Bit(bit);
} }
cx_write( gpio_reg, value); cx_write( gpio_reg, value);
@ -102,15 +102,15 @@ void cx25821_gpio_init(struct cx25821_dev *dev)
{ {
return; return;
} }
switch (dev->board) switch (dev->board)
{ {
case CX25821_BOARD_CONEXANT_ATHENA10: case CX25821_BOARD_CONEXANT_ATHENA10:
default: default:
//set GPIO 5 to select the path for Medusa/Athena //set GPIO 5 to select the path for Medusa/Athena
cx25821_set_gpiopin_logicvalue(dev, 5, 1); cx25821_set_gpiopin_logicvalue(dev, 5, 1);
mdelay(20); mdelay(20);
break; break;
} }
} }

72
drivers/staging/cx25821/cx25821-i2c.c
View file

@ -88,9 +88,9 @@ static int i2c_sendbytes(struct i2c_adapter *i2c_adap, const struct i2c_msg *msg
dprintk(1, "%s(msg->len=%d)\n", __func__, msg->len); dprintk(1, "%s(msg->len=%d)\n", __func__, msg->len);
/* Deal with i2c probe functions with zero payload */ /* Deal with i2c probe functions with zero payload */
if (msg->len == 0) if (msg->len == 0)
{ {
cx_write(bus->reg_addr, msg->addr << 25); cx_write(bus->reg_addr, msg->addr << 25);
cx_write(bus->reg_ctrl, bus->i2c_period | (1 << 2)); cx_write(bus->reg_ctrl, bus->i2c_period | (1 << 2));
if (!i2c_wait_done(i2c_adap)) if (!i2c_wait_done(i2c_adap))
@ -106,7 +106,7 @@ static int i2c_sendbytes(struct i2c_adapter *i2c_adap, const struct i2c_msg *msg
/* dev, reg + first byte */ /* dev, reg + first byte */
addr = (msg->addr << 25) | msg->buf[0]; addr = (msg->addr << 25) | msg->buf[0];
wdata = msg->buf[0]; wdata = msg->buf[0];
ctrl = bus->i2c_period | (1 << 12) | (1 << 2); ctrl = bus->i2c_period | (1 << 12) | (1 << 2);
if (msg->len > 1) if (msg->len > 1)
@ -125,7 +125,7 @@ static int i2c_sendbytes(struct i2c_adapter *i2c_adap, const struct i2c_msg *msg
if (retval == 0) if (retval == 0)
goto eio; goto eio;
if (i2c_debug) if (i2c_debug)
{ {
if (!(ctrl & I2C_NOSTOP)) if (!(ctrl & I2C_NOSTOP))
printk(" >\n"); printk(" >\n");
@ -152,14 +152,14 @@ static int i2c_sendbytes(struct i2c_adapter *i2c_adap, const struct i2c_msg *msg
if (retval == 0) if (retval == 0)
goto eio; goto eio;
if (i2c_debug) if (i2c_debug)
{ {
dprintk(1, " %02x", msg->buf[cnt]); dprintk(1, " %02x", msg->buf[cnt]);
if (!(ctrl & I2C_NOSTOP)) if (!(ctrl & I2C_NOSTOP))
dprintk(1, " >\n"); dprintk(1, " >\n");
} }
} }
return msg->len; return msg->len;
eio: eio:
@ -244,18 +244,18 @@ static int i2c_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs, int num)
dprintk(1, "%s(num = %d)\n", __func__, num); dprintk(1, "%s(num = %d)\n", __func__, num);
for (i = 0 ; i < num; i++) for (i = 0 ; i < num; i++)
{ {
dprintk(1, "%s(num = %d) addr = 0x%02x len = 0x%x\n", dprintk(1, "%s(num = %d) addr = 0x%02x len = 0x%x\n",
__func__, num, msgs[i].addr, msgs[i].len); __func__, num, msgs[i].addr, msgs[i].len);
if (msgs[i].flags & I2C_M_RD) if (msgs[i].flags & I2C_M_RD)
{ {
/* read */ /* read */
retval = i2c_readbytes(i2c_adap, &msgs[i], 0); retval = i2c_readbytes(i2c_adap, &msgs[i], 0);
} }
else if (i + 1 < num && (msgs[i + 1].flags & I2C_M_RD) && else if (i + 1 < num && (msgs[i + 1].flags & I2C_M_RD) &&
msgs[i].addr == msgs[i + 1].addr) msgs[i].addr == msgs[i + 1].addr)
{ {
/* write then read from same address */ /* write then read from same address */
retval = i2c_sendbytes(i2c_adap, &msgs[i], msgs[i + 1].len); retval = i2c_sendbytes(i2c_adap, &msgs[i], msgs[i + 1].len);
@ -264,13 +264,13 @@ static int i2c_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs, int num)
goto err; goto err;
i++; i++;
retval = i2c_readbytes(i2c_adap, &msgs[i], 1); retval = i2c_readbytes(i2c_adap, &msgs[i], 1);
} }
else else
{ {
/* write */ /* write */
retval = i2c_sendbytes(i2c_adap, &msgs[i], 0); retval = i2c_sendbytes(i2c_adap, &msgs[i], 0);
} }
if (retval < 0) if (retval < 0)
goto err; goto err;
} }
@ -283,9 +283,9 @@ static int i2c_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs, int num)
static u32 cx25821_functionality(struct i2c_adapter *adap) static u32 cx25821_functionality(struct i2c_adapter *adap)
{ {
return I2C_FUNC_SMBUS_EMUL | return I2C_FUNC_SMBUS_EMUL |
I2C_FUNC_I2C | I2C_FUNC_I2C |
I2C_FUNC_SMBUS_WORD_DATA | I2C_FUNC_SMBUS_WORD_DATA |
I2C_FUNC_SMBUS_READ_WORD_DATA | I2C_FUNC_SMBUS_READ_WORD_DATA |
I2C_FUNC_SMBUS_WRITE_WORD_DATA; I2C_FUNC_SMBUS_WRITE_WORD_DATA;
} }
@ -334,7 +334,7 @@ int cx25821_i2c_register(struct cx25821_i2c *bus)
//set up the I2c //set up the I2c
bus->i2c_client.addr = (0x88>>1); bus->i2c_client.addr = (0x88>>1);
return bus->i2c_rc; return bus->i2c_rc;
} }
@ -375,19 +375,19 @@ int cx25821_i2c_read(struct cx25821_i2c *bus, u16 reg_addr, int *value)
int v = 0; int v = 0;
u8 addr[2] = {0, 0}; u8 addr[2] = {0, 0};
u8 buf[4] = {0,0,0,0}; u8 buf[4] = {0,0,0,0};
struct i2c_msg msgs[2]={ struct i2c_msg msgs[2]={
{ {
.addr = client->addr, .addr = client->addr,
.flags = 0, .flags = 0,
.len = 2, .len = 2,
.buf = addr, .buf = addr,
}, { }, {
.addr = client->addr, .addr = client->addr,
.flags = I2C_M_RD, .flags = I2C_M_RD,
.len = 4, .len = 4,
.buf = buf, .buf = buf,
} }
}; };
@ -401,23 +401,23 @@ int cx25821_i2c_read(struct cx25821_i2c *bus, u16 reg_addr, int *value)
v = (buf[3]<<24) | (buf[2]<<16) | (buf[1]<<8) | buf[0]; v = (buf[3]<<24) | (buf[2]<<16) | (buf[1]<<8) | buf[0];
*value = v; *value = v;
return v; return v;
} }
int cx25821_i2c_write(struct cx25821_i2c *bus, u16 reg_addr, int value) int cx25821_i2c_write(struct cx25821_i2c *bus, u16 reg_addr, int value)
{ {
struct i2c_client *client = &bus->i2c_client; struct i2c_client *client = &bus->i2c_client;
int retval = 0; int retval = 0;
u8 buf[6] = {0, 0, 0, 0, 0, 0}; u8 buf[6] = {0, 0, 0, 0, 0, 0};
struct i2c_msg msgs[1]={ struct i2c_msg msgs[1]={
{ {
.addr = client->addr, .addr = client->addr,
.flags = 0, .flags = 0,
.len = 6, .len = 6,
.buf = buf, .buf = buf,
} }
}; };

658
drivers/staging/cx25821/cx25821-medusa-video.c
View file

@ -1,7 +1,7 @@
/* /*
* Driver for the Conexant CX25821 PCIe bridge * Driver for the Conexant CX25821 PCIe bridge
* *
* Copyright (C) 2009 Conexant Systems Inc. * Copyright (C) 2009 Conexant Systems Inc.
* Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com> * Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com>
* *
* This program is free software; you can redistribute it and/or modify * This program is free software; you can redistribute it and/or modify
@ -38,52 +38,52 @@ static void medusa_enable_bluefield_output(struct cx25821_dev *dev, int channel,
int out_ctrl = OUT_CTRL1; int out_ctrl = OUT_CTRL1;
int out_ctrl_ns = OUT_CTRL_NS; int out_ctrl_ns = OUT_CTRL_NS;
switch (channel) switch (channel)
{ {
default: default:
case VDEC_A: case VDEC_A:
break; break;
case VDEC_B: case VDEC_B:
out_ctrl = VDEC_B_OUT_CTRL1; out_ctrl = VDEC_B_OUT_CTRL1;
out_ctrl_ns = VDEC_B_OUT_CTRL_NS; out_ctrl_ns = VDEC_B_OUT_CTRL_NS;
break; break;
case VDEC_C: case VDEC_C:
out_ctrl = VDEC_C_OUT_CTRL1; out_ctrl = VDEC_C_OUT_CTRL1;
out_ctrl_ns = VDEC_C_OUT_CTRL_NS; out_ctrl_ns = VDEC_C_OUT_CTRL_NS;
break; break;
case VDEC_D: case VDEC_D:
out_ctrl = VDEC_D_OUT_CTRL1; out_ctrl = VDEC_D_OUT_CTRL1;
out_ctrl_ns = VDEC_D_OUT_CTRL_NS; out_ctrl_ns = VDEC_D_OUT_CTRL_NS;
break; break;
case VDEC_E: case VDEC_E:
out_ctrl = VDEC_E_OUT_CTRL1; out_ctrl = VDEC_E_OUT_CTRL1;
out_ctrl_ns = VDEC_E_OUT_CTRL_NS; out_ctrl_ns = VDEC_E_OUT_CTRL_NS;
return; return;
case VDEC_F: case VDEC_F:
out_ctrl = VDEC_F_OUT_CTRL1; out_ctrl = VDEC_F_OUT_CTRL1;
out_ctrl_ns = VDEC_F_OUT_CTRL_NS; out_ctrl_ns = VDEC_F_OUT_CTRL_NS;
return; return;
case VDEC_G: case VDEC_G:
out_ctrl = VDEC_G_OUT_CTRL1; out_ctrl = VDEC_G_OUT_CTRL1;
out_ctrl_ns = VDEC_G_OUT_CTRL_NS; out_ctrl_ns = VDEC_G_OUT_CTRL_NS;
return; return;
case VDEC_H: case VDEC_H:
out_ctrl = VDEC_H_OUT_CTRL1; out_ctrl = VDEC_H_OUT_CTRL1;
out_ctrl_ns = VDEC_H_OUT_CTRL_NS; out_ctrl_ns = VDEC_H_OUT_CTRL_NS;
return; return;
} }
value = cx25821_i2c_read(&dev->i2c_bus[0], out_ctrl, &tmp); value = cx25821_i2c_read(&dev->i2c_bus[0], out_ctrl, &tmp);
value &= 0xFFFFFF7F; // clear BLUE_FIELD_EN value &= 0xFFFFFF7F; // clear BLUE_FIELD_EN
if (enable) if (enable)
value |= 0x00000080; // set BLUE_FIELD_EN value |= 0x00000080; // set BLUE_FIELD_EN
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], out_ctrl, value); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], out_ctrl, value);
value = cx25821_i2c_read(&dev->i2c_bus[0], out_ctrl_ns, &tmp); value = cx25821_i2c_read(&dev->i2c_bus[0], out_ctrl_ns, &tmp);
value &= 0xFFFFFF7F; value &= 0xFFFFFF7F;
if (enable) if (enable)
value |= 0x00000080; // set BLUE_FIELD_EN value |= 0x00000080; // set BLUE_FIELD_EN
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], out_ctrl_ns, value); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], out_ctrl_ns, value);
} }
@ -97,93 +97,93 @@ static int medusa_initialize_ntsc(struct cx25821_dev *dev)
mutex_lock(&dev->lock); mutex_lock(&dev->lock);
for (i=0; i < MAX_DECODERS; i++) for (i=0; i < MAX_DECODERS; i++)
{ {
// set video format NTSC-M // set video format NTSC-M
value = cx25821_i2c_read(&dev->i2c_bus[0], MODE_CTRL+(0x200*i), &tmp); value = cx25821_i2c_read(&dev->i2c_bus[0], MODE_CTRL+(0x200*i), &tmp);
value &= 0xFFFFFFF0; value &= 0xFFFFFFF0;
value |= 0x10001; // enable the fast locking mode bit[16] value |= 0x10001; // enable the fast locking mode bit[16]
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], MODE_CTRL+(0x200*i), value); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], MODE_CTRL+(0x200*i), value);
// resolution NTSC 720x480
value = cx25821_i2c_read(&dev->i2c_bus[0], HORIZ_TIM_CTRL+(0x200*i), &tmp);
value &= 0x00C00C00;
value |= 0x612D0074;
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], HORIZ_TIM_CTRL+(0x200*i), value);
value = cx25821_i2c_read(&dev->i2c_bus[0], VERT_TIM_CTRL+(0x200*i), &tmp);
value &= 0x00C00C00;
value |= 0x1C1E001A; // vblank_cnt + 2 to get camera ID
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], VERT_TIM_CTRL+(0x200*i), value);
// chroma subcarrier step size // resolution NTSC 720x480
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], SC_STEP_SIZE+(0x200*i), 0x43E00000); value = cx25821_i2c_read(&dev->i2c_bus[0], HORIZ_TIM_CTRL+(0x200*i), &tmp);
value &= 0x00C00C00;
// enable VIP optional active value |= 0x612D0074;
value = cx25821_i2c_read(&dev->i2c_bus[0], OUT_CTRL_NS+(0x200*i), &tmp); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], HORIZ_TIM_CTRL+(0x200*i), value);
value &= 0xFFFBFFFF;
value |= 0x00040000;
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], OUT_CTRL_NS+(0x200*i), value);
// enable VIP optional active (VIP_OPT_AL) for direct output. value = cx25821_i2c_read(&dev->i2c_bus[0], VERT_TIM_CTRL+(0x200*i), &tmp);
value = cx25821_i2c_read(&dev->i2c_bus[0], OUT_CTRL1+(0x200*i), &tmp); value &= 0x00C00C00;
value &= 0xFFFBFFFF; value |= 0x1C1E001A; // vblank_cnt + 2 to get camera ID
value |= 0x00040000; ret_val = cx25821_i2c_write(&dev->i2c_bus[0], VERT_TIM_CTRL+(0x200*i), value);
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], OUT_CTRL1+(0x200*i), value);
// clear VPRES_VERT_EN bit, fixes the chroma run away problem // chroma subcarrier step size
// when the input switching rate < 16 fields ret_val = cx25821_i2c_write(&dev->i2c_bus[0], SC_STEP_SIZE+(0x200*i), 0x43E00000);
//
value = cx25821_i2c_read(&dev->i2c_bus[0], MISC_TIM_CTRL+(0x200*i), &tmp);
value = setBitAtPos(value, 14); // disable special play detection
value = clearBitAtPos(value, 15);
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], MISC_TIM_CTRL+(0x200*i), value);
// set vbi_gate_en to 0 // enable VIP optional active
value = cx25821_i2c_read(&dev->i2c_bus[0], DFE_CTRL1+(0x200*i), &tmp); value = cx25821_i2c_read(&dev->i2c_bus[0], OUT_CTRL_NS+(0x200*i), &tmp);
value = clearBitAtPos(value, 29); value &= 0xFFFBFFFF;
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DFE_CTRL1+(0x200*i), value); value |= 0x00040000;
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], OUT_CTRL_NS+(0x200*i), value);
// Enable the generation of blue field output if no video
medusa_enable_bluefield_output(dev, i, 1); // enable VIP optional active (VIP_OPT_AL) for direct output.
value = cx25821_i2c_read(&dev->i2c_bus[0], OUT_CTRL1+(0x200*i), &tmp);
value &= 0xFFFBFFFF;
value |= 0x00040000;
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], OUT_CTRL1+(0x200*i), value);
// clear VPRES_VERT_EN bit, fixes the chroma run away problem
// when the input switching rate < 16 fields
//
value = cx25821_i2c_read(&dev->i2c_bus[0], MISC_TIM_CTRL+(0x200*i), &tmp);
value = setBitAtPos(value, 14); // disable special play detection
value = clearBitAtPos(value, 15);
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], MISC_TIM_CTRL+(0x200*i), value);
// set vbi_gate_en to 0
value = cx25821_i2c_read(&dev->i2c_bus[0], DFE_CTRL1+(0x200*i), &tmp);
value = clearBitAtPos(value, 29);
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DFE_CTRL1+(0x200*i), value);
// Enable the generation of blue field output if no video
medusa_enable_bluefield_output(dev, i, 1);
} }
for (i=0; i < MAX_ENCODERS; i++) for (i=0; i < MAX_ENCODERS; i++)
{ {
// NTSC hclock // NTSC hclock
value = cx25821_i2c_read(&dev->i2c_bus[0], DENC_A_REG_1+(0x100*i), &tmp); value = cx25821_i2c_read(&dev->i2c_bus[0], DENC_A_REG_1+(0x100*i), &tmp);
value &= 0xF000FC00; value &= 0xF000FC00;
value |= 0x06B402D0; value |= 0x06B402D0;
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_1+(0x100*i), value); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_1+(0x100*i), value);
// burst begin and burst end // burst begin and burst end
value = cx25821_i2c_read(&dev->i2c_bus[0], DENC_A_REG_2+(0x100*i), &tmp); value = cx25821_i2c_read(&dev->i2c_bus[0], DENC_A_REG_2+(0x100*i), &tmp);
value &= 0xFF000000; value &= 0xFF000000;
value |= 0x007E9054; value |= 0x007E9054;
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_2+(0x100*i), value); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_2+(0x100*i), value);
value = cx25821_i2c_read(&dev->i2c_bus[0], DENC_A_REG_3+(0x100*i), &tmp); value = cx25821_i2c_read(&dev->i2c_bus[0], DENC_A_REG_3+(0x100*i), &tmp);
value &= 0xFC00FE00; value &= 0xFC00FE00;
value |= 0x00EC00F0; value |= 0x00EC00F0;
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_3+(0x100*i), value); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_3+(0x100*i), value);
// set NTSC vblank, no phase alternation, 7.5 IRE pedestal // set NTSC vblank, no phase alternation, 7.5 IRE pedestal
value = cx25821_i2c_read(&dev->i2c_bus[0], DENC_A_REG_4+(0x100*i), &tmp); value = cx25821_i2c_read(&dev->i2c_bus[0], DENC_A_REG_4+(0x100*i), &tmp);
value &= 0x00FCFFFF; value &= 0x00FCFFFF;
value |= 0x13020000; value |= 0x13020000;
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_4+(0x100*i), value); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_4+(0x100*i), value);
value = cx25821_i2c_read(&dev->i2c_bus[0], DENC_A_REG_5+(0x100*i), &tmp); value = cx25821_i2c_read(&dev->i2c_bus[0], DENC_A_REG_5+(0x100*i), &tmp);
value &= 0xFFFF0000; value &= 0xFFFF0000;
value |= 0x0000E575; value |= 0x0000E575;
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_5+(0x100*i), value); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_5+(0x100*i), value);
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_6+(0x100*i), 0x009A89C1); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_6+(0x100*i), 0x009A89C1);
// Subcarrier Increment // Subcarrier Increment
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_7+(0x100*i), 0x21F07C1F); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_7+(0x100*i), 0x21F07C1F);
} }
@ -206,23 +206,23 @@ static int medusa_PALCombInit(struct cx25821_dev *dev, int dec)
{ {
int ret_val = -1; int ret_val = -1;
u32 value = 0, tmp = 0; u32 value = 0, tmp = 0;
// Setup for 2D threshold // Setup for 2D threshold
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], COMB_2D_HFS_CFG+(0x200*dec), 0x20002861); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], COMB_2D_HFS_CFG+(0x200*dec), 0x20002861);
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], COMB_2D_HFD_CFG+(0x200*dec), 0x20002861); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], COMB_2D_HFD_CFG+(0x200*dec), 0x20002861);
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], COMB_2D_LF_CFG+(0x200*dec), 0x200A1023); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], COMB_2D_LF_CFG+(0x200*dec), 0x200A1023);
// Setup flat chroma and luma thresholds // Setup flat chroma and luma thresholds
value = cx25821_i2c_read(&dev->i2c_bus[0], COMB_FLAT_THRESH_CTRL+(0x200*dec), &tmp); value = cx25821_i2c_read(&dev->i2c_bus[0], COMB_FLAT_THRESH_CTRL+(0x200*dec), &tmp);
value &= 0x06230000; value &= 0x06230000;
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], COMB_FLAT_THRESH_CTRL+(0x200*dec), value); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], COMB_FLAT_THRESH_CTRL+(0x200*dec), value);
// set comb 2D blend // set comb 2D blend
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], COMB_2D_BLEND+(0x200*dec), 0x210F0F0F); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], COMB_2D_BLEND+(0x200*dec), 0x210F0F0F);
// COMB MISC CONTROL // COMB MISC CONTROL
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], COMB_MISC_CTRL+(0x200*dec), 0x41120A7F); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], COMB_MISC_CTRL+(0x200*dec), 0x41120A7F);
return ret_val; return ret_val;
} }
@ -235,110 +235,110 @@ static int medusa_initialize_pal(struct cx25821_dev *dev)
u32 tmp = 0; u32 tmp = 0;
mutex_lock(&dev->lock); mutex_lock(&dev->lock);
for (i=0; i < MAX_DECODERS; i++) for (i=0; i < MAX_DECODERS; i++)
{ {
// set video format PAL-BDGHI // set video format PAL-BDGHI
value = cx25821_i2c_read(&dev->i2c_bus[0], MODE_CTRL+(0x200*i), &tmp); value = cx25821_i2c_read(&dev->i2c_bus[0], MODE_CTRL+(0x200*i), &tmp);
value &= 0xFFFFFFF0; value &= 0xFFFFFFF0;
value |= 0x10004; // enable the fast locking mode bit[16] value |= 0x10004; // enable the fast locking mode bit[16]
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], MODE_CTRL+(0x200*i), value); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], MODE_CTRL+(0x200*i), value);
// resolution PAL 720x576
value = cx25821_i2c_read(&dev->i2c_bus[0], HORIZ_TIM_CTRL+(0x200*i), &tmp);
value &= 0x00C00C00;
value |= 0x632D007D;
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], HORIZ_TIM_CTRL+(0x200*i), value);
// vblank656_cnt=x26, vactive_cnt=240h, vblank_cnt=x24
value = cx25821_i2c_read(&dev->i2c_bus[0], VERT_TIM_CTRL+(0x200*i), &tmp);
value &= 0x00C00C00;
value |= 0x28240026; // vblank_cnt + 2 to get camera ID
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], VERT_TIM_CTRL+(0x200*i), value);
// chroma subcarrier step size
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], SC_STEP_SIZE+(0x200*i), 0x5411E2D0);
// enable VIP optional active
value = cx25821_i2c_read(&dev->i2c_bus[0], OUT_CTRL_NS+(0x200*i), &tmp);
value &= 0xFFFBFFFF;
value |= 0x00040000;
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], OUT_CTRL_NS+(0x200*i), value);
// enable VIP optional active (VIP_OPT_AL) for direct output.
value = cx25821_i2c_read(&dev->i2c_bus[0], OUT_CTRL1+(0x200*i), &tmp);
value &= 0xFFFBFFFF;
value |= 0x00040000;
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], OUT_CTRL1+(0x200*i), value);
// clear VPRES_VERT_EN bit, fixes the chroma run away problem
// when the input switching rate < 16 fields
value = cx25821_i2c_read(&dev->i2c_bus[0], MISC_TIM_CTRL+(0x200*i), &tmp);
value = setBitAtPos(value, 14); // disable special play detection
value = clearBitAtPos(value, 15);
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], MISC_TIM_CTRL+(0x200*i), value);
// set vbi_gate_en to 0
value = cx25821_i2c_read(&dev->i2c_bus[0], DFE_CTRL1+(0x200*i), &tmp);
value = clearBitAtPos(value, 29);
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DFE_CTRL1+(0x200*i), value);
medusa_PALCombInit(dev, i); // resolution PAL 720x576
value = cx25821_i2c_read(&dev->i2c_bus[0], HORIZ_TIM_CTRL+(0x200*i), &tmp);
// Enable the generation of blue field output if no video value &= 0x00C00C00;
medusa_enable_bluefield_output(dev, i, 1); value |= 0x632D007D;
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], HORIZ_TIM_CTRL+(0x200*i), value);
// vblank656_cnt=x26, vactive_cnt=240h, vblank_cnt=x24
value = cx25821_i2c_read(&dev->i2c_bus[0], VERT_TIM_CTRL+(0x200*i), &tmp);
value &= 0x00C00C00;
value |= 0x28240026; // vblank_cnt + 2 to get camera ID
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], VERT_TIM_CTRL+(0x200*i), value);
// chroma subcarrier step size
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], SC_STEP_SIZE+(0x200*i), 0x5411E2D0);
// enable VIP optional active
value = cx25821_i2c_read(&dev->i2c_bus[0], OUT_CTRL_NS+(0x200*i), &tmp);
value &= 0xFFFBFFFF;
value |= 0x00040000;
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], OUT_CTRL_NS+(0x200*i), value);
// enable VIP optional active (VIP_OPT_AL) for direct output.
value = cx25821_i2c_read(&dev->i2c_bus[0], OUT_CTRL1+(0x200*i), &tmp);
value &= 0xFFFBFFFF;
value |= 0x00040000;
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], OUT_CTRL1+(0x200*i), value);
// clear VPRES_VERT_EN bit, fixes the chroma run away problem
// when the input switching rate < 16 fields
value = cx25821_i2c_read(&dev->i2c_bus[0], MISC_TIM_CTRL+(0x200*i), &tmp);
value = setBitAtPos(value, 14); // disable special play detection
value = clearBitAtPos(value, 15);
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], MISC_TIM_CTRL+(0x200*i), value);
// set vbi_gate_en to 0
value = cx25821_i2c_read(&dev->i2c_bus[0], DFE_CTRL1+(0x200*i), &tmp);
value = clearBitAtPos(value, 29);
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DFE_CTRL1+(0x200*i), value);
medusa_PALCombInit(dev, i);
// Enable the generation of blue field output if no video
medusa_enable_bluefield_output(dev, i, 1);
} }
for (i=0; i < MAX_ENCODERS; i++) for (i=0; i < MAX_ENCODERS; i++)
{ {
// PAL hclock // PAL hclock
value = cx25821_i2c_read(&dev->i2c_bus[0], DENC_A_REG_1+(0x100*i), &tmp); value = cx25821_i2c_read(&dev->i2c_bus[0], DENC_A_REG_1+(0x100*i), &tmp);
value &= 0xF000FC00; value &= 0xF000FC00;
value |= 0x06C002D0; value |= 0x06C002D0;
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_1+(0x100*i), value); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_1+(0x100*i), value);
// burst begin and burst end // burst begin and burst end
value = cx25821_i2c_read(&dev->i2c_bus[0], DENC_A_REG_2+(0x100*i), &tmp); value = cx25821_i2c_read(&dev->i2c_bus[0], DENC_A_REG_2+(0x100*i), &tmp);
value &= 0xFF000000; value &= 0xFF000000;
value |= 0x007E9754; value |= 0x007E9754;
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_2+(0x100*i), value); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_2+(0x100*i), value);
// hblank and vactive // hblank and vactive
value = cx25821_i2c_read(&dev->i2c_bus[0], DENC_A_REG_3+(0x100*i), &tmp); value = cx25821_i2c_read(&dev->i2c_bus[0], DENC_A_REG_3+(0x100*i), &tmp);
value &= 0xFC00FE00; value &= 0xFC00FE00;
value |= 0x00FC0120; value |= 0x00FC0120;
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_3+(0x100*i), value); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_3+(0x100*i), value);
// set PAL vblank, phase alternation, 0 IRE pedestal // set PAL vblank, phase alternation, 0 IRE pedestal
value = cx25821_i2c_read(&dev->i2c_bus[0], DENC_A_REG_4+(0x100*i), &tmp); value = cx25821_i2c_read(&dev->i2c_bus[0], DENC_A_REG_4+(0x100*i), &tmp);
value &= 0x00FCFFFF; value &= 0x00FCFFFF;
value |= 0x14010000; value |= 0x14010000;
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_4+(0x100*i), value); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_4+(0x100*i), value);
value = cx25821_i2c_read(&dev->i2c_bus[0], DENC_A_REG_5+(0x100*i), &tmp);
value &= 0xFFFF0000;
value |= 0x0000F078;
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_5+(0x100*i), value);
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_6+(0x100*i), 0x00A493CF);
// Subcarrier Increment value = cx25821_i2c_read(&dev->i2c_bus[0], DENC_A_REG_5+(0x100*i), &tmp);
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_7+(0x100*i), 0x2A098ACB); value &= 0xFFFF0000;
value |= 0x0000F078;
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_5+(0x100*i), value);
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_6+(0x100*i), 0x00A493CF);
// Subcarrier Increment
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_7+(0x100*i), 0x2A098ACB);
} }
//set picture resolutions
//set picture resolutions
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], HSCALE_CTRL, 0x0); //0 - 720 ret_val = cx25821_i2c_write(&dev->i2c_bus[0], HSCALE_CTRL, 0x0); //0 - 720
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], VSCALE_CTRL, 0x0); //0 - 576 ret_val = cx25821_i2c_write(&dev->i2c_bus[0], VSCALE_CTRL, 0x0); //0 - 576
// set Bypass input format to PAL 625 lines // set Bypass input format to PAL 625 lines
value = cx25821_i2c_read(&dev->i2c_bus[0], BYP_AB_CTRL, &tmp); value = cx25821_i2c_read(&dev->i2c_bus[0], BYP_AB_CTRL, &tmp);
value &= 0xFFF7FDFF; value &= 0xFFF7FDFF;
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], BYP_AB_CTRL, value); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], BYP_AB_CTRL, value);
mutex_unlock(&dev->lock); mutex_unlock(&dev->lock);
return ret_val; return ret_val;
@ -350,26 +350,26 @@ int medusa_set_videostandard(struct cx25821_dev *dev)
int status = STATUS_SUCCESS; int status = STATUS_SUCCESS;
u32 value = 0, tmp = 0; u32 value = 0, tmp = 0;
if(dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK) if(dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK)
{ {
status = medusa_initialize_pal(dev); status = medusa_initialize_pal(dev);
} }
else else
{ {
status = medusa_initialize_ntsc(dev); status = medusa_initialize_ntsc(dev);
} }
// Enable DENC_A output // Enable DENC_A output
value = cx25821_i2c_read(&dev->i2c_bus[0], DENC_A_REG_4, &tmp); value = cx25821_i2c_read(&dev->i2c_bus[0], DENC_A_REG_4, &tmp);
value = setBitAtPos(value, 4); value = setBitAtPos(value, 4);
status = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_4, value); status = cx25821_i2c_write(&dev->i2c_bus[0], DENC_A_REG_4, value);
// Enable DENC_B output // Enable DENC_B output
value = cx25821_i2c_read(&dev->i2c_bus[0], DENC_B_REG_4, &tmp); value = cx25821_i2c_read(&dev->i2c_bus[0], DENC_B_REG_4, &tmp);
value = setBitAtPos(value, 4); value = setBitAtPos(value, 4);
status = cx25821_i2c_write(&dev->i2c_bus[0], DENC_B_REG_4, value); status = cx25821_i2c_write(&dev->i2c_bus[0], DENC_B_REG_4, value);
return status; return status;
} }
@ -380,7 +380,7 @@ void medusa_set_resolution(struct cx25821_dev *dev, int width, int decoder_selec
int decoder_count = 0; int decoder_count = 0;
int ret_val = 0; int ret_val = 0;
u32 hscale = 0x0; u32 hscale = 0x0;
u32 vscale = 0x0; u32 vscale = 0x0;
const int MAX_WIDTH = 720; const int MAX_WIDTH = 720;
mutex_lock(&dev->lock); mutex_lock(&dev->lock);
@ -388,55 +388,55 @@ void medusa_set_resolution(struct cx25821_dev *dev, int width, int decoder_selec
// validate the width - cannot be negative // validate the width - cannot be negative
if (width > MAX_WIDTH) if (width > MAX_WIDTH)
{ {
printk("cx25821 %s() : width %d > MAX_WIDTH %d ! resetting to MAX_WIDTH \n", __func__, width, MAX_WIDTH); printk("cx25821 %s() : width %d > MAX_WIDTH %d ! resetting to MAX_WIDTH \n", __func__, width, MAX_WIDTH);
width = MAX_WIDTH; width = MAX_WIDTH;
} }
if( decoder_select <= 7 && decoder_select >= 0 ) if( decoder_select <= 7 && decoder_select >= 0 )
{ {
decoder = decoder_select; decoder = decoder_select;
decoder_count = decoder_select + 1; decoder_count = decoder_select + 1;
} }
else else
{ {
decoder = 0; decoder = 0;
decoder_count = _num_decoders; decoder_count = _num_decoders;
} }
switch( width ) switch( width )
{ {
case 320: case 320:
hscale = 0x13E34B; hscale = 0x13E34B;
vscale = 0x0; vscale = 0x0;
break; break;
case 352: case 352:
hscale = 0x10A273; hscale = 0x10A273;
vscale = 0x0; vscale = 0x0;
break; break;
case 176: case 176:
hscale = 0x3115B2; hscale = 0x3115B2;
vscale = 0x1E00; vscale = 0x1E00;
break; break;
case 160: case 160:
hscale = 0x378D84; hscale = 0x378D84;
vscale = 0x1E00; vscale = 0x1E00;
break; break;
default: //720 default: //720
hscale = 0x0; hscale = 0x0;
vscale = 0x0; vscale = 0x0;
break; break;
} }
for( ; decoder < decoder_count; decoder++) for( ; decoder < decoder_count; decoder++)
{ {
// write scaling values for each decoder // write scaling values for each decoder
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], HSCALE_CTRL+(0x200*decoder), hscale); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], HSCALE_CTRL+(0x200*decoder), hscale);
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], VSCALE_CTRL+(0x200*decoder), vscale); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], VSCALE_CTRL+(0x200*decoder), vscale);
} }
mutex_unlock(&dev->lock); mutex_unlock(&dev->lock);
@ -448,52 +448,52 @@ static void medusa_set_decoderduration(struct cx25821_dev *dev, int decoder, int
u32 fld_cnt = 0; u32 fld_cnt = 0;
u32 tmp = 0; u32 tmp = 0;
u32 disp_cnt_reg = DISP_AB_CNT; u32 disp_cnt_reg = DISP_AB_CNT;
mutex_lock(&dev->lock); mutex_lock(&dev->lock);
// no support // no support
if (decoder < VDEC_A && decoder > VDEC_H) if (decoder < VDEC_A && decoder > VDEC_H)
{ {
mutex_unlock(&dev->lock); mutex_unlock(&dev->lock);
return; return;
} }
switch (decoder) switch (decoder)
{ {
default: default:
break; break;
case VDEC_C: case VDEC_C:
case VDEC_D: case VDEC_D:
disp_cnt_reg = DISP_CD_CNT; disp_cnt_reg = DISP_CD_CNT;
break; break;
case VDEC_E: case VDEC_E:
case VDEC_F: case VDEC_F:
disp_cnt_reg = DISP_EF_CNT; disp_cnt_reg = DISP_EF_CNT;
break; break;
case VDEC_G: case VDEC_G:
case VDEC_H: case VDEC_H:
disp_cnt_reg = DISP_GH_CNT; disp_cnt_reg = DISP_GH_CNT;
break; break;
} }
_display_field_cnt[decoder] = duration; _display_field_cnt[decoder] = duration;
// update hardware // update hardware
fld_cnt = cx25821_i2c_read(&dev->i2c_bus[0], disp_cnt_reg, &tmp); fld_cnt = cx25821_i2c_read(&dev->i2c_bus[0], disp_cnt_reg, &tmp);
if (!(decoder % 2)) // EVEN decoder if (!(decoder % 2)) // EVEN decoder
{ {
fld_cnt &= 0xFFFF0000; fld_cnt &= 0xFFFF0000;
fld_cnt |= duration; fld_cnt |= duration;
} }
else else
{ {
fld_cnt &= 0x0000FFFF; fld_cnt &= 0x0000FFFF;
fld_cnt |= ((u32)duration) << 16; fld_cnt |= ((u32)duration) << 16;
} }
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], disp_cnt_reg, fld_cnt); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], disp_cnt_reg, fld_cnt);
mutex_unlock(&dev->lock); mutex_unlock(&dev->lock);
} }
@ -514,7 +514,7 @@ static int mapM(
if((srcMin == srcMax) || (srcVal < srcMin) || (srcVal > srcMax)) if((srcMin == srcMax) || (srcVal < srcMin) || (srcVal > srcMax))
{ {
return -1; return -1;
} }
// This is the overall expression used: // This is the overall expression used:
@ -527,7 +527,7 @@ static int mapM(
if(2 * ( numerator % denominator ) >= denominator) if(2 * ( numerator % denominator ) >= denominator)
{ {
quotient++; quotient++;
} }
*dstVal = quotient + dstMin; *dstVal = quotient + dstMin;
@ -540,12 +540,12 @@ static unsigned long convert_to_twos(long numeric, unsigned long bits_len)
unsigned char temp; unsigned char temp;
if (numeric >= 0) if (numeric >= 0)
return numeric; return numeric;
else else
{ {
temp = ~(abs(numeric) & 0xFF); temp = ~(abs(numeric) & 0xFF);
temp += 1; temp += 1;
return temp; return temp;
} }
} }
///////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////
@ -558,8 +558,8 @@ int medusa_set_brightness(struct cx25821_dev *dev, int brightness, int decoder)
mutex_lock(&dev->lock); mutex_lock(&dev->lock);
if((brightness > VIDEO_PROCAMP_MAX) || (brightness < VIDEO_PROCAMP_MIN)) if((brightness > VIDEO_PROCAMP_MAX) || (brightness < VIDEO_PROCAMP_MIN))
{ {
mutex_unlock(&dev->lock); mutex_unlock(&dev->lock);
return -1; return -1;
} }
ret_val = mapM(VIDEO_PROCAMP_MIN, VIDEO_PROCAMP_MAX, brightness, SIGNED_BYTE_MIN, SIGNED_BYTE_MAX, &value); ret_val = mapM(VIDEO_PROCAMP_MIN, VIDEO_PROCAMP_MAX, brightness, SIGNED_BYTE_MIN, SIGNED_BYTE_MAX, &value);
value = convert_to_twos(value, 8); value = convert_to_twos(value, 8);
@ -578,11 +578,11 @@ int medusa_set_contrast(struct cx25821_dev *dev, int contrast, int decoder)
u32 val = 0, tmp = 0; u32 val = 0, tmp = 0;
mutex_lock(&dev->lock); mutex_lock(&dev->lock);
if((contrast > VIDEO_PROCAMP_MAX) || (contrast < VIDEO_PROCAMP_MIN)) if((contrast > VIDEO_PROCAMP_MAX) || (contrast < VIDEO_PROCAMP_MIN))
{ {
mutex_unlock(&dev->lock); mutex_unlock(&dev->lock);
return -1; return -1;
} }
ret_val = mapM(VIDEO_PROCAMP_MIN, VIDEO_PROCAMP_MAX, contrast, UNSIGNED_BYTE_MIN, UNSIGNED_BYTE_MAX, &value); ret_val = mapM(VIDEO_PROCAMP_MIN, VIDEO_PROCAMP_MAX, contrast, UNSIGNED_BYTE_MIN, UNSIGNED_BYTE_MAX, &value);
@ -602,15 +602,15 @@ int medusa_set_hue(struct cx25821_dev *dev, int hue, int decoder)
u32 val = 0, tmp = 0; u32 val = 0, tmp = 0;
mutex_lock(&dev->lock); mutex_lock(&dev->lock);
if((hue > VIDEO_PROCAMP_MAX) || (hue < VIDEO_PROCAMP_MIN)) if((hue > VIDEO_PROCAMP_MAX) || (hue < VIDEO_PROCAMP_MIN))
{ {
mutex_unlock(&dev->lock); mutex_unlock(&dev->lock);
return -1; return -1;
} }
ret_val = mapM(VIDEO_PROCAMP_MIN, VIDEO_PROCAMP_MAX, hue, SIGNED_BYTE_MIN, SIGNED_BYTE_MAX, &value); ret_val = mapM(VIDEO_PROCAMP_MIN, VIDEO_PROCAMP_MAX, hue, SIGNED_BYTE_MIN, SIGNED_BYTE_MAX, &value);
value = convert_to_twos(value, 8); value = convert_to_twos(value, 8);
val = cx25821_i2c_read(&dev->i2c_bus[0], VDEC_A_HUE_CTRL+(0x200*decoder), &tmp); val = cx25821_i2c_read(&dev->i2c_bus[0], VDEC_A_HUE_CTRL+(0x200*decoder), &tmp);
val &= 0xFFFFFF00; val &= 0xFFFFFF00;
@ -628,25 +628,25 @@ int medusa_set_saturation(struct cx25821_dev *dev, int saturation, int decoder)
int ret_val = 0; int ret_val = 0;
int value = 0; int value = 0;
u32 val = 0, tmp = 0; u32 val = 0, tmp = 0;
mutex_lock(&dev->lock); mutex_lock(&dev->lock);
if((saturation > VIDEO_PROCAMP_MAX) || (saturation < VIDEO_PROCAMP_MIN)) if((saturation > VIDEO_PROCAMP_MAX) || (saturation < VIDEO_PROCAMP_MIN))
{ {
mutex_unlock(&dev->lock); mutex_unlock(&dev->lock);
return -1; return -1;
} }
ret_val = mapM(VIDEO_PROCAMP_MIN, VIDEO_PROCAMP_MAX, saturation, UNSIGNED_BYTE_MIN, UNSIGNED_BYTE_MAX, &value); ret_val = mapM(VIDEO_PROCAMP_MIN, VIDEO_PROCAMP_MAX, saturation, UNSIGNED_BYTE_MIN, UNSIGNED_BYTE_MAX, &value);
val = cx25821_i2c_read(&dev->i2c_bus[0], VDEC_A_USAT_CTRL+(0x200*decoder), &tmp); val = cx25821_i2c_read(&dev->i2c_bus[0], VDEC_A_USAT_CTRL+(0x200*decoder), &tmp);
val &= 0xFFFFFF00; val &= 0xFFFFFF00;
ret_val |= cx25821_i2c_write(&dev->i2c_bus[0], VDEC_A_USAT_CTRL+(0x200*decoder), val | value); ret_val |= cx25821_i2c_write(&dev->i2c_bus[0], VDEC_A_USAT_CTRL+(0x200*decoder), val | value);
val = cx25821_i2c_read(&dev->i2c_bus[0], VDEC_A_VSAT_CTRL+(0x200*decoder), &tmp); val = cx25821_i2c_read(&dev->i2c_bus[0], VDEC_A_VSAT_CTRL+(0x200*decoder), &tmp);
val &= 0xFFFFFF00; val &= 0xFFFFFF00;
ret_val |= cx25821_i2c_write(&dev->i2c_bus[0], VDEC_A_VSAT_CTRL+(0x200*decoder), val | value); ret_val |= cx25821_i2c_write(&dev->i2c_bus[0], VDEC_A_VSAT_CTRL+(0x200*decoder), val | value);
mutex_unlock(&dev->lock); mutex_unlock(&dev->lock);
return ret_val; return ret_val;
} }
@ -660,75 +660,75 @@ int medusa_video_init(struct cx25821_dev *dev)
u32 value = 0, tmp = 0; u32 value = 0, tmp = 0;
int ret_val = 0; int ret_val = 0;
int i=0; int i=0;
mutex_lock(&dev->lock); mutex_lock(&dev->lock);
_num_decoders = dev->_max_num_decoders; _num_decoders = dev->_max_num_decoders;
// disable Auto source selection on all video decoders // disable Auto source selection on all video decoders
value = cx25821_i2c_read(&dev->i2c_bus[0], MON_A_CTRL, &tmp); value = cx25821_i2c_read(&dev->i2c_bus[0], MON_A_CTRL, &tmp);
value &= 0xFFFFF0FF; value &= 0xFFFFF0FF;
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], MON_A_CTRL, value); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], MON_A_CTRL, value);
if (ret_val < 0) if (ret_val < 0)
{ {
mutex_unlock(&dev->lock); mutex_unlock(&dev->lock);
return -EINVAL; return -EINVAL;
} }
// Turn off Master source switch enable // Turn off Master source switch enable
value = cx25821_i2c_read(&dev->i2c_bus[0], MON_A_CTRL, &tmp); value = cx25821_i2c_read(&dev->i2c_bus[0], MON_A_CTRL, &tmp);
value &= 0xFFFFFFDF; value &= 0xFFFFFFDF;
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], MON_A_CTRL, value); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], MON_A_CTRL, value);
if (ret_val < 0) if (ret_val < 0)
{ {
mutex_unlock(&dev->lock); mutex_unlock(&dev->lock);
return -EINVAL; return -EINVAL;
} }
mutex_unlock(&dev->lock); mutex_unlock(&dev->lock);
for (i=0; i < _num_decoders; i++) for (i=0; i < _num_decoders; i++)
{ {
medusa_set_decoderduration(dev, i, _display_field_cnt[i]); medusa_set_decoderduration(dev, i, _display_field_cnt[i]);
} }
mutex_lock(&dev->lock); mutex_lock(&dev->lock);
// Select monitor as DENC A input, power up the DAC // Select monitor as DENC A input, power up the DAC
value = cx25821_i2c_read(&dev->i2c_bus[0], DENC_AB_CTRL, &tmp); value = cx25821_i2c_read(&dev->i2c_bus[0], DENC_AB_CTRL, &tmp);
value &= 0xFF70FF70; value &= 0xFF70FF70;
value |= 0x00090008; // set en_active value |= 0x00090008; // set en_active
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_AB_CTRL, value); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], DENC_AB_CTRL, value);
if (ret_val < 0) if (ret_val < 0)
{ {
mutex_unlock(&dev->lock); mutex_unlock(&dev->lock);
return -EINVAL; return -EINVAL;
} }
// enable input is VIP/656 // enable input is VIP/656
value = cx25821_i2c_read(&dev->i2c_bus[0], BYP_AB_CTRL, &tmp); value = cx25821_i2c_read(&dev->i2c_bus[0], BYP_AB_CTRL, &tmp);
value |= 0x00040100; // enable VIP value |= 0x00040100; // enable VIP
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], BYP_AB_CTRL, value); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], BYP_AB_CTRL, value);
if (ret_val < 0) if (ret_val < 0)
{ {
mutex_unlock(&dev->lock); mutex_unlock(&dev->lock);
return -EINVAL; return -EINVAL;
} }
// select AFE clock to output mode // select AFE clock to output mode
value = cx25821_i2c_read(&dev->i2c_bus[0], AFE_AB_DIAG_CTRL, &tmp); value = cx25821_i2c_read(&dev->i2c_bus[0], AFE_AB_DIAG_CTRL, &tmp);
value &= 0x83FFFFFF; value &= 0x83FFFFFF;
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], AFE_AB_DIAG_CTRL, value | 0x10000000); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], AFE_AB_DIAG_CTRL, value | 0x10000000);
if (ret_val < 0) if (ret_val < 0)
{ {
mutex_unlock(&dev->lock); mutex_unlock(&dev->lock);
return -EINVAL; return -EINVAL;
} }
// Turn on all of the data out and control output pins. // Turn on all of the data out and control output pins.
@ -736,34 +736,34 @@ int medusa_video_init(struct cx25821_dev *dev)
value &= 0xFEF0FE00; value &= 0xFEF0FE00;
if (_num_decoders == MAX_DECODERS) if (_num_decoders == MAX_DECODERS)
{ {
// Note: The octal board does not support control pins(bit16-19). // Note: The octal board does not support control pins(bit16-19).
// These bits are ignored in the octal board. // These bits are ignored in the octal board.
value |= 0x010001F8; // disable VDEC A-C port, default to Mobilygen Interface value |= 0x010001F8; // disable VDEC A-C port, default to Mobilygen Interface
} }
else else
{ {
value |= 0x010F0108; // disable VDEC A-C port, default to Mobilygen Interface value |= 0x010F0108; // disable VDEC A-C port, default to Mobilygen Interface
} }
value |= 7; value |= 7;
ret_val = cx25821_i2c_write(&dev->i2c_bus[0], PIN_OE_CTRL, value); ret_val = cx25821_i2c_write(&dev->i2c_bus[0], PIN_OE_CTRL, value);
if (ret_val < 0) if (ret_val < 0)
{ {
mutex_unlock(&dev->lock); mutex_unlock(&dev->lock);
return -EINVAL; return -EINVAL;
} }
mutex_unlock(&dev->lock); mutex_unlock(&dev->lock);
ret_val = medusa_set_videostandard(dev); ret_val = medusa_set_videostandard(dev);
if (ret_val < 0) if (ret_val < 0)
{ {
mutex_unlock(&dev->lock); mutex_unlock(&dev->lock);
return -EINVAL; return -EINVAL;
} }
return 1; return 1;
} }

2
drivers/staging/cx25821/cx25821-medusa-video.h
View file

@ -26,7 +26,7 @@
#include "cx25821-medusa-defines.h" #include "cx25821-medusa-defines.h"
// Color control constants // Color control constants
#define VIDEO_PROCAMP_MIN 0 #define VIDEO_PROCAMP_MIN 0
#define VIDEO_PROCAMP_MAX 10000 #define VIDEO_PROCAMP_MAX 10000
#define UNSIGNED_BYTE_MIN 0 #define UNSIGNED_BYTE_MIN 0

24
drivers/staging/cx25821/cx25821-reg.h
View file

@ -1481,7 +1481,7 @@
//***************************************************************************** //*****************************************************************************
#define I2C1_ADDR 0x180000 // I2C #1 address #define I2C1_ADDR 0x180000 // I2C #1 address
#define FLD_I2C_DADDR 0xfe000000 // RW [31:25] I2C Device Address #define FLD_I2C_DADDR 0xfe000000 // RW [31:25] I2C Device Address
// RO [24] reserved // RO [24] reserved
//***************************************************************************** //*****************************************************************************
#define FLD_I2C_SADDR 0x00FFFFFF // RW [23:0] I2C Sub-address #define FLD_I2C_SADDR 0x00FFFFFF // RW [23:0] I2C Sub-address
@ -1494,15 +1494,15 @@
#define FLD_I2C_PERIOD 0xFF000000 // RW [31:24] #define FLD_I2C_PERIOD 0xFF000000 // RW [31:24]
#define FLD_I2C_SCL_IN 0x00200000 // RW [21] #define FLD_I2C_SCL_IN 0x00200000 // RW [21]
#define FLD_I2C_SDA_IN 0x00100000 // RW [20] #define FLD_I2C_SDA_IN 0x00100000 // RW [20]
// RO [19:18] reserved // RO [19:18] reserved
#define FLD_I2C_SCL_OUT 0x00020000 // RW [17] #define FLD_I2C_SCL_OUT 0x00020000 // RW [17]
#define FLD_I2C_SDA_OUT 0x00010000 // RW [16] #define FLD_I2C_SDA_OUT 0x00010000 // RW [16]
// RO [15] reserved // RO [15] reserved
#define FLD_I2C_DATA_LEN 0x00007000 // RW [14:12] #define FLD_I2C_DATA_LEN 0x00007000 // RW [14:12]
#define FLD_I2C_SADDR_INC 0x00000800 // RW [11] #define FLD_I2C_SADDR_INC 0x00000800 // RW [11]
// RO [10:9] reserved // RO [10:9] reserved
#define FLD_I2C_SADDR_LEN 0x00000300 // RW [9:8] #define FLD_I2C_SADDR_LEN 0x00000300 // RW [9:8]
// RO [7:6] reserved // RO [7:6] reserved
#define FLD_I2C_SOFT 0x00000020 // RW [5] #define FLD_I2C_SOFT 0x00000020 // RW [5]
#define FLD_I2C_NOSTOP 0x00000010 // RW [4] #define FLD_I2C_NOSTOP 0x00000010 // RW [4]
#define FLD_I2C_EXTEND 0x00000008 // RW [3] #define FLD_I2C_EXTEND 0x00000008 // RW [3]
@ -1588,13 +1588,13 @@
//***************************************************************************** //*****************************************************************************
// Motion Detection // Motion Detection
#define MD_CH0_GRID_BLOCK_YCNT 0x170014 #define MD_CH0_GRID_BLOCK_YCNT 0x170014
#define MD_CH1_GRID_BLOCK_YCNT 0x170094 #define MD_CH1_GRID_BLOCK_YCNT 0x170094
#define MD_CH2_GRID_BLOCK_YCNT 0x170114 #define MD_CH2_GRID_BLOCK_YCNT 0x170114
#define MD_CH3_GRID_BLOCK_YCNT 0x170194 #define MD_CH3_GRID_BLOCK_YCNT 0x170194
#define MD_CH4_GRID_BLOCK_YCNT 0x170214 #define MD_CH4_GRID_BLOCK_YCNT 0x170214
#define MD_CH5_GRID_BLOCK_YCNT 0x170294 #define MD_CH5_GRID_BLOCK_YCNT 0x170294
#define MD_CH6_GRID_BLOCK_YCNT 0x170314 #define MD_CH6_GRID_BLOCK_YCNT 0x170314
#define MD_CH7_GRID_BLOCK_YCNT 0x170394 #define MD_CH7_GRID_BLOCK_YCNT 0x170394
#define PIXEL_FRMT_422 4 #define PIXEL_FRMT_422 4

622
drivers/staging/cx25821/cx25821-video-upstream-ch2.c
View file

@ -44,97 +44,97 @@ static int _intr_msk = FLD_VID_SRC_RISC1 | FLD_VID_SRC_UF | FLD_VID_SRC_SYNC | F
static __le32 *cx25821_update_riscprogram_ch2( struct cx25821_dev *dev, static __le32 *cx25821_update_riscprogram_ch2( struct cx25821_dev *dev,
__le32 *rp, unsigned int offset, unsigned int bpl, __le32 *rp, unsigned int offset, unsigned int bpl,
u32 sync_line, unsigned int lines, int fifo_enable, int field_type) u32 sync_line, unsigned int lines, int fifo_enable, int field_type)
{ {
unsigned int line, i; unsigned int line, i;
int dist_betwn_starts = bpl * 2; int dist_betwn_starts = bpl * 2;
*(rp++) = cpu_to_le32(RISC_RESYNC | sync_line); *(rp++) = cpu_to_le32(RISC_RESYNC | sync_line);
if( USE_RISC_NOOP_VIDEO ) if( USE_RISC_NOOP_VIDEO )
{ {
for( i = 0; i < NUM_NO_OPS; i++ ) for( i = 0; i < NUM_NO_OPS; i++ )
{ {
*(rp++) = cpu_to_le32(RISC_NOOP); *(rp++) = cpu_to_le32(RISC_NOOP);
} }
} }
/* scan lines */ /* scan lines */
for (line = 0; line < lines; line++) for (line = 0; line < lines; line++)
{ {
*(rp++) = cpu_to_le32(RISC_READ|RISC_SOL|RISC_EOL|bpl); *(rp++) = cpu_to_le32(RISC_READ|RISC_SOL|RISC_EOL|bpl);
*(rp++) = cpu_to_le32(dev->_data_buf_phys_addr_ch2+offset); *(rp++) = cpu_to_le32(dev->_data_buf_phys_addr_ch2+offset);
*(rp++) = cpu_to_le32(0); /* bits 63-32 */ *(rp++) = cpu_to_le32(0); /* bits 63-32 */
if ( (lines <= NTSC_FIELD_HEIGHT) || (line < (NTSC_FIELD_HEIGHT-1)) || !(dev->_isNTSC_ch2) ) if ( (lines <= NTSC_FIELD_HEIGHT) || (line < (NTSC_FIELD_HEIGHT-1)) || !(dev->_isNTSC_ch2) )
{ {
offset += dist_betwn_starts; offset += dist_betwn_starts;
} }
} }
return rp; return rp;
} }
static __le32 *cx25821_risc_field_upstream_ch2( struct cx25821_dev *dev, static __le32 *cx25821_risc_field_upstream_ch2( struct cx25821_dev *dev,
__le32 *rp, __le32 *rp,
dma_addr_t databuf_phys_addr, dma_addr_t databuf_phys_addr,
unsigned int offset, u32 sync_line, unsigned int bpl, unsigned int offset, u32 sync_line, unsigned int bpl,
unsigned int lines, int fifo_enable, int field_type) unsigned int lines, int fifo_enable, int field_type)
{ {
unsigned int line, i; unsigned int line, i;
struct sram_channel *sram_ch = &dev->sram_channels[dev->_channel2_upstream_select]; struct sram_channel *sram_ch = &dev->sram_channels[dev->_channel2_upstream_select];
int dist_betwn_starts = bpl * 2; int dist_betwn_starts = bpl * 2;
/* sync instruction */ /* sync instruction */
if (sync_line != NO_SYNC_LINE) if (sync_line != NO_SYNC_LINE)
{ {
*(rp++) = cpu_to_le32(RISC_RESYNC | sync_line); *(rp++) = cpu_to_le32(RISC_RESYNC | sync_line);
} }
if( USE_RISC_NOOP_VIDEO ) if( USE_RISC_NOOP_VIDEO )
{ {
for( i = 0; i < NUM_NO_OPS; i++ ) for( i = 0; i < NUM_NO_OPS; i++ )
{ {
*(rp++) = cpu_to_le32(RISC_NOOP); *(rp++) = cpu_to_le32(RISC_NOOP);
} }
} }
/* scan lines */ /* scan lines */
for (line = 0; line < lines; line++) for (line = 0; line < lines; line++)
{ {
*(rp++) = cpu_to_le32(RISC_READ|RISC_SOL|RISC_EOL|bpl); *(rp++) = cpu_to_le32(RISC_READ|RISC_SOL|RISC_EOL|bpl);
*(rp++) = cpu_to_le32(databuf_phys_addr+offset); *(rp++) = cpu_to_le32(databuf_phys_addr+offset);
*(rp++) = cpu_to_le32(0); /* bits 63-32 */ *(rp++) = cpu_to_le32(0); /* bits 63-32 */
if ( (lines <= NTSC_FIELD_HEIGHT) || (line < (NTSC_FIELD_HEIGHT-1)) || !(dev->_isNTSC_ch2) ) if ( (lines <= NTSC_FIELD_HEIGHT) || (line < (NTSC_FIELD_HEIGHT-1)) || !(dev->_isNTSC_ch2) )
{ {
offset += dist_betwn_starts; offset += dist_betwn_starts;
} }
// check if we need to enable the FIFO after the first 4 lines // check if we need to enable the FIFO after the first 4 lines
// For the upstream video channel, the risc engine will enable the FIFO. // For the upstream video channel, the risc engine will enable the FIFO.
if ( fifo_enable && line == 3 ) if ( fifo_enable && line == 3 )
{ {
*(rp++) = RISC_WRITECR; *(rp++) = RISC_WRITECR;
*(rp++) = sram_ch->dma_ctl; *(rp++) = sram_ch->dma_ctl;
*(rp++) = FLD_VID_FIFO_EN; *(rp++) = FLD_VID_FIFO_EN;
*(rp++) = 0x00000001; *(rp++) = 0x00000001;
} }
} }
return rp; return rp;
} }
int cx25821_risc_buffer_upstream_ch2( struct cx25821_dev *dev, struct pci_dev *pci, int cx25821_risc_buffer_upstream_ch2( struct cx25821_dev *dev, struct pci_dev *pci,
unsigned int top_offset, unsigned int top_offset,
unsigned int bpl, unsigned int lines) unsigned int bpl, unsigned int lines)
{ {
__le32 *rp; __le32 *rp;
int fifo_enable = 0; int fifo_enable = 0;
@ -148,57 +148,57 @@ int cx25821_risc_buffer_upstream_ch2( struct cx25821_dev *dev, struct pci_dev *p
unsigned int bottom_offset = bpl; unsigned int bottom_offset = bpl;
dma_addr_t risc_phys_jump_addr; dma_addr_t risc_phys_jump_addr;
if( dev->_isNTSC_ch2 ) if( dev->_isNTSC_ch2 )
{ {
odd_num_lines = singlefield_lines + 1; odd_num_lines = singlefield_lines + 1;
risc_program_size = FRAME1_VID_PROG_SIZE; risc_program_size = FRAME1_VID_PROG_SIZE;
frame_size = (bpl == Y411_LINE_SZ) ? FRAME_SIZE_NTSC_Y411 : FRAME_SIZE_NTSC_Y422; frame_size = (bpl == Y411_LINE_SZ) ? FRAME_SIZE_NTSC_Y411 : FRAME_SIZE_NTSC_Y422;
} }
else else
{ {
risc_program_size = PAL_VID_PROG_SIZE; risc_program_size = PAL_VID_PROG_SIZE;
frame_size = (bpl == Y411_LINE_SZ) ? FRAME_SIZE_PAL_Y411 : FRAME_SIZE_PAL_Y422; frame_size = (bpl == Y411_LINE_SZ) ? FRAME_SIZE_PAL_Y411 : FRAME_SIZE_PAL_Y422;
} }
/* Virtual address of Risc buffer program */ /* Virtual address of Risc buffer program */
rp = dev->_dma_virt_addr_ch2; rp = dev->_dma_virt_addr_ch2;
for( frame = 0; frame < NUM_FRAMES; frame++ ) for( frame = 0; frame < NUM_FRAMES; frame++ )
{ {
databuf_offset = frame_size * frame; databuf_offset = frame_size * frame;
if (UNSET != top_offset) if (UNSET != top_offset)
{ {
fifo_enable = (frame == 0) ? FIFO_ENABLE : FIFO_DISABLE; fifo_enable = (frame == 0) ? FIFO_ENABLE : FIFO_DISABLE;
rp = cx25821_risc_field_upstream_ch2(dev, rp, dev->_data_buf_phys_addr_ch2 + databuf_offset, top_offset, 0, bpl, odd_num_lines, fifo_enable, ODD_FIELD); rp = cx25821_risc_field_upstream_ch2(dev, rp, dev->_data_buf_phys_addr_ch2 + databuf_offset, top_offset, 0, bpl, odd_num_lines, fifo_enable, ODD_FIELD);
} }
fifo_enable = FIFO_DISABLE; fifo_enable = FIFO_DISABLE;
//Even field //Even field
rp = cx25821_risc_field_upstream_ch2(dev, rp, dev->_data_buf_phys_addr_ch2 + databuf_offset, bottom_offset, 0x200, bpl, singlefield_lines, fifo_enable, EVEN_FIELD); rp = cx25821_risc_field_upstream_ch2(dev, rp, dev->_data_buf_phys_addr_ch2 + databuf_offset, bottom_offset, 0x200, bpl, singlefield_lines, fifo_enable, EVEN_FIELD);
if( frame == 0 ) if( frame == 0 )
{ {
risc_flag = RISC_CNT_RESET; risc_flag = RISC_CNT_RESET;
risc_phys_jump_addr = dev->_dma_phys_start_addr_ch2 + risc_program_size; risc_phys_jump_addr = dev->_dma_phys_start_addr_ch2 + risc_program_size;
} }
else else
{ {
risc_flag = RISC_CNT_INC; risc_flag = RISC_CNT_INC;
risc_phys_jump_addr = dev->_dma_phys_start_addr_ch2; risc_phys_jump_addr = dev->_dma_phys_start_addr_ch2;
} }
// Loop to 2ndFrameRISC or to Start of Risc program & generate IRQ // Loop to 2ndFrameRISC or to Start of Risc program & generate IRQ
*(rp++) = cpu_to_le32(RISC_JUMP|RISC_IRQ1|risc_flag); *(rp++) = cpu_to_le32(RISC_JUMP|RISC_IRQ1|risc_flag);
*(rp++) = cpu_to_le32(risc_phys_jump_addr); *(rp++) = cpu_to_le32(risc_phys_jump_addr);
*(rp++) = cpu_to_le32(0); *(rp++) = cpu_to_le32(0);
} }
return 0; return 0;
@ -212,8 +212,8 @@ void cx25821_stop_upstream_video_ch2(struct cx25821_dev *dev)
if( !dev->_is_running_ch2 ) if( !dev->_is_running_ch2 )
{ {
printk("cx25821: No video file is currently running so return!\n"); printk("cx25821: No video file is currently running so return!\n");
return; return;
} }
//Disable RISC interrupts //Disable RISC interrupts
@ -226,8 +226,8 @@ void cx25821_stop_upstream_video_ch2(struct cx25821_dev *dev)
//Clear data buffer memory //Clear data buffer memory
if( dev->_data_buf_virt_addr_ch2 ) if( dev->_data_buf_virt_addr_ch2 )
memset( dev->_data_buf_virt_addr_ch2, 0, dev->_data_buf_size_ch2 ); memset( dev->_data_buf_virt_addr_ch2, 0, dev->_data_buf_size_ch2 );
dev->_is_running_ch2 = 0; dev->_is_running_ch2 = 0;
dev->_is_first_frame_ch2 = 0; dev->_is_first_frame_ch2 = 0;
dev->_frame_count_ch2 = 0; dev->_frame_count_ch2 = 0;
@ -235,12 +235,12 @@ void cx25821_stop_upstream_video_ch2(struct cx25821_dev *dev)
if( dev->_irq_queues_ch2 ) if( dev->_irq_queues_ch2 )
{ {
kfree(dev->_irq_queues_ch2); kfree(dev->_irq_queues_ch2);
dev->_irq_queues_ch2 = NULL; dev->_irq_queues_ch2 = NULL;
} }
if( dev->_filename_ch2 != NULL ) if( dev->_filename_ch2 != NULL )
kfree(dev->_filename_ch2); kfree(dev->_filename_ch2);
tmp = cx_read( VID_CH_MODE_SEL ); tmp = cx_read( VID_CH_MODE_SEL );
cx_write( VID_CH_MODE_SEL, tmp & 0xFFFFFE00); cx_write( VID_CH_MODE_SEL, tmp & 0xFFFFFE00);
@ -250,19 +250,19 @@ void cx25821_free_mem_upstream_ch2(struct cx25821_dev *dev)
{ {
if( dev->_is_running_ch2 ) if( dev->_is_running_ch2 )
{ {
cx25821_stop_upstream_video_ch2(dev); cx25821_stop_upstream_video_ch2(dev);
} }
if (dev->_dma_virt_addr_ch2) if (dev->_dma_virt_addr_ch2)
{ {
pci_free_consistent(dev->pci, dev->_risc_size_ch2, dev->_dma_virt_addr_ch2, dev->_dma_phys_addr_ch2); pci_free_consistent(dev->pci, dev->_risc_size_ch2, dev->_dma_virt_addr_ch2, dev->_dma_phys_addr_ch2);
dev->_dma_virt_addr_ch2 = NULL; dev->_dma_virt_addr_ch2 = NULL;
} }
if (dev->_data_buf_virt_addr_ch2) if (dev->_data_buf_virt_addr_ch2)
{ {
pci_free_consistent(dev->pci, dev->_data_buf_size_ch2, dev->_data_buf_virt_addr_ch2, dev->_data_buf_phys_addr_ch2); pci_free_consistent(dev->pci, dev->_data_buf_size_ch2, dev->_data_buf_virt_addr_ch2, dev->_data_buf_phys_addr_ch2);
dev->_data_buf_virt_addr_ch2 = NULL; dev->_data_buf_virt_addr_ch2 = NULL;
} }
} }
@ -280,84 +280,84 @@ int cx25821_get_frame_ch2(struct cx25821_dev *dev, struct sram_channel *sram_ch
loff_t file_offset; loff_t file_offset;
loff_t pos; loff_t pos;
mm_segment_t old_fs; mm_segment_t old_fs;
if( dev->_file_status_ch2 == END_OF_FILE ) if( dev->_file_status_ch2 == END_OF_FILE )
return 0; return 0;
if( dev->_isNTSC_ch2 ) if( dev->_isNTSC_ch2 )
{ {
frame_size = (line_size == Y411_LINE_SZ) ? FRAME_SIZE_NTSC_Y411 : FRAME_SIZE_NTSC_Y422; frame_size = (line_size == Y411_LINE_SZ) ? FRAME_SIZE_NTSC_Y411 : FRAME_SIZE_NTSC_Y422;
} }
else else
{ {
frame_size = (line_size == Y411_LINE_SZ) ? FRAME_SIZE_PAL_Y411 : FRAME_SIZE_PAL_Y422; frame_size = (line_size == Y411_LINE_SZ) ? FRAME_SIZE_PAL_Y411 : FRAME_SIZE_PAL_Y422;
} }
frame_offset = (frame_index_temp > 0) ? frame_size : 0; frame_offset = (frame_index_temp > 0) ? frame_size : 0;
file_offset = dev->_frame_count_ch2 * frame_size; file_offset = dev->_frame_count_ch2 * frame_size;
myfile = filp_open( dev->_filename_ch2, O_RDONLY | O_LARGEFILE, 0 ); myfile = filp_open( dev->_filename_ch2, O_RDONLY | O_LARGEFILE, 0 );
if (IS_ERR(myfile)) if (IS_ERR(myfile))
{ {
const int open_errno = -PTR_ERR(myfile); const int open_errno = -PTR_ERR(myfile);
printk("%s(): ERROR opening file(%s) with errno = %d! \n", __func__, dev->_filename_ch2, open_errno); printk("%s(): ERROR opening file(%s) with errno = %d! \n", __func__, dev->_filename_ch2, open_errno);
return PTR_ERR(myfile); return PTR_ERR(myfile);
} }
else else
{ {
if( !(myfile->f_op) ) if( !(myfile->f_op) )
{ {
printk("%s: File has no file operations registered!", __func__); printk("%s: File has no file operations registered!", __func__);
filp_close(myfile, NULL); filp_close(myfile, NULL);
return -EIO; return -EIO;
} }
if( !myfile->f_op->read ) if( !myfile->f_op->read )
{ {
printk("%s: File has no READ operations registered!", __func__); printk("%s: File has no READ operations registered!", __func__);
filp_close(myfile, NULL); filp_close(myfile, NULL);
return -EIO; return -EIO;
} }
pos = myfile->f_pos; pos = myfile->f_pos;
old_fs = get_fs(); old_fs = get_fs();
set_fs(KERNEL_DS); set_fs(KERNEL_DS);
for( i = 0; i < dev->_lines_count_ch2; i++ ) for( i = 0; i < dev->_lines_count_ch2; i++ )
{ {
pos = file_offset; pos = file_offset;
vfs_read_retval = vfs_read(myfile, mybuf, line_size, &pos); vfs_read_retval = vfs_read(myfile, mybuf, line_size, &pos);
if( vfs_read_retval > 0 && vfs_read_retval == line_size && dev->_data_buf_virt_addr_ch2 != NULL ) if( vfs_read_retval > 0 && vfs_read_retval == line_size && dev->_data_buf_virt_addr_ch2 != NULL )
{ {
memcpy( (void*)(dev->_data_buf_virt_addr_ch2+frame_offset/4), mybuf, vfs_read_retval); memcpy( (void*)(dev->_data_buf_virt_addr_ch2+frame_offset/4), mybuf, vfs_read_retval);
} }
file_offset += vfs_read_retval; file_offset += vfs_read_retval;
frame_offset += vfs_read_retval; frame_offset += vfs_read_retval;
if( vfs_read_retval < line_size ) if( vfs_read_retval < line_size )
{ {
printk(KERN_INFO "Done: exit %s() since no more bytes to read from Video file.\n", __func__ ); printk(KERN_INFO "Done: exit %s() since no more bytes to read from Video file.\n", __func__ );
break; break;
} }
} }
if( i > 0 ) if( i > 0 )
dev->_frame_count_ch2++; dev->_frame_count_ch2++;
dev->_file_status_ch2 = (vfs_read_retval == line_size) ? IN_PROGRESS : END_OF_FILE; dev->_file_status_ch2 = (vfs_read_retval == line_size) ? IN_PROGRESS : END_OF_FILE;
set_fs(old_fs); set_fs(old_fs);
filp_close(myfile, NULL); filp_close(myfile, NULL);
} }
return 0; return 0;
@ -369,8 +369,8 @@ static void cx25821_vidups_handler_ch2(struct work_struct *work)
if( !dev ) if( !dev )
{ {
printk("ERROR %s(): since container_of(work_struct) FAILED! \n", __func__ ); printk("ERROR %s(): since container_of(work_struct) FAILED! \n", __func__ );
return; return;
} }
cx25821_get_frame_ch2( dev, &dev->sram_channels[dev->_channel2_upstream_select] ); cx25821_get_frame_ch2( dev, &dev->sram_channels[dev->_channel2_upstream_select] );
@ -387,76 +387,76 @@ int cx25821_openfile_ch2(struct cx25821_dev *dev, struct sram_channel *sram_ch)
loff_t pos; loff_t pos;
loff_t offset = (unsigned long)0; loff_t offset = (unsigned long)0;
mm_segment_t old_fs; mm_segment_t old_fs;
myfile = filp_open( dev->_filename_ch2, O_RDONLY | O_LARGEFILE, 0 ); myfile = filp_open( dev->_filename_ch2, O_RDONLY | O_LARGEFILE, 0 );
if (IS_ERR(myfile)) if (IS_ERR(myfile))
{ {
const int open_errno = -PTR_ERR(myfile); const int open_errno = -PTR_ERR(myfile);
printk("%s(): ERROR opening file(%s) with errno = %d! \n", __func__, dev->_filename_ch2, open_errno); printk("%s(): ERROR opening file(%s) with errno = %d! \n", __func__, dev->_filename_ch2, open_errno);
return PTR_ERR(myfile); return PTR_ERR(myfile);
} }
else else
{ {
if( !(myfile->f_op) ) if( !(myfile->f_op) )
{ {
printk("%s: File has no file operations registered!", __func__); printk("%s: File has no file operations registered!", __func__);
filp_close(myfile, NULL); filp_close(myfile, NULL);
return -EIO; return -EIO;
} }
if( !myfile->f_op->read ) if( !myfile->f_op->read )
{ {
printk("%s: File has no READ operations registered! Returning.", __func__); printk("%s: File has no READ operations registered! Returning.", __func__);
filp_close(myfile, NULL); filp_close(myfile, NULL);
return -EIO; return -EIO;
} }
pos = myfile->f_pos; pos = myfile->f_pos;
old_fs = get_fs(); old_fs = get_fs();
set_fs(KERNEL_DS); set_fs(KERNEL_DS);
for( j = 0; j < NUM_FRAMES; j++ ) for( j = 0; j < NUM_FRAMES; j++ )
{ {
for( i = 0; i < dev->_lines_count_ch2; i++ ) for( i = 0; i < dev->_lines_count_ch2; i++ )
{ {
pos = offset; pos = offset;
vfs_read_retval = vfs_read(myfile, mybuf, line_size, &pos); vfs_read_retval = vfs_read(myfile, mybuf, line_size, &pos);
if( vfs_read_retval > 0 && vfs_read_retval == line_size && dev->_data_buf_virt_addr_ch2 != NULL ) if( vfs_read_retval > 0 && vfs_read_retval == line_size && dev->_data_buf_virt_addr_ch2 != NULL )
{ {
memcpy( (void*)(dev->_data_buf_virt_addr_ch2+offset/4), mybuf, vfs_read_retval); memcpy( (void*)(dev->_data_buf_virt_addr_ch2+offset/4), mybuf, vfs_read_retval);
} }
offset += vfs_read_retval; offset += vfs_read_retval;
if( vfs_read_retval < line_size ) if( vfs_read_retval < line_size )
{ {
printk(KERN_INFO "Done: exit %s() since no more bytes to read from Video file.\n", __func__ ); printk(KERN_INFO "Done: exit %s() since no more bytes to read from Video file.\n", __func__ );
break; break;
} }
} }
if( i > 0 ) if( i > 0 )
dev->_frame_count_ch2++; dev->_frame_count_ch2++;
if( vfs_read_retval < line_size ) if( vfs_read_retval < line_size )
{ {
break; break;
} }
} }
dev->_file_status_ch2 = (vfs_read_retval == line_size) ? IN_PROGRESS : END_OF_FILE; dev->_file_status_ch2 = (vfs_read_retval == line_size) ? IN_PROGRESS : END_OF_FILE;
set_fs(old_fs); set_fs(old_fs);
myfile->f_pos = 0; myfile->f_pos = 0;
filp_close(myfile, NULL); filp_close(myfile, NULL);
} }
return 0; return 0;
@ -464,17 +464,17 @@ int cx25821_openfile_ch2(struct cx25821_dev *dev, struct sram_channel *sram_ch)
static int cx25821_upstream_buffer_prepare_ch2(struct cx25821_dev *dev, static int cx25821_upstream_buffer_prepare_ch2(struct cx25821_dev *dev,
struct sram_channel *sram_ch, struct sram_channel *sram_ch,
int bpl) int bpl)
{ {
int ret = 0; int ret = 0;
dma_addr_t dma_addr; dma_addr_t dma_addr;
dma_addr_t data_dma_addr; dma_addr_t data_dma_addr;
if( dev->_dma_virt_addr_ch2 != NULL ) if( dev->_dma_virt_addr_ch2 != NULL )
{ {
pci_free_consistent(dev->pci, dev->upstream_riscbuf_size_ch2, dev->_dma_virt_addr_ch2, dev->_dma_phys_addr_ch2); pci_free_consistent(dev->pci, dev->upstream_riscbuf_size_ch2, dev->_dma_virt_addr_ch2, dev->_dma_phys_addr_ch2);
} }
dev->_dma_virt_addr_ch2 = pci_alloc_consistent(dev->pci, dev->upstream_riscbuf_size_ch2, &dma_addr); dev->_dma_virt_addr_ch2 = pci_alloc_consistent(dev->pci, dev->upstream_riscbuf_size_ch2, &dma_addr);
@ -486,8 +486,8 @@ static int cx25821_upstream_buffer_prepare_ch2(struct cx25821_dev *dev,
if (!dev->_dma_virt_addr_ch2) if (!dev->_dma_virt_addr_ch2)
{ {
printk("cx25821: FAILED to allocate memory for Risc buffer! Returning.\n"); printk("cx25821: FAILED to allocate memory for Risc buffer! Returning.\n");
return -ENOMEM; return -ENOMEM;
} }
@ -497,7 +497,7 @@ static int cx25821_upstream_buffer_prepare_ch2(struct cx25821_dev *dev,
if( dev->_data_buf_virt_addr_ch2 != NULL ) if( dev->_data_buf_virt_addr_ch2 != NULL )
{ {
pci_free_consistent(dev->pci, dev->upstream_databuf_size_ch2, dev->_data_buf_virt_addr_ch2, dev->_data_buf_phys_addr_ch2); pci_free_consistent(dev->pci, dev->upstream_databuf_size_ch2, dev->_data_buf_virt_addr_ch2, dev->_data_buf_phys_addr_ch2);
} }
//For Video Data buffer allocation //For Video Data buffer allocation
@ -507,8 +507,8 @@ static int cx25821_upstream_buffer_prepare_ch2(struct cx25821_dev *dev,
if (!dev->_data_buf_virt_addr_ch2) if (!dev->_data_buf_virt_addr_ch2)
{ {
printk("cx25821: FAILED to allocate memory for data buffer! Returning.\n"); printk("cx25821: FAILED to allocate memory for data buffer! Returning.\n");
return -ENOMEM; return -ENOMEM;
} }
@ -518,15 +518,15 @@ static int cx25821_upstream_buffer_prepare_ch2(struct cx25821_dev *dev,
ret = cx25821_openfile_ch2(dev, sram_ch); ret = cx25821_openfile_ch2(dev, sram_ch);
if( ret < 0 ) if( ret < 0 )
return ret; return ret;
//Creating RISC programs //Creating RISC programs
ret = cx25821_risc_buffer_upstream_ch2(dev, dev->pci, 0, bpl, dev->_lines_count_ch2 ); ret = cx25821_risc_buffer_upstream_ch2(dev, dev->pci, 0, bpl, dev->_lines_count_ch2 );
if (ret < 0) if (ret < 0)
{ {
printk(KERN_INFO "cx25821: Failed creating Video Upstream Risc programs! \n"); printk(KERN_INFO "cx25821: Failed creating Video Upstream Risc programs! \n");
goto error; goto error;
} }
return 0; return 0;
@ -549,59 +549,59 @@ int cx25821_video_upstream_irq_ch2(struct cx25821_dev *dev, int chan_num, u32 st
if (status & FLD_VID_SRC_RISC1) if (status & FLD_VID_SRC_RISC1)
{ {
// We should only process one program per call // We should only process one program per call
u32 prog_cnt = cx_read( channel->gpcnt ); u32 prog_cnt = cx_read( channel->gpcnt );
//Since we've identified our IRQ, clear our bits from the interrupt mask and interrupt status registers //Since we've identified our IRQ, clear our bits from the interrupt mask and interrupt status registers
int_msk_tmp = cx_read(channel->int_msk); int_msk_tmp = cx_read(channel->int_msk);
cx_write(channel->int_msk, int_msk_tmp & ~_intr_msk); cx_write(channel->int_msk, int_msk_tmp & ~_intr_msk);
cx_write( channel->int_stat, _intr_msk ); cx_write( channel->int_stat, _intr_msk );
spin_lock(&dev->slock); spin_lock(&dev->slock);
dev->_frame_index_ch2 = prog_cnt; dev->_frame_index_ch2 = prog_cnt;
queue_work(dev->_irq_queues_ch2, &dev->_irq_work_entry_ch2); queue_work(dev->_irq_queues_ch2, &dev->_irq_work_entry_ch2);
if ( dev->_is_first_frame_ch2 ) if ( dev->_is_first_frame_ch2 )
{ {
dev->_is_first_frame_ch2 = 0; dev->_is_first_frame_ch2 = 0;
if( dev->_isNTSC_ch2 ) if( dev->_isNTSC_ch2 )
{ {
singlefield_lines += 1; singlefield_lines += 1;
odd_risc_prog_size = ODD_FLD_NTSC_PROG_SIZE; odd_risc_prog_size = ODD_FLD_NTSC_PROG_SIZE;
} }
else else
{ {
singlefield_lines = PAL_FIELD_HEIGHT; singlefield_lines = PAL_FIELD_HEIGHT;
odd_risc_prog_size = ODD_FLD_PAL_PROG_SIZE; odd_risc_prog_size = ODD_FLD_PAL_PROG_SIZE;
} }
if( dev->_dma_virt_start_addr_ch2 != NULL ) if( dev->_dma_virt_start_addr_ch2 != NULL )
{ {
line_size_in_bytes = (dev->_pixel_format_ch2 == PIXEL_FRMT_411) ? Y411_LINE_SZ : Y422_LINE_SZ; line_size_in_bytes = (dev->_pixel_format_ch2 == PIXEL_FRMT_411) ? Y411_LINE_SZ : Y422_LINE_SZ;
risc_phys_jump_addr = dev->_dma_phys_start_addr_ch2 + odd_risc_prog_size; risc_phys_jump_addr = dev->_dma_phys_start_addr_ch2 + odd_risc_prog_size;
rp = cx25821_update_riscprogram_ch2(dev, dev->_dma_virt_start_addr_ch2, TOP_OFFSET, line_size_in_bytes, 0x0, singlefield_lines, FIFO_DISABLE, ODD_FIELD); rp = cx25821_update_riscprogram_ch2(dev, dev->_dma_virt_start_addr_ch2, TOP_OFFSET, line_size_in_bytes, 0x0, singlefield_lines, FIFO_DISABLE, ODD_FIELD);
// Jump to Even Risc program of 1st Frame // Jump to Even Risc program of 1st Frame
*(rp++) = cpu_to_le32(RISC_JUMP); *(rp++) = cpu_to_le32(RISC_JUMP);
*(rp++) = cpu_to_le32(risc_phys_jump_addr); *(rp++) = cpu_to_le32(risc_phys_jump_addr);
*(rp++) = cpu_to_le32(0); *(rp++) = cpu_to_le32(0);
} }
} }
spin_unlock(&dev->slock); spin_unlock(&dev->slock);
} }
if( dev->_file_status_ch2 == END_OF_FILE ) if( dev->_file_status_ch2 == END_OF_FILE )
{ {
printk("cx25821: EOF Channel 2 Framecount = %d\n", dev->_frame_count_ch2 ); printk("cx25821: EOF Channel 2 Framecount = %d\n", dev->_frame_count_ch2 );
return -1; return -1;
} }
//ElSE, set the interrupt mask register, re-enable irq. //ElSE, set the interrupt mask register, re-enable irq.
@ -621,10 +621,10 @@ static irqreturn_t cx25821_upstream_irq_ch2(int irq, void *dev_id)
if( !dev ) if( !dev )
return -1; return -1;
channel_num = VID_UPSTREAM_SRAM_CHANNEL_J; channel_num = VID_UPSTREAM_SRAM_CHANNEL_J;
sram_ch = &dev->sram_channels[channel_num]; sram_ch = &dev->sram_channels[channel_num];
msk_stat = cx_read(sram_ch->int_mstat); msk_stat = cx_read(sram_ch->int_mstat);
@ -633,17 +633,17 @@ static irqreturn_t cx25821_upstream_irq_ch2(int irq, void *dev_id)
// Only deal with our interrupt // Only deal with our interrupt
if(vid_status) if(vid_status)
{ {
handled = cx25821_video_upstream_irq_ch2(dev, channel_num, vid_status); handled = cx25821_video_upstream_irq_ch2(dev, channel_num, vid_status);
} }
if( handled < 0 ) if( handled < 0 )
{ {
cx25821_stop_upstream_video_ch2(dev); cx25821_stop_upstream_video_ch2(dev);
} }
else else
{ {
handled += handled; handled += handled;
} }
return IRQ_RETVAL(handled); return IRQ_RETVAL(handled);
@ -658,7 +658,7 @@ static void cx25821_set_pixelengine_ch2(struct cx25821_dev *dev, struct sram_cha
u32 value; u32 value;
int vip_mode = PIXEL_ENGINE_VIP1; int vip_mode = PIXEL_ENGINE_VIP1;
value = ( (pix_format & 0x3) << 12 ) | ( vip_mode & 0x7 ); value = ( (pix_format & 0x3) << 12 ) | ( vip_mode & 0x7 );
value &= 0xFFFFFFEF; value &= 0xFFFFFFEF;
value |= dev->_isNTSC_ch2 ? 0 : 0x10; value |= dev->_isNTSC_ch2 ? 0 : 0x10;
@ -672,7 +672,7 @@ static void cx25821_set_pixelengine_ch2(struct cx25821_dev *dev, struct sram_cha
if(dev->_isNTSC_ch2) if(dev->_isNTSC_ch2)
{ {
odd_num_lines += 1; odd_num_lines += 1;
} }
value = (num_lines << 16) | odd_num_lines; value = (num_lines << 16) | odd_num_lines;
@ -685,7 +685,7 @@ static void cx25821_set_pixelengine_ch2(struct cx25821_dev *dev, struct sram_cha
int cx25821_start_video_dma_upstream_ch2(struct cx25821_dev *dev, int cx25821_start_video_dma_upstream_ch2(struct cx25821_dev *dev,
struct sram_channel *sram_ch) struct sram_channel *sram_ch)
{ {
u32 tmp = 0; u32 tmp = 0;
int err = 0; int err = 0;
@ -716,8 +716,8 @@ int cx25821_start_video_dma_upstream_ch2(struct cx25821_dev *dev,
err = request_irq(dev->pci->irq, cx25821_upstream_irq_ch2, IRQF_SHARED | IRQF_DISABLED, dev->name, dev); err = request_irq(dev->pci->irq, cx25821_upstream_irq_ch2, IRQF_SHARED | IRQF_DISABLED, dev->name, dev);
if (err < 0) if (err < 0)
{ {
printk(KERN_ERR "%s: can't get upstream IRQ %d\n", dev->name, dev->pci->irq); printk(KERN_ERR "%s: can't get upstream IRQ %d\n", dev->name, dev->pci->irq);
goto fail_irq; goto fail_irq;
} }
// Start the DMA engine // Start the DMA engine
@ -748,8 +748,8 @@ int cx25821_vidupstream_init_ch2(struct cx25821_dev *dev, int channel_select, in
if( dev->_is_running_ch2 ) if( dev->_is_running_ch2 )
{ {
printk("Video Channel is still running so return!\n"); printk("Video Channel is still running so return!\n");
return 0; return 0;
} }
dev->_channel2_upstream_select = channel_select; dev->_channel2_upstream_select = channel_select;
@ -761,15 +761,15 @@ int cx25821_vidupstream_init_ch2(struct cx25821_dev *dev, int channel_select, in
if(!dev->_irq_queues_ch2) if(!dev->_irq_queues_ch2)
{ {
printk("cx25821: create_singlethread_workqueue() for Video FAILED!\n"); printk("cx25821: create_singlethread_workqueue() for Video FAILED!\n");
return -ENOMEM; return -ENOMEM;
} }
// 656/VIP SRC Upstream Channel I & J and 7 - Host Bus Interface for channel A-C // 656/VIP SRC Upstream Channel I & J and 7 - Host Bus Interface for channel A-C
tmp = cx_read( VID_CH_MODE_SEL ); tmp = cx_read( VID_CH_MODE_SEL );
cx_write( VID_CH_MODE_SEL, tmp | 0x1B0001FF); cx_write( VID_CH_MODE_SEL, tmp | 0x1B0001FF);
dev->_is_running_ch2 = 0; dev->_is_running_ch2 = 0;
dev->_frame_count_ch2 = 0; dev->_frame_count_ch2 = 0;
dev->_file_status_ch2 = RESET_STATUS; dev->_file_status_ch2 = RESET_STATUS;
@ -779,43 +779,43 @@ int cx25821_vidupstream_init_ch2(struct cx25821_dev *dev, int channel_select, in
data_frame_size = dev->_isNTSC_ch2 ? NTSC_DATA_BUF_SZ : PAL_DATA_BUF_SZ; data_frame_size = dev->_isNTSC_ch2 ? NTSC_DATA_BUF_SZ : PAL_DATA_BUF_SZ;
risc_buffer_size = dev->_isNTSC_ch2 ? NTSC_RISC_BUF_SIZE : PAL_RISC_BUF_SIZE; risc_buffer_size = dev->_isNTSC_ch2 ? NTSC_RISC_BUF_SIZE : PAL_RISC_BUF_SIZE;
if( dev->input_filename_ch2 ) if( dev->input_filename_ch2 )
{ {
str_length = strlen(dev->input_filename_ch2); str_length = strlen(dev->input_filename_ch2);
dev->_filename_ch2 = (char *) kmalloc(str_length + 1, GFP_KERNEL); dev->_filename_ch2 = (char *) kmalloc(str_length + 1, GFP_KERNEL);
if( !dev->_filename_ch2 ) if( !dev->_filename_ch2 )
goto error; goto error;
memcpy(dev->_filename_ch2, dev->input_filename_ch2, str_length + 1); memcpy(dev->_filename_ch2, dev->input_filename_ch2, str_length + 1);
} }
else else
{ {
str_length = strlen(dev->_defaultname_ch2); str_length = strlen(dev->_defaultname_ch2);
dev->_filename_ch2 = (char *) kmalloc(str_length + 1, GFP_KERNEL); dev->_filename_ch2 = (char *) kmalloc(str_length + 1, GFP_KERNEL);
if( !dev->_filename_ch2 ) if( !dev->_filename_ch2 )
goto error; goto error;
memcpy(dev->_filename_ch2, dev->_defaultname_ch2, str_length + 1); memcpy(dev->_filename_ch2, dev->_defaultname_ch2, str_length + 1);
} }
//Default if filename is empty string //Default if filename is empty string
if( strcmp(dev->input_filename_ch2,"") == 0) if( strcmp(dev->input_filename_ch2,"") == 0)
{ {
if( dev->_isNTSC_ch2 ) if( dev->_isNTSC_ch2 )
{ {
dev->_filename_ch2 = (dev->_pixel_format_ch2 == PIXEL_FRMT_411) ? "/root/vid411.yuv" : "/root/vidtest.yuv"; dev->_filename_ch2 = (dev->_pixel_format_ch2 == PIXEL_FRMT_411) ? "/root/vid411.yuv" : "/root/vidtest.yuv";
} }
else else
{ {
dev->_filename_ch2 = (dev->_pixel_format_ch2 == PIXEL_FRMT_411) ? "/root/pal411.yuv" : "/root/pal422.yuv"; dev->_filename_ch2 = (dev->_pixel_format_ch2 == PIXEL_FRMT_411) ? "/root/pal411.yuv" : "/root/pal422.yuv";
} }
} }
retval = cx25821_sram_channel_setup_upstream(dev, sram_ch, dev->_line_size_ch2, 0); retval = cx25821_sram_channel_setup_upstream(dev, sram_ch, dev->_line_size_ch2, 0);
@ -830,8 +830,8 @@ int cx25821_vidupstream_init_ch2(struct cx25821_dev *dev, int channel_select, in
retval = cx25821_upstream_buffer_prepare_ch2(dev, sram_ch, dev->_line_size_ch2); retval = cx25821_upstream_buffer_prepare_ch2(dev, sram_ch, dev->_line_size_ch2);
if (retval < 0) if (retval < 0)
{ {
printk(KERN_ERR "%s: Failed to set up Video upstream buffers!\n", dev->name); printk(KERN_ERR "%s: Failed to set up Video upstream buffers!\n", dev->name);
goto error; goto error;
} }

20
drivers/staging/cx25821/cx25821-video-upstream-ch2.h
View file

@ -71,25 +71,25 @@
#ifdef USE_RISC_NOOP_VIDEO #ifdef USE_RISC_NOOP_VIDEO
#define PAL_US_VID_PROG_SIZE ((PAL_FIELD_HEIGHT) * 3 * DWORD_SIZE + RISC_WRITECR_INSTRUCTION_SIZE + \ #define PAL_US_VID_PROG_SIZE ((PAL_FIELD_HEIGHT) * 3 * DWORD_SIZE + RISC_WRITECR_INSTRUCTION_SIZE + \
RISC_SYNC_INSTRUCTION_SIZE + NUM_NO_OPS*DWORD_SIZE) RISC_SYNC_INSTRUCTION_SIZE + NUM_NO_OPS*DWORD_SIZE)
#define PAL_RISC_BUF_SIZE (2 * PAL_US_VID_PROG_SIZE) #define PAL_RISC_BUF_SIZE (2 * PAL_US_VID_PROG_SIZE)
#define PAL_VID_PROG_SIZE ((PAL_FIELD_HEIGHT*2) * 3 * DWORD_SIZE + 2*RISC_SYNC_INSTRUCTION_SIZE + \ #define PAL_VID_PROG_SIZE ((PAL_FIELD_HEIGHT*2) * 3 * DWORD_SIZE + 2*RISC_SYNC_INSTRUCTION_SIZE + \
RISC_WRITECR_INSTRUCTION_SIZE + JUMP_INSTRUCTION_SIZE + 2*NUM_NO_OPS*DWORD_SIZE) RISC_WRITECR_INSTRUCTION_SIZE + JUMP_INSTRUCTION_SIZE + 2*NUM_NO_OPS*DWORD_SIZE)
#define ODD_FLD_PAL_PROG_SIZE ((PAL_FIELD_HEIGHT) * 3 * DWORD_SIZE + RISC_SYNC_INSTRUCTION_SIZE + \ #define ODD_FLD_PAL_PROG_SIZE ((PAL_FIELD_HEIGHT) * 3 * DWORD_SIZE + RISC_SYNC_INSTRUCTION_SIZE + \
RISC_WRITECR_INSTRUCTION_SIZE + NUM_NO_OPS*DWORD_SIZE) RISC_WRITECR_INSTRUCTION_SIZE + NUM_NO_OPS*DWORD_SIZE)
#define NTSC_US_VID_PROG_SIZE ((NTSC_ODD_FLD_LINES + 1) * 3 * DWORD_SIZE + RISC_WRITECR_INSTRUCTION_SIZE + \ #define NTSC_US_VID_PROG_SIZE ((NTSC_ODD_FLD_LINES + 1) * 3 * DWORD_SIZE + RISC_WRITECR_INSTRUCTION_SIZE + \
JUMP_INSTRUCTION_SIZE + NUM_NO_OPS*DWORD_SIZE) JUMP_INSTRUCTION_SIZE + NUM_NO_OPS*DWORD_SIZE)
#define NTSC_RISC_BUF_SIZE (2 * (RISC_SYNC_INSTRUCTION_SIZE + NTSC_US_VID_PROG_SIZE)) #define NTSC_RISC_BUF_SIZE (2 * (RISC_SYNC_INSTRUCTION_SIZE + NTSC_US_VID_PROG_SIZE))
#define FRAME1_VID_PROG_SIZE ((NTSC_ODD_FLD_LINES + NTSC_FIELD_HEIGHT) * 3 * DWORD_SIZE + 2*RISC_SYNC_INSTRUCTION_SIZE + \ #define FRAME1_VID_PROG_SIZE ((NTSC_ODD_FLD_LINES + NTSC_FIELD_HEIGHT) * 3 * DWORD_SIZE + 2*RISC_SYNC_INSTRUCTION_SIZE + \
RISC_WRITECR_INSTRUCTION_SIZE + JUMP_INSTRUCTION_SIZE + 2*NUM_NO_OPS*DWORD_SIZE) RISC_WRITECR_INSTRUCTION_SIZE + JUMP_INSTRUCTION_SIZE + 2*NUM_NO_OPS*DWORD_SIZE)
#define ODD_FLD_NTSC_PROG_SIZE ((NTSC_ODD_FLD_LINES) * 3 * DWORD_SIZE + RISC_SYNC_INSTRUCTION_SIZE + \ #define ODD_FLD_NTSC_PROG_SIZE ((NTSC_ODD_FLD_LINES) * 3 * DWORD_SIZE + RISC_SYNC_INSTRUCTION_SIZE + \
RISC_WRITECR_INSTRUCTION_SIZE + NUM_NO_OPS*DWORD_SIZE) RISC_WRITECR_INSTRUCTION_SIZE + NUM_NO_OPS*DWORD_SIZE)
#endif #endif
@ -97,11 +97,11 @@
#define PAL_US_VID_PROG_SIZE ((PAL_FIELD_HEIGHT + 1) * 3 * DWORD_SIZE + RISC_WRITECR_INSTRUCTION_SIZE ) #define PAL_US_VID_PROG_SIZE ((PAL_FIELD_HEIGHT + 1) * 3 * DWORD_SIZE + RISC_WRITECR_INSTRUCTION_SIZE )
#define PAL_RISC_BUF_SIZE ( 2 * (RISC_SYNC_INSTRUCTION_SIZE + PAL_US_VID_PROG_SIZE) ) #define PAL_RISC_BUF_SIZE ( 2 * (RISC_SYNC_INSTRUCTION_SIZE + PAL_US_VID_PROG_SIZE) )
#define PAL_VID_PROG_SIZE ((PAL_FIELD_HEIGHT*2) * 3 * DWORD_SIZE + 2*RISC_SYNC_INSTRUCTION_SIZE + \ #define PAL_VID_PROG_SIZE ((PAL_FIELD_HEIGHT*2) * 3 * DWORD_SIZE + 2*RISC_SYNC_INSTRUCTION_SIZE + \
RISC_WRITECR_INSTRUCTION_SIZE + JUMP_INSTRUCTION_SIZE ) RISC_WRITECR_INSTRUCTION_SIZE + JUMP_INSTRUCTION_SIZE )
#define ODD_FLD_PAL_PROG_SIZE ((PAL_FIELD_HEIGHT) * 3 * DWORD_SIZE + RISC_SYNC_INSTRUCTION_SIZE + RISC_WRITECR_INSTRUCTION_SIZE ) #define ODD_FLD_PAL_PROG_SIZE ((PAL_FIELD_HEIGHT) * 3 * DWORD_SIZE + RISC_SYNC_INSTRUCTION_SIZE + RISC_WRITECR_INSTRUCTION_SIZE )
#define ODD_FLD_NTSC_PROG_SIZE ((NTSC_ODD_FLD_LINES) * 3 * DWORD_SIZE + RISC_SYNC_INSTRUCTION_SIZE + RISC_WRITECR_INSTRUCTION_SIZE ) #define ODD_FLD_NTSC_PROG_SIZE ((NTSC_ODD_FLD_LINES) * 3 * DWORD_SIZE + RISC_SYNC_INSTRUCTION_SIZE + RISC_WRITECR_INSTRUCTION_SIZE )
#define NTSC_US_VID_PROG_SIZE ((NTSC_ODD_FLD_LINES + 1) * 3 * DWORD_SIZE + RISC_WRITECR_INSTRUCTION_SIZE + JUMP_INSTRUCTION_SIZE) #define NTSC_US_VID_PROG_SIZE ((NTSC_ODD_FLD_LINES + 1) * 3 * DWORD_SIZE + RISC_WRITECR_INSTRUCTION_SIZE + JUMP_INSTRUCTION_SIZE)
#define NTSC_RISC_BUF_SIZE (2 * (RISC_SYNC_INSTRUCTION_SIZE + NTSC_US_VID_PROG_SIZE) ) #define NTSC_RISC_BUF_SIZE (2 * (RISC_SYNC_INSTRUCTION_SIZE + NTSC_US_VID_PROG_SIZE) )
#define FRAME1_VID_PROG_SIZE ((NTSC_ODD_FLD_LINES + NTSC_FIELD_HEIGHT) * 3 * DWORD_SIZE + 2*RISC_SYNC_INSTRUCTION_SIZE + \ #define FRAME1_VID_PROG_SIZE ((NTSC_ODD_FLD_LINES + NTSC_FIELD_HEIGHT) * 3 * DWORD_SIZE + 2*RISC_SYNC_INSTRUCTION_SIZE + \
RISC_WRITECR_INSTRUCTION_SIZE + JUMP_INSTRUCTION_SIZE ) RISC_WRITECR_INSTRUCTION_SIZE + JUMP_INSTRUCTION_SIZE )
#endif #endif

656
drivers/staging/cx25821/cx25821-video-upstream.c
View file

@ -43,19 +43,19 @@ MODULE_LICENSE("GPL");
static int _intr_msk = FLD_VID_SRC_RISC1 | FLD_VID_SRC_UF | FLD_VID_SRC_SYNC | FLD_VID_SRC_OPC_ERR; static int _intr_msk = FLD_VID_SRC_RISC1 | FLD_VID_SRC_UF | FLD_VID_SRC_SYNC | FLD_VID_SRC_OPC_ERR;
int cx25821_sram_channel_setup_upstream(struct cx25821_dev *dev, int cx25821_sram_channel_setup_upstream(struct cx25821_dev *dev,
struct sram_channel *ch, struct sram_channel *ch,
unsigned int bpl, u32 risc) unsigned int bpl, u32 risc)
{ {
unsigned int i, lines; unsigned int i, lines;
u32 cdt; u32 cdt;
if (ch->cmds_start == 0) { if (ch->cmds_start == 0) {
cx_write(ch->ptr1_reg, 0); cx_write(ch->ptr1_reg, 0);
cx_write(ch->ptr2_reg, 0); cx_write(ch->ptr2_reg, 0);
cx_write(ch->cnt2_reg, 0); cx_write(ch->cnt2_reg, 0);
cx_write(ch->cnt1_reg, 0); cx_write(ch->cnt1_reg, 0);
return 0; return 0;
} }
bpl = (bpl + 7) & ~7; /* alignment */ bpl = (bpl + 7) & ~7; /* alignment */
@ -64,7 +64,7 @@ int cx25821_sram_channel_setup_upstream(struct cx25821_dev *dev,
if (lines > 4) if (lines > 4)
{ {
lines = 4; lines = 4;
} }
BUG_ON(lines < 2); BUG_ON(lines < 2);
@ -72,10 +72,10 @@ int cx25821_sram_channel_setup_upstream(struct cx25821_dev *dev,
/* write CDT */ /* write CDT */
for (i = 0; i < lines; i++) { for (i = 0; i < lines; i++) {
cx_write(cdt + 16*i, ch->fifo_start + bpl*i); cx_write(cdt + 16*i, ch->fifo_start + bpl*i);
cx_write(cdt + 16*i + 4, 0); cx_write(cdt + 16*i + 4, 0);
cx_write(cdt + 16*i + 8, 0); cx_write(cdt + 16*i + 8, 0);
cx_write(cdt + 16*i + 12, 0); cx_write(cdt + 16*i + 12, 0);
} }
/* write CMDS */ /* write CMDS */
@ -85,12 +85,12 @@ int cx25821_sram_channel_setup_upstream(struct cx25821_dev *dev,
cx_write(ch->cmds_start + 8, cdt); cx_write(ch->cmds_start + 8, cdt);
cx_write(ch->cmds_start + 12, (lines*16) >> 3); cx_write(ch->cmds_start + 12, (lines*16) >> 3);
cx_write(ch->cmds_start + 16, ch->ctrl_start); cx_write(ch->cmds_start + 16, ch->ctrl_start);
cx_write(ch->cmds_start + 20, VID_IQ_SIZE_DW); cx_write(ch->cmds_start + 20, VID_IQ_SIZE_DW);
for (i = 24; i < 80; i += 4) for (i = 24; i < 80; i += 4)
cx_write(ch->cmds_start + i, 0); cx_write(ch->cmds_start + i, 0);
/* fill registers */ /* fill registers */
cx_write(ch->ptr1_reg, ch->fifo_start); cx_write(ch->ptr1_reg, ch->fifo_start);
@ -102,8 +102,8 @@ int cx25821_sram_channel_setup_upstream(struct cx25821_dev *dev,
} }
static __le32 *cx25821_update_riscprogram( struct cx25821_dev *dev, static __le32 *cx25821_update_riscprogram( struct cx25821_dev *dev,
__le32 *rp, unsigned int offset, unsigned int bpl, __le32 *rp, unsigned int offset, unsigned int bpl,
u32 sync_line, unsigned int lines, int fifo_enable, int field_type) u32 sync_line, unsigned int lines, int fifo_enable, int field_type)
{ {
unsigned int line, i; unsigned int line, i;
int dist_betwn_starts = bpl * 2; int dist_betwn_starts = bpl * 2;
@ -114,85 +114,85 @@ static __le32 *cx25821_update_riscprogram( struct cx25821_dev *dev,
if( USE_RISC_NOOP_VIDEO ) if( USE_RISC_NOOP_VIDEO )
{ {
for( i = 0; i < NUM_NO_OPS; i++ ) for( i = 0; i < NUM_NO_OPS; i++ )
{ {
*(rp++) = cpu_to_le32(RISC_NOOP); *(rp++) = cpu_to_le32(RISC_NOOP);
} }
} }
/* scan lines */ /* scan lines */
for (line = 0; line < lines; line++) for (line = 0; line < lines; line++)
{ {
*(rp++) = cpu_to_le32(RISC_READ|RISC_SOL|RISC_EOL|bpl); *(rp++) = cpu_to_le32(RISC_READ|RISC_SOL|RISC_EOL|bpl);
*(rp++) = cpu_to_le32(dev->_data_buf_phys_addr+offset); *(rp++) = cpu_to_le32(dev->_data_buf_phys_addr+offset);
*(rp++) = cpu_to_le32(0); /* bits 63-32 */ *(rp++) = cpu_to_le32(0); /* bits 63-32 */
if ( (lines <= NTSC_FIELD_HEIGHT) || (line < (NTSC_FIELD_HEIGHT-1)) || !(dev->_isNTSC) ) if ( (lines <= NTSC_FIELD_HEIGHT) || (line < (NTSC_FIELD_HEIGHT-1)) || !(dev->_isNTSC) )
{ {
offset += dist_betwn_starts; offset += dist_betwn_starts;
} }
} }
return rp; return rp;
} }
static __le32 *cx25821_risc_field_upstream( struct cx25821_dev *dev, __le32 *rp, static __le32 *cx25821_risc_field_upstream( struct cx25821_dev *dev, __le32 *rp,
dma_addr_t databuf_phys_addr, dma_addr_t databuf_phys_addr,
unsigned int offset, u32 sync_line, unsigned int offset, u32 sync_line,
unsigned int bpl, unsigned int lines, int fifo_enable, int field_type) unsigned int bpl, unsigned int lines, int fifo_enable, int field_type)
{ {
unsigned int line, i; unsigned int line, i;
struct sram_channel *sram_ch = &dev->sram_channels[dev->_channel_upstream_select]; struct sram_channel *sram_ch = &dev->sram_channels[dev->_channel_upstream_select];
int dist_betwn_starts = bpl * 2; int dist_betwn_starts = bpl * 2;
/* sync instruction */ /* sync instruction */
if (sync_line != NO_SYNC_LINE) if (sync_line != NO_SYNC_LINE)
{ {
*(rp++) = cpu_to_le32(RISC_RESYNC | sync_line); *(rp++) = cpu_to_le32(RISC_RESYNC | sync_line);
} }
if( USE_RISC_NOOP_VIDEO ) if( USE_RISC_NOOP_VIDEO )
{ {
for( i = 0; i < NUM_NO_OPS; i++ ) for( i = 0; i < NUM_NO_OPS; i++ )
{ {
*(rp++) = cpu_to_le32(RISC_NOOP); *(rp++) = cpu_to_le32(RISC_NOOP);
} }
} }
/* scan lines */ /* scan lines */
for (line = 0; line < lines; line++) for (line = 0; line < lines; line++)
{ {
*(rp++) = cpu_to_le32(RISC_READ|RISC_SOL|RISC_EOL|bpl); *(rp++) = cpu_to_le32(RISC_READ|RISC_SOL|RISC_EOL|bpl);
*(rp++) = cpu_to_le32(databuf_phys_addr+offset); *(rp++) = cpu_to_le32(databuf_phys_addr+offset);
*(rp++) = cpu_to_le32(0); /* bits 63-32 */ *(rp++) = cpu_to_le32(0); /* bits 63-32 */
if ( (lines <= NTSC_FIELD_HEIGHT) || (line < (NTSC_FIELD_HEIGHT-1)) || !(dev->_isNTSC) ) if ( (lines <= NTSC_FIELD_HEIGHT) || (line < (NTSC_FIELD_HEIGHT-1)) || !(dev->_isNTSC) )
{ {
offset += dist_betwn_starts; //to skip the other field line offset += dist_betwn_starts; //to skip the other field line
} }
// check if we need to enable the FIFO after the first 4 lines // check if we need to enable the FIFO after the first 4 lines
// For the upstream video channel, the risc engine will enable the FIFO. // For the upstream video channel, the risc engine will enable the FIFO.
if ( fifo_enable && line == 3 ) if ( fifo_enable && line == 3 )
{ {
*(rp++) = RISC_WRITECR; *(rp++) = RISC_WRITECR;
*(rp++) = sram_ch->dma_ctl; *(rp++) = sram_ch->dma_ctl;
*(rp++) = FLD_VID_FIFO_EN; *(rp++) = FLD_VID_FIFO_EN;
*(rp++) = 0x00000001; *(rp++) = 0x00000001;
} }
} }
return rp; return rp;
} }
int cx25821_risc_buffer_upstream( struct cx25821_dev *dev, int cx25821_risc_buffer_upstream( struct cx25821_dev *dev,
struct pci_dev *pci, struct pci_dev *pci,
unsigned int top_offset, unsigned int top_offset,
unsigned int bpl, unsigned int lines) unsigned int bpl, unsigned int lines)
{ {
__le32 *rp; __le32 *rp;
int fifo_enable = 0; int fifo_enable = 0;
@ -205,57 +205,57 @@ int cx25821_risc_buffer_upstream( struct cx25821_dev *dev,
int risc_flag = RISC_CNT_RESET; int risc_flag = RISC_CNT_RESET;
unsigned int bottom_offset = bpl; unsigned int bottom_offset = bpl;
dma_addr_t risc_phys_jump_addr; dma_addr_t risc_phys_jump_addr;
if( dev->_isNTSC ) if( dev->_isNTSC )
{ {
odd_num_lines = singlefield_lines + 1; odd_num_lines = singlefield_lines + 1;
risc_program_size = FRAME1_VID_PROG_SIZE; risc_program_size = FRAME1_VID_PROG_SIZE;
frame_size = (bpl == Y411_LINE_SZ) ? FRAME_SIZE_NTSC_Y411 : FRAME_SIZE_NTSC_Y422; frame_size = (bpl == Y411_LINE_SZ) ? FRAME_SIZE_NTSC_Y411 : FRAME_SIZE_NTSC_Y422;
} }
else else
{ {
risc_program_size = PAL_VID_PROG_SIZE; risc_program_size = PAL_VID_PROG_SIZE;
frame_size = (bpl == Y411_LINE_SZ) ? FRAME_SIZE_PAL_Y411 : FRAME_SIZE_PAL_Y422; frame_size = (bpl == Y411_LINE_SZ) ? FRAME_SIZE_PAL_Y411 : FRAME_SIZE_PAL_Y422;
} }
/* Virtual address of Risc buffer program */ /* Virtual address of Risc buffer program */
rp = dev->_dma_virt_addr; rp = dev->_dma_virt_addr;
for( frame = 0; frame < NUM_FRAMES; frame++ ) for( frame = 0; frame < NUM_FRAMES; frame++ )
{ {
databuf_offset = frame_size * frame; databuf_offset = frame_size * frame;
if (UNSET != top_offset) if (UNSET != top_offset)
{ {
fifo_enable = (frame == 0) ? FIFO_ENABLE : FIFO_DISABLE; fifo_enable = (frame == 0) ? FIFO_ENABLE : FIFO_DISABLE;
rp = cx25821_risc_field_upstream(dev, rp, dev->_data_buf_phys_addr+databuf_offset, top_offset, 0, bpl, odd_num_lines, fifo_enable, ODD_FIELD); rp = cx25821_risc_field_upstream(dev, rp, dev->_data_buf_phys_addr+databuf_offset, top_offset, 0, bpl, odd_num_lines, fifo_enable, ODD_FIELD);
} }
fifo_enable = FIFO_DISABLE; fifo_enable = FIFO_DISABLE;
//Even Field //Even Field
rp = cx25821_risc_field_upstream(dev, rp, dev->_data_buf_phys_addr+databuf_offset, bottom_offset, 0x200, bpl, singlefield_lines, fifo_enable, EVEN_FIELD); rp = cx25821_risc_field_upstream(dev, rp, dev->_data_buf_phys_addr+databuf_offset, bottom_offset, 0x200, bpl, singlefield_lines, fifo_enable, EVEN_FIELD);
if( frame == 0 ) if( frame == 0 )
{ {
risc_flag = RISC_CNT_RESET; risc_flag = RISC_CNT_RESET;
risc_phys_jump_addr = dev->_dma_phys_start_addr + risc_program_size; risc_phys_jump_addr = dev->_dma_phys_start_addr + risc_program_size;
} }
else else
{ {
risc_phys_jump_addr = dev->_dma_phys_start_addr; risc_phys_jump_addr = dev->_dma_phys_start_addr;
risc_flag = RISC_CNT_INC; risc_flag = RISC_CNT_INC;
} }
// Loop to 2ndFrameRISC or to Start of Risc program & generate IRQ // Loop to 2ndFrameRISC or to Start of Risc program & generate IRQ
*(rp++) = cpu_to_le32(RISC_JUMP|RISC_IRQ1|risc_flag); *(rp++) = cpu_to_le32(RISC_JUMP|RISC_IRQ1|risc_flag);
*(rp++) = cpu_to_le32(risc_phys_jump_addr); *(rp++) = cpu_to_le32(risc_phys_jump_addr);
*(rp++) = cpu_to_le32(0); *(rp++) = cpu_to_le32(0);
} }
return 0; return 0;
@ -269,10 +269,10 @@ void cx25821_stop_upstream_video_ch1(struct cx25821_dev *dev)
if( !dev->_is_running ) if( !dev->_is_running )
{ {
printk("cx25821: No video file is currently running so return!\n"); printk("cx25821: No video file is currently running so return!\n");
return; return;
} }
//Disable RISC interrupts //Disable RISC interrupts
tmp = cx_read( sram_ch->int_msk ); tmp = cx_read( sram_ch->int_msk );
cx_write( sram_ch->int_msk, tmp & ~_intr_msk); cx_write( sram_ch->int_msk, tmp & ~_intr_msk);
@ -283,8 +283,8 @@ void cx25821_stop_upstream_video_ch1(struct cx25821_dev *dev)
//Clear data buffer memory //Clear data buffer memory
if( dev->_data_buf_virt_addr ) if( dev->_data_buf_virt_addr )
memset( dev->_data_buf_virt_addr, 0, dev->_data_buf_size ); memset( dev->_data_buf_virt_addr, 0, dev->_data_buf_size );
dev->_is_running = 0; dev->_is_running = 0;
dev->_is_first_frame = 0; dev->_is_first_frame = 0;
dev->_frame_count = 0; dev->_frame_count = 0;
@ -292,12 +292,12 @@ void cx25821_stop_upstream_video_ch1(struct cx25821_dev *dev)
if( dev->_irq_queues ) if( dev->_irq_queues )
{ {
kfree(dev->_irq_queues); kfree(dev->_irq_queues);
dev->_irq_queues = NULL; dev->_irq_queues = NULL;
} }
if( dev->_filename != NULL ) if( dev->_filename != NULL )
kfree(dev->_filename); kfree(dev->_filename);
tmp = cx_read( VID_CH_MODE_SEL ); tmp = cx_read( VID_CH_MODE_SEL );
cx_write( VID_CH_MODE_SEL, tmp & 0xFFFFFE00); cx_write( VID_CH_MODE_SEL, tmp & 0xFFFFFE00);
@ -307,19 +307,19 @@ void cx25821_free_mem_upstream_ch1(struct cx25821_dev *dev)
{ {
if( dev->_is_running ) if( dev->_is_running )
{ {
cx25821_stop_upstream_video_ch1(dev); cx25821_stop_upstream_video_ch1(dev);
} }
if (dev->_dma_virt_addr) if (dev->_dma_virt_addr)
{ {
pci_free_consistent(dev->pci, dev->_risc_size, dev->_dma_virt_addr, dev->_dma_phys_addr); pci_free_consistent(dev->pci, dev->_risc_size, dev->_dma_virt_addr, dev->_dma_phys_addr);
dev->_dma_virt_addr = NULL; dev->_dma_virt_addr = NULL;
} }
if (dev->_data_buf_virt_addr) if (dev->_data_buf_virt_addr)
{ {
pci_free_consistent(dev->pci, dev->_data_buf_size, dev->_data_buf_virt_addr, dev->_data_buf_phys_addr); pci_free_consistent(dev->pci, dev->_data_buf_size, dev->_data_buf_virt_addr, dev->_data_buf_phys_addr);
dev->_data_buf_virt_addr = NULL; dev->_data_buf_virt_addr = NULL;
} }
} }
@ -337,84 +337,84 @@ int cx25821_get_frame(struct cx25821_dev *dev, struct sram_channel *sram_ch )
loff_t file_offset; loff_t file_offset;
loff_t pos; loff_t pos;
mm_segment_t old_fs; mm_segment_t old_fs;
if( dev->_file_status == END_OF_FILE ) if( dev->_file_status == END_OF_FILE )
return 0; return 0;
if( dev->_isNTSC ) if( dev->_isNTSC )
{ {
frame_size = (line_size == Y411_LINE_SZ) ? FRAME_SIZE_NTSC_Y411 : FRAME_SIZE_NTSC_Y422; frame_size = (line_size == Y411_LINE_SZ) ? FRAME_SIZE_NTSC_Y411 : FRAME_SIZE_NTSC_Y422;
} }
else else
{ {
frame_size = (line_size == Y411_LINE_SZ) ? FRAME_SIZE_PAL_Y411 : FRAME_SIZE_PAL_Y422; frame_size = (line_size == Y411_LINE_SZ) ? FRAME_SIZE_PAL_Y411 : FRAME_SIZE_PAL_Y422;
} }
frame_offset = (frame_index_temp > 0) ? frame_size : 0; frame_offset = (frame_index_temp > 0) ? frame_size : 0;
file_offset = dev->_frame_count * frame_size; file_offset = dev->_frame_count * frame_size;
myfile = filp_open( dev->_filename, O_RDONLY | O_LARGEFILE, 0 ); myfile = filp_open( dev->_filename, O_RDONLY | O_LARGEFILE, 0 );
if (IS_ERR(myfile)) if (IS_ERR(myfile))
{ {
const int open_errno = -PTR_ERR(myfile); const int open_errno = -PTR_ERR(myfile);
printk("%s(): ERROR opening file(%s) with errno = %d! \n", __func__, dev->_filename, open_errno); printk("%s(): ERROR opening file(%s) with errno = %d! \n", __func__, dev->_filename, open_errno);
return PTR_ERR(myfile); return PTR_ERR(myfile);
} }
else else
{ {
if( !(myfile->f_op) ) if( !(myfile->f_op) )
{ {
printk("%s: File has no file operations registered!", __func__); printk("%s: File has no file operations registered!", __func__);
filp_close(myfile, NULL); filp_close(myfile, NULL);
return -EIO; return -EIO;
} }
if( !myfile->f_op->read ) if( !myfile->f_op->read )
{ {
printk("%s: File has no READ operations registered!", __func__); printk("%s: File has no READ operations registered!", __func__);
filp_close(myfile, NULL); filp_close(myfile, NULL);
return -EIO; return -EIO;
} }
pos = myfile->f_pos; pos = myfile->f_pos;
old_fs = get_fs(); old_fs = get_fs();
set_fs(KERNEL_DS); set_fs(KERNEL_DS);
for( i = 0; i < dev->_lines_count; i++ ) for( i = 0; i < dev->_lines_count; i++ )
{ {
pos = file_offset; pos = file_offset;
vfs_read_retval = vfs_read(myfile, mybuf, line_size, &pos); vfs_read_retval = vfs_read(myfile, mybuf, line_size, &pos);
if( vfs_read_retval > 0 && vfs_read_retval == line_size && dev->_data_buf_virt_addr != NULL ) if( vfs_read_retval > 0 && vfs_read_retval == line_size && dev->_data_buf_virt_addr != NULL )
{ {
memcpy( (void*)(dev->_data_buf_virt_addr+frame_offset/4), mybuf, vfs_read_retval); memcpy( (void*)(dev->_data_buf_virt_addr+frame_offset/4), mybuf, vfs_read_retval);
} }
file_offset += vfs_read_retval; file_offset += vfs_read_retval;
frame_offset += vfs_read_retval; frame_offset += vfs_read_retval;
if( vfs_read_retval < line_size ) if( vfs_read_retval < line_size )
{ {
printk(KERN_INFO "Done: exit %s() since no more bytes to read from Video file.\n", __func__ ); printk(KERN_INFO "Done: exit %s() since no more bytes to read from Video file.\n", __func__ );
break; break;
} }
} }
if( i > 0 ) if( i > 0 )
dev->_frame_count++; dev->_frame_count++;
dev->_file_status = (vfs_read_retval == line_size) ? IN_PROGRESS : END_OF_FILE; dev->_file_status = (vfs_read_retval == line_size) ? IN_PROGRESS : END_OF_FILE;
set_fs(old_fs); set_fs(old_fs);
filp_close(myfile, NULL); filp_close(myfile, NULL);
} }
return 0; return 0;
@ -426,8 +426,8 @@ static void cx25821_vidups_handler(struct work_struct *work)
if( !dev ) if( !dev )
{ {
printk("ERROR %s(): since container_of(work_struct) FAILED! \n", __func__ ); printk("ERROR %s(): since container_of(work_struct) FAILED! \n", __func__ );
return; return;
} }
cx25821_get_frame( dev, &dev->sram_channels[dev->_channel_upstream_select] ); cx25821_get_frame( dev, &dev->sram_channels[dev->_channel_upstream_select] );
@ -444,77 +444,77 @@ int cx25821_openfile(struct cx25821_dev *dev, struct sram_channel *sram_ch)
loff_t pos; loff_t pos;
loff_t offset = (unsigned long)0; loff_t offset = (unsigned long)0;
mm_segment_t old_fs; mm_segment_t old_fs;
myfile = filp_open( dev->_filename, O_RDONLY | O_LARGEFILE, 0 ); myfile = filp_open( dev->_filename, O_RDONLY | O_LARGEFILE, 0 );
if (IS_ERR(myfile)) if (IS_ERR(myfile))
{ {
const int open_errno = -PTR_ERR(myfile); const int open_errno = -PTR_ERR(myfile);
printk("%s(): ERROR opening file(%s) with errno = %d! \n", __func__, dev->_filename, open_errno); printk("%s(): ERROR opening file(%s) with errno = %d! \n", __func__, dev->_filename, open_errno);
return PTR_ERR(myfile); return PTR_ERR(myfile);
} }
else else
{ {
if( !(myfile->f_op) ) if( !(myfile->f_op) )
{ {
printk("%s: File has no file operations registered!", __func__); printk("%s: File has no file operations registered!", __func__);
filp_close(myfile, NULL); filp_close(myfile, NULL);
return -EIO; return -EIO;
} }
if( !myfile->f_op->read ) if( !myfile->f_op->read )
{ {
printk("%s: File has no READ operations registered! Returning.", __func__); printk("%s: File has no READ operations registered! Returning.", __func__);
filp_close(myfile, NULL); filp_close(myfile, NULL);
return -EIO; return -EIO;
} }
pos = myfile->f_pos; pos = myfile->f_pos;
old_fs = get_fs(); old_fs = get_fs();
set_fs(KERNEL_DS); set_fs(KERNEL_DS);
for( j = 0; j < NUM_FRAMES; j++ ) for( j = 0; j < NUM_FRAMES; j++ )
{ {
for( i = 0; i < dev->_lines_count; i++ ) for( i = 0; i < dev->_lines_count; i++ )
{ {
pos = offset; pos = offset;
vfs_read_retval = vfs_read(myfile, mybuf, line_size, &pos); vfs_read_retval = vfs_read(myfile, mybuf, line_size, &pos);
if( vfs_read_retval > 0 && vfs_read_retval == line_size && dev->_data_buf_virt_addr != NULL ) if( vfs_read_retval > 0 && vfs_read_retval == line_size && dev->_data_buf_virt_addr != NULL )
{ {
memcpy( (void*)(dev->_data_buf_virt_addr+offset/4), mybuf, vfs_read_retval); memcpy( (void*)(dev->_data_buf_virt_addr+offset/4), mybuf, vfs_read_retval);
} }
offset += vfs_read_retval; offset += vfs_read_retval;
if( vfs_read_retval < line_size ) if( vfs_read_retval < line_size )
{ {
printk(KERN_INFO "Done: exit %s() since no more bytes to read from Video file.\n", __func__ ); printk(KERN_INFO "Done: exit %s() since no more bytes to read from Video file.\n", __func__ );
break; break;
} }
} }
if( i > 0 ) if( i > 0 )
dev->_frame_count++; dev->_frame_count++;
if( vfs_read_retval < line_size ) if( vfs_read_retval < line_size )
{ {
break; break;
} }
} }
dev->_file_status = (vfs_read_retval == line_size) ? IN_PROGRESS : END_OF_FILE; dev->_file_status = (vfs_read_retval == line_size) ? IN_PROGRESS : END_OF_FILE;
set_fs(old_fs); set_fs(old_fs);
myfile->f_pos = 0; myfile->f_pos = 0;
filp_close(myfile, NULL); filp_close(myfile, NULL);
} }
return 0; return 0;
@ -522,8 +522,8 @@ int cx25821_openfile(struct cx25821_dev *dev, struct sram_channel *sram_ch)
int cx25821_upstream_buffer_prepare(struct cx25821_dev *dev, int cx25821_upstream_buffer_prepare(struct cx25821_dev *dev,
struct sram_channel *sram_ch, struct sram_channel *sram_ch,
int bpl) int bpl)
{ {
int ret = 0; int ret = 0;
dma_addr_t dma_addr; dma_addr_t dma_addr;
@ -531,7 +531,7 @@ int cx25821_upstream_buffer_prepare(struct cx25821_dev *dev,
if( dev->_dma_virt_addr != NULL ) if( dev->_dma_virt_addr != NULL )
{ {
pci_free_consistent(dev->pci, dev->upstream_riscbuf_size, dev->_dma_virt_addr, dev->_dma_phys_addr); pci_free_consistent(dev->pci, dev->upstream_riscbuf_size, dev->_dma_virt_addr, dev->_dma_phys_addr);
} }
@ -544,8 +544,8 @@ int cx25821_upstream_buffer_prepare(struct cx25821_dev *dev,
if (!dev->_dma_virt_addr) if (!dev->_dma_virt_addr)
{ {
printk("cx25821: FAILED to allocate memory for Risc buffer! Returning.\n"); printk("cx25821: FAILED to allocate memory for Risc buffer! Returning.\n");
return -ENOMEM; return -ENOMEM;
} }
@ -555,7 +555,7 @@ int cx25821_upstream_buffer_prepare(struct cx25821_dev *dev,
if( dev->_data_buf_virt_addr != NULL ) if( dev->_data_buf_virt_addr != NULL )
{ {
pci_free_consistent(dev->pci, dev->upstream_databuf_size, dev->_data_buf_virt_addr, dev->_data_buf_phys_addr); pci_free_consistent(dev->pci, dev->upstream_databuf_size, dev->_data_buf_virt_addr, dev->_data_buf_phys_addr);
} }
//For Video Data buffer allocation //For Video Data buffer allocation
@ -565,8 +565,8 @@ int cx25821_upstream_buffer_prepare(struct cx25821_dev *dev,
if (!dev->_data_buf_virt_addr) if (!dev->_data_buf_virt_addr)
{ {
printk("cx25821: FAILED to allocate memory for data buffer! Returning.\n"); printk("cx25821: FAILED to allocate memory for data buffer! Returning.\n");
return -ENOMEM; return -ENOMEM;
} }
@ -576,15 +576,15 @@ int cx25821_upstream_buffer_prepare(struct cx25821_dev *dev,
ret = cx25821_openfile(dev, sram_ch); ret = cx25821_openfile(dev, sram_ch);
if( ret < 0 ) if( ret < 0 )
return ret; return ret;
//Create RISC programs //Create RISC programs
ret = cx25821_risc_buffer_upstream(dev, dev->pci, 0, bpl, dev->_lines_count ); ret = cx25821_risc_buffer_upstream(dev, dev->pci, 0, bpl, dev->_lines_count );
if (ret < 0) if (ret < 0)
{ {
printk(KERN_INFO "cx25821: Failed creating Video Upstream Risc programs! \n"); printk(KERN_INFO "cx25821: Failed creating Video Upstream Risc programs! \n");
goto error; goto error;
} }
return 0; return 0;
@ -607,70 +607,70 @@ int cx25821_video_upstream_irq(struct cx25821_dev *dev, int chan_num, u32 status
if (status & FLD_VID_SRC_RISC1) if (status & FLD_VID_SRC_RISC1)
{ {
// We should only process one program per call // We should only process one program per call
u32 prog_cnt = cx_read( channel->gpcnt ); u32 prog_cnt = cx_read( channel->gpcnt );
//Since we've identified our IRQ, clear our bits from the interrupt mask and interrupt status registers //Since we've identified our IRQ, clear our bits from the interrupt mask and interrupt status registers
int_msk_tmp = cx_read(channel->int_msk); int_msk_tmp = cx_read(channel->int_msk);
cx_write(channel->int_msk, int_msk_tmp & ~_intr_msk); cx_write(channel->int_msk, int_msk_tmp & ~_intr_msk);
cx_write( channel->int_stat, _intr_msk ); cx_write( channel->int_stat, _intr_msk );
spin_lock(&dev->slock); spin_lock(&dev->slock);
dev->_frame_index = prog_cnt; dev->_frame_index = prog_cnt;
queue_work(dev->_irq_queues, &dev->_irq_work_entry); queue_work(dev->_irq_queues, &dev->_irq_work_entry);
if ( dev->_is_first_frame ) if ( dev->_is_first_frame )
{ {
dev->_is_first_frame = 0; dev->_is_first_frame = 0;
if( dev->_isNTSC ) if( dev->_isNTSC )
{ {
singlefield_lines += 1; singlefield_lines += 1;
odd_risc_prog_size = ODD_FLD_NTSC_PROG_SIZE; odd_risc_prog_size = ODD_FLD_NTSC_PROG_SIZE;
} }
else else
{ {
singlefield_lines = PAL_FIELD_HEIGHT; singlefield_lines = PAL_FIELD_HEIGHT;
odd_risc_prog_size = ODD_FLD_PAL_PROG_SIZE; odd_risc_prog_size = ODD_FLD_PAL_PROG_SIZE;
} }
if( dev->_dma_virt_start_addr != NULL ) if( dev->_dma_virt_start_addr != NULL )
{ {
line_size_in_bytes = (dev->_pixel_format == PIXEL_FRMT_411) ? Y411_LINE_SZ : Y422_LINE_SZ; line_size_in_bytes = (dev->_pixel_format == PIXEL_FRMT_411) ? Y411_LINE_SZ : Y422_LINE_SZ;
risc_phys_jump_addr = dev->_dma_phys_start_addr + odd_risc_prog_size; risc_phys_jump_addr = dev->_dma_phys_start_addr + odd_risc_prog_size;
rp = cx25821_update_riscprogram(dev, dev->_dma_virt_start_addr, TOP_OFFSET, line_size_in_bytes, 0x0, singlefield_lines, FIFO_DISABLE, ODD_FIELD); rp = cx25821_update_riscprogram(dev, dev->_dma_virt_start_addr, TOP_OFFSET, line_size_in_bytes, 0x0, singlefield_lines, FIFO_DISABLE, ODD_FIELD);
// Jump to Even Risc program of 1st Frame // Jump to Even Risc program of 1st Frame
*(rp++) = cpu_to_le32(RISC_JUMP); *(rp++) = cpu_to_le32(RISC_JUMP);
*(rp++) = cpu_to_le32(risc_phys_jump_addr); *(rp++) = cpu_to_le32(risc_phys_jump_addr);
*(rp++) = cpu_to_le32(0); *(rp++) = cpu_to_le32(0);
} }
} }
spin_unlock(&dev->slock); spin_unlock(&dev->slock);
} }
else else
{ {
if(status & FLD_VID_SRC_UF) if(status & FLD_VID_SRC_UF)
printk("%s: Video Received Underflow Error Interrupt!\n", __func__); printk("%s: Video Received Underflow Error Interrupt!\n", __func__);
if(status & FLD_VID_SRC_SYNC) if(status & FLD_VID_SRC_SYNC)
printk("%s: Video Received Sync Error Interrupt!\n", __func__); printk("%s: Video Received Sync Error Interrupt!\n", __func__);
if(status & FLD_VID_SRC_OPC_ERR) if(status & FLD_VID_SRC_OPC_ERR)
printk("%s: Video Received OpCode Error Interrupt!\n", __func__); printk("%s: Video Received OpCode Error Interrupt!\n", __func__);
} }
if( dev->_file_status == END_OF_FILE ) if( dev->_file_status == END_OF_FILE )
{ {
printk("cx25821: EOF Channel 1 Framecount = %d\n", dev->_frame_count ); printk("cx25821: EOF Channel 1 Framecount = %d\n", dev->_frame_count );
return -1; return -1;
} }
//ElSE, set the interrupt mask register, re-enable irq. //ElSE, set the interrupt mask register, re-enable irq.
@ -690,8 +690,8 @@ static irqreturn_t cx25821_upstream_irq(int irq, void *dev_id)
if( !dev ) if( !dev )
return -1; return -1;
channel_num = VID_UPSTREAM_SRAM_CHANNEL_I; channel_num = VID_UPSTREAM_SRAM_CHANNEL_I;
sram_ch = &dev->sram_channels[channel_num]; sram_ch = &dev->sram_channels[channel_num];
@ -702,16 +702,16 @@ static irqreturn_t cx25821_upstream_irq(int irq, void *dev_id)
// Only deal with our interrupt // Only deal with our interrupt
if(vid_status) if(vid_status)
{ {
handled = cx25821_video_upstream_irq(dev, channel_num, vid_status); handled = cx25821_video_upstream_irq(dev, channel_num, vid_status);
} }
if( handled < 0 ) if( handled < 0 )
{ {
cx25821_stop_upstream_video_ch1(dev); cx25821_stop_upstream_video_ch1(dev);
} }
else else
{ {
handled += handled; handled += handled;
} }
return IRQ_RETVAL(handled); return IRQ_RETVAL(handled);
@ -725,7 +725,7 @@ void cx25821_set_pixelengine(struct cx25821_dev *dev, struct sram_channel *ch, i
int num_lines, odd_num_lines; int num_lines, odd_num_lines;
u32 value; u32 value;
int vip_mode = OUTPUT_FRMT_656; int vip_mode = OUTPUT_FRMT_656;
value = ( (pix_format & 0x3) << 12 ) | ( vip_mode & 0x7 ); value = ( (pix_format & 0x3) << 12 ) | ( vip_mode & 0x7 );
value &= 0xFFFFFFEF; value &= 0xFFFFFFEF;
@ -741,7 +741,7 @@ void cx25821_set_pixelengine(struct cx25821_dev *dev, struct sram_channel *ch, i
if(dev->_isNTSC) if(dev->_isNTSC)
{ {
odd_num_lines += 1; odd_num_lines += 1;
} }
value = (num_lines << 16) | odd_num_lines; value = (num_lines << 16) | odd_num_lines;
@ -754,7 +754,7 @@ void cx25821_set_pixelengine(struct cx25821_dev *dev, struct sram_channel *ch, i
int cx25821_start_video_dma_upstream(struct cx25821_dev *dev, int cx25821_start_video_dma_upstream(struct cx25821_dev *dev,
struct sram_channel *sram_ch) struct sram_channel *sram_ch)
{ {
u32 tmp = 0; u32 tmp = 0;
int err = 0; int err = 0;
@ -785,8 +785,8 @@ int cx25821_start_video_dma_upstream(struct cx25821_dev *dev,
err = request_irq(dev->pci->irq, cx25821_upstream_irq, IRQF_SHARED | IRQF_DISABLED, dev->name, dev); err = request_irq(dev->pci->irq, cx25821_upstream_irq, IRQF_SHARED | IRQF_DISABLED, dev->name, dev);
if (err < 0) if (err < 0)
{ {
printk(KERN_ERR "%s: can't get upstream IRQ %d\n", dev->name, dev->pci->irq); printk(KERN_ERR "%s: can't get upstream IRQ %d\n", dev->name, dev->pci->irq);
goto fail_irq; goto fail_irq;
} }
@ -818,8 +818,8 @@ int cx25821_vidupstream_init_ch1(struct cx25821_dev *dev, int channel_select, in
if( dev->_is_running ) if( dev->_is_running )
{ {
printk("Video Channel is still running so return!\n"); printk("Video Channel is still running so return!\n");
return 0; return 0;
} }
@ -832,15 +832,15 @@ int cx25821_vidupstream_init_ch1(struct cx25821_dev *dev, int channel_select, in
if(!dev->_irq_queues) if(!dev->_irq_queues)
{ {
printk("cx25821: create_singlethread_workqueue() for Video FAILED!\n"); printk("cx25821: create_singlethread_workqueue() for Video FAILED!\n");
return -ENOMEM; return -ENOMEM;
} }
// 656/VIP SRC Upstream Channel I & J and 7 - Host Bus Interface for channel A-C // 656/VIP SRC Upstream Channel I & J and 7 - Host Bus Interface for channel A-C
tmp = cx_read( VID_CH_MODE_SEL ); tmp = cx_read( VID_CH_MODE_SEL );
cx_write( VID_CH_MODE_SEL, tmp | 0x1B0001FF); cx_write( VID_CH_MODE_SEL, tmp | 0x1B0001FF);
dev->_is_running = 0; dev->_is_running = 0;
dev->_frame_count = 0; dev->_frame_count = 0;
dev->_file_status = RESET_STATUS; dev->_file_status = RESET_STATUS;
@ -850,40 +850,40 @@ int cx25821_vidupstream_init_ch1(struct cx25821_dev *dev, int channel_select, in
data_frame_size = dev->_isNTSC ? NTSC_DATA_BUF_SZ : PAL_DATA_BUF_SZ; data_frame_size = dev->_isNTSC ? NTSC_DATA_BUF_SZ : PAL_DATA_BUF_SZ;
risc_buffer_size = dev->_isNTSC ? NTSC_RISC_BUF_SIZE : PAL_RISC_BUF_SIZE; risc_buffer_size = dev->_isNTSC ? NTSC_RISC_BUF_SIZE : PAL_RISC_BUF_SIZE;
if( dev->input_filename ) if( dev->input_filename )
{ {
str_length = strlen(dev->input_filename); str_length = strlen(dev->input_filename);
dev->_filename = (char *) kmalloc(str_length + 1, GFP_KERNEL); dev->_filename = (char *) kmalloc(str_length + 1, GFP_KERNEL);
if( !dev->_filename ) if( !dev->_filename )
goto error; goto error;
memcpy(dev->_filename, dev->input_filename, str_length + 1); memcpy(dev->_filename, dev->input_filename, str_length + 1);
} }
else else
{ {
str_length = strlen(dev->_defaultname); str_length = strlen(dev->_defaultname);
dev->_filename = (char *) kmalloc(str_length + 1, GFP_KERNEL); dev->_filename = (char *) kmalloc(str_length + 1, GFP_KERNEL);
if( !dev->_filename ) if( !dev->_filename )
goto error; goto error;
memcpy(dev->_filename, dev->_defaultname, str_length + 1); memcpy(dev->_filename, dev->_defaultname, str_length + 1);
} }
//Default if filename is empty string //Default if filename is empty string
if( strcmp(dev->input_filename,"") == 0) if( strcmp(dev->input_filename,"") == 0)
{ {
if( dev->_isNTSC ) if( dev->_isNTSC )
{ {
dev->_filename = (dev->_pixel_format == PIXEL_FRMT_411) ? "/root/vid411.yuv" : "/root/vidtest.yuv"; dev->_filename = (dev->_pixel_format == PIXEL_FRMT_411) ? "/root/vid411.yuv" : "/root/vidtest.yuv";
} }
else else
{ {
dev->_filename = (dev->_pixel_format == PIXEL_FRMT_411) ? "/root/pal411.yuv" : "/root/pal422.yuv"; dev->_filename = (dev->_pixel_format == PIXEL_FRMT_411) ? "/root/pal411.yuv" : "/root/pal422.yuv";
} }
} }
dev->_is_running = 0; dev->_is_running = 0;
@ -906,8 +906,8 @@ int cx25821_vidupstream_init_ch1(struct cx25821_dev *dev, int channel_select, in
retval = cx25821_upstream_buffer_prepare(dev, sram_ch, dev->_line_size); retval = cx25821_upstream_buffer_prepare(dev, sram_ch, dev->_line_size);
if (retval < 0) if (retval < 0)
{ {
printk(KERN_ERR "%s: Failed to set up Video upstream buffers!\n", dev->name); printk(KERN_ERR "%s: Failed to set up Video upstream buffers!\n", dev->name);
goto error; goto error;
} }

30
drivers/staging/cx25821/cx25821-video-upstream.h
View file

@ -70,38 +70,38 @@
#ifdef USE_RISC_NOOP_VIDEO #ifdef USE_RISC_NOOP_VIDEO
#define PAL_US_VID_PROG_SIZE ((PAL_FIELD_HEIGHT) * 3 * DWORD_SIZE + RISC_WRITECR_INSTRUCTION_SIZE + \ #define PAL_US_VID_PROG_SIZE ((PAL_FIELD_HEIGHT) * 3 * DWORD_SIZE + RISC_WRITECR_INSTRUCTION_SIZE + \
RISC_SYNC_INSTRUCTION_SIZE + NUM_NO_OPS*DWORD_SIZE) RISC_SYNC_INSTRUCTION_SIZE + NUM_NO_OPS*DWORD_SIZE)
#define PAL_RISC_BUF_SIZE (2 * PAL_US_VID_PROG_SIZE) #define PAL_RISC_BUF_SIZE (2 * PAL_US_VID_PROG_SIZE)
#define PAL_VID_PROG_SIZE ((PAL_FIELD_HEIGHT*2) * 3 * DWORD_SIZE + 2*RISC_SYNC_INSTRUCTION_SIZE + \ #define PAL_VID_PROG_SIZE ((PAL_FIELD_HEIGHT*2) * 3 * DWORD_SIZE + 2*RISC_SYNC_INSTRUCTION_SIZE + \
RISC_WRITECR_INSTRUCTION_SIZE + JUMP_INSTRUCTION_SIZE + 2*NUM_NO_OPS*DWORD_SIZE) RISC_WRITECR_INSTRUCTION_SIZE + JUMP_INSTRUCTION_SIZE + 2*NUM_NO_OPS*DWORD_SIZE)
#define ODD_FLD_PAL_PROG_SIZE ((PAL_FIELD_HEIGHT) * 3 * DWORD_SIZE + RISC_SYNC_INSTRUCTION_SIZE + \ #define ODD_FLD_PAL_PROG_SIZE ((PAL_FIELD_HEIGHT) * 3 * DWORD_SIZE + RISC_SYNC_INSTRUCTION_SIZE + \
RISC_WRITECR_INSTRUCTION_SIZE + NUM_NO_OPS*DWORD_SIZE) RISC_WRITECR_INSTRUCTION_SIZE + NUM_NO_OPS*DWORD_SIZE)
#define ODD_FLD_NTSC_PROG_SIZE ((NTSC_ODD_FLD_LINES) * 3 * DWORD_SIZE + RISC_SYNC_INSTRUCTION_SIZE + \ #define ODD_FLD_NTSC_PROG_SIZE ((NTSC_ODD_FLD_LINES) * 3 * DWORD_SIZE + RISC_SYNC_INSTRUCTION_SIZE + \
RISC_WRITECR_INSTRUCTION_SIZE + NUM_NO_OPS*DWORD_SIZE) RISC_WRITECR_INSTRUCTION_SIZE + NUM_NO_OPS*DWORD_SIZE)
#define NTSC_US_VID_PROG_SIZE ((NTSC_ODD_FLD_LINES + 1) * 3 * DWORD_SIZE + RISC_WRITECR_INSTRUCTION_SIZE + \ #define NTSC_US_VID_PROG_SIZE ((NTSC_ODD_FLD_LINES + 1) * 3 * DWORD_SIZE + RISC_WRITECR_INSTRUCTION_SIZE + \
JUMP_INSTRUCTION_SIZE + NUM_NO_OPS*DWORD_SIZE) JUMP_INSTRUCTION_SIZE + NUM_NO_OPS*DWORD_SIZE)
#define NTSC_RISC_BUF_SIZE (2 * (RISC_SYNC_INSTRUCTION_SIZE + NTSC_US_VID_PROG_SIZE)) #define NTSC_RISC_BUF_SIZE (2 * (RISC_SYNC_INSTRUCTION_SIZE + NTSC_US_VID_PROG_SIZE))
#define FRAME1_VID_PROG_SIZE ((NTSC_ODD_FLD_LINES + NTSC_FIELD_HEIGHT) * 3 * DWORD_SIZE + 2*RISC_SYNC_INSTRUCTION_SIZE + \ #define FRAME1_VID_PROG_SIZE ((NTSC_ODD_FLD_LINES + NTSC_FIELD_HEIGHT) * 3 * DWORD_SIZE + 2*RISC_SYNC_INSTRUCTION_SIZE + \
RISC_WRITECR_INSTRUCTION_SIZE + JUMP_INSTRUCTION_SIZE + 2*NUM_NO_OPS*DWORD_SIZE) RISC_WRITECR_INSTRUCTION_SIZE + JUMP_INSTRUCTION_SIZE + 2*NUM_NO_OPS*DWORD_SIZE)
#endif #endif
#ifndef USE_RISC_NOOP_VIDEO #ifndef USE_RISC_NOOP_VIDEO
#define PAL_US_VID_PROG_SIZE ((PAL_FIELD_HEIGHT) * 3 * DWORD_SIZE + RISC_WRITECR_INSTRUCTION_SIZE + \ #define PAL_US_VID_PROG_SIZE ((PAL_FIELD_HEIGHT) * 3 * DWORD_SIZE + RISC_WRITECR_INSTRUCTION_SIZE + \
RISC_SYNC_INSTRUCTION_SIZE + JUMP_INSTRUCTION_SIZE) RISC_SYNC_INSTRUCTION_SIZE + JUMP_INSTRUCTION_SIZE)
#define PAL_RISC_BUF_SIZE (2 * PAL_US_VID_PROG_SIZE) #define PAL_RISC_BUF_SIZE (2 * PAL_US_VID_PROG_SIZE)
#define PAL_VID_PROG_SIZE ((PAL_FIELD_HEIGHT*2) * 3 * DWORD_SIZE + 2*RISC_SYNC_INSTRUCTION_SIZE + \ #define PAL_VID_PROG_SIZE ((PAL_FIELD_HEIGHT*2) * 3 * DWORD_SIZE + 2*RISC_SYNC_INSTRUCTION_SIZE + \
RISC_WRITECR_INSTRUCTION_SIZE + JUMP_INSTRUCTION_SIZE ) RISC_WRITECR_INSTRUCTION_SIZE + JUMP_INSTRUCTION_SIZE )
#define ODD_FLD_PAL_PROG_SIZE ((PAL_FIELD_HEIGHT) * 3 * DWORD_SIZE + RISC_SYNC_INSTRUCTION_SIZE + RISC_WRITECR_INSTRUCTION_SIZE ) #define ODD_FLD_PAL_PROG_SIZE ((PAL_FIELD_HEIGHT) * 3 * DWORD_SIZE + RISC_SYNC_INSTRUCTION_SIZE + RISC_WRITECR_INSTRUCTION_SIZE )
#define ODD_FLD_NTSC_PROG_SIZE ((NTSC_ODD_FLD_LINES) * 3 * DWORD_SIZE + RISC_SYNC_INSTRUCTION_SIZE + RISC_WRITECR_INSTRUCTION_SIZE ) #define ODD_FLD_NTSC_PROG_SIZE ((NTSC_ODD_FLD_LINES) * 3 * DWORD_SIZE + RISC_SYNC_INSTRUCTION_SIZE + RISC_WRITECR_INSTRUCTION_SIZE )
@ -109,5 +109,5 @@
#define NTSC_US_VID_PROG_SIZE ((NTSC_ODD_FLD_LINES + 1) * 3 * DWORD_SIZE + RISC_WRITECR_INSTRUCTION_SIZE + JUMP_INSTRUCTION_SIZE) #define NTSC_US_VID_PROG_SIZE ((NTSC_ODD_FLD_LINES + 1) * 3 * DWORD_SIZE + RISC_WRITECR_INSTRUCTION_SIZE + JUMP_INSTRUCTION_SIZE)
#define NTSC_RISC_BUF_SIZE ( 2 * (RISC_SYNC_INSTRUCTION_SIZE + NTSC_US_VID_PROG_SIZE) ) #define NTSC_RISC_BUF_SIZE ( 2 * (RISC_SYNC_INSTRUCTION_SIZE + NTSC_US_VID_PROG_SIZE) )
#define FRAME1_VID_PROG_SIZE ((NTSC_ODD_FLD_LINES + NTSC_FIELD_HEIGHT) * 3 * DWORD_SIZE + 2*RISC_SYNC_INSTRUCTION_SIZE + \ #define FRAME1_VID_PROG_SIZE ((NTSC_ODD_FLD_LINES + NTSC_FIELD_HEIGHT) * 3 * DWORD_SIZE + 2*RISC_SYNC_INSTRUCTION_SIZE + \
RISC_WRITECR_INSTRUCTION_SIZE + JUMP_INSTRUCTION_SIZE ) RISC_WRITECR_INSTRUCTION_SIZE + JUMP_INSTRUCTION_SIZE )
#endif #endif

684
drivers/staging/cx25821/cx25821-video.c
View file

File diff suppressed because it is too large Load diff

10
drivers/staging/cx25821/cx25821-video.h
View file

@ -1,7 +1,7 @@
/* /*
* Driver for the Conexant CX25821 PCIe bridge * Driver for the Conexant CX25821 PCIe bridge
* *
* Copyright (C) 2009 Conexant Systems Inc. * Copyright (C) 2009 Conexant Systems Inc.
* Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com> * Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com>
* Based on Steven Toth <stoth@linuxtv.org> cx23885 driver * Based on Steven Toth <stoth@linuxtv.org> cx23885 driver
* *
@ -52,7 +52,7 @@
#define dprintk(level, fmt, arg...)\ #define dprintk(level, fmt, arg...)\
do { if (VIDEO_DEBUG >= level)\ do { if (VIDEO_DEBUG >= level)\
printk(KERN_DEBUG "%s/0: " fmt, dev->name, ## arg);\ printk(KERN_DEBUG "%s/0: " fmt, dev->name, ## arg);\
} while (0) } while (0)
@ -117,9 +117,9 @@ extern int res_locked(struct cx25821_dev *dev, unsigned int bit);
extern void res_free(struct cx25821_dev *dev, struct cx25821_fh *fh, unsigned int bits); extern void res_free(struct cx25821_dev *dev, struct cx25821_fh *fh, unsigned int bits);
extern int cx25821_video_mux(struct cx25821_dev *dev, unsigned int input); extern int cx25821_video_mux(struct cx25821_dev *dev, unsigned int input);
extern int cx25821_start_video_dma(struct cx25821_dev *dev, extern int cx25821_start_video_dma(struct cx25821_dev *dev,
struct cx25821_dmaqueue *q, struct cx25821_dmaqueue *q,
struct cx25821_buffer *buf, struct cx25821_buffer *buf,
struct sram_channel *channel); struct sram_channel *channel);
extern int cx25821_set_scale(struct cx25821_dev *dev, unsigned int width, unsigned int height, enum v4l2_field field); extern int cx25821_set_scale(struct cx25821_dev *dev, unsigned int width, unsigned int height, enum v4l2_field field);
extern int cx25821_video_irq(struct cx25821_dev *dev, int chan_num, u32 status); extern int cx25821_video_irq(struct cx25821_dev *dev, int chan_num, u32 status);

216
drivers/staging/cx25821/cx25821-video0.c
View file

@ -1,7 +1,7 @@
/* /*
* Driver for the Conexant CX25821 PCIe bridge * Driver for the Conexant CX25821 PCIe bridge
* *
* Copyright (C) 2009 Conexant Systems Inc. * Copyright (C) 2009 Conexant Systems Inc.
* Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com> * Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com>
* Based on Steven Toth <stoth@linuxtv.org> cx23885 driver * Based on Steven Toth <stoth@linuxtv.org> cx23885 driver
* *
@ -40,37 +40,37 @@ static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
dprintk(2, "jmp to stopper (0x%x)\n", buf->risc.jmp[1]); dprintk(2, "jmp to stopper (0x%x)\n", buf->risc.jmp[1]);
if (!list_empty(&q->queued)) { if (!list_empty(&q->queued)) {
list_add_tail(&buf->vb.queue, &q->queued); list_add_tail(&buf->vb.queue, &q->queued);
buf->vb.state = VIDEOBUF_QUEUED; buf->vb.state = VIDEOBUF_QUEUED;
dprintk(2, "[%p/%d] buffer_queue - append to queued\n", buf, buf->vb.i); dprintk(2, "[%p/%d] buffer_queue - append to queued\n", buf, buf->vb.i);
} else if (list_empty(&q->active)) { } else if (list_empty(&q->active)) {
list_add_tail(&buf->vb.queue, &q->active); list_add_tail(&buf->vb.queue, &q->active);
cx25821_start_video_dma(dev, q, buf, &dev->sram_channels[SRAM_CH00]); cx25821_start_video_dma(dev, q, buf, &dev->sram_channels[SRAM_CH00]);
buf->vb.state = VIDEOBUF_ACTIVE; buf->vb.state = VIDEOBUF_ACTIVE;
buf->count = q->count++; buf->count = q->count++;
mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT); mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
dprintk(2, "[%p/%d] buffer_queue - first active, buf cnt = %d, q->count = %d\n", dprintk(2, "[%p/%d] buffer_queue - first active, buf cnt = %d, q->count = %d\n",
buf, buf->vb. i, buf->count, q->count); buf, buf->vb. i, buf->count, q->count);
} else { } else {
prev = list_entry(q->active.prev, struct cx25821_buffer, vb.queue); prev = list_entry(q->active.prev, struct cx25821_buffer, vb.queue);
if (prev->vb.width == buf->vb.width && if (prev->vb.width == buf->vb.width &&
prev->vb.height == buf->vb.height && prev->vb.height == buf->vb.height &&
prev->fmt == buf->fmt) { prev->fmt == buf->fmt) {
list_add_tail(&buf->vb.queue, &q->active); list_add_tail(&buf->vb.queue, &q->active);
buf->vb.state = VIDEOBUF_ACTIVE; buf->vb.state = VIDEOBUF_ACTIVE;
buf->count = q->count++; buf->count = q->count++;
prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma); prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
/* 64 bit bits 63-32 */ /* 64 bit bits 63-32 */
prev->risc.jmp[2] = cpu_to_le32(0); prev->risc.jmp[2] = cpu_to_le32(0);
dprintk(2, "[%p/%d] buffer_queue - append to active, buf->count=%d\n", buf, buf->vb.i, buf->count); dprintk(2, "[%p/%d] buffer_queue - append to active, buf->count=%d\n", buf, buf->vb.i, buf->count);
} else { } else {
list_add_tail(&buf->vb.queue, &q->queued); list_add_tail(&buf->vb.queue, &q->queued);
buf->vb.state = VIDEOBUF_QUEUED; buf->vb.state = VIDEOBUF_QUEUED;
dprintk(2, "[%p/%d] buffer_queue - first queued\n", buf, buf->vb.i); dprintk(2, "[%p/%d] buffer_queue - first queued\n", buf, buf->vb.i);
} }
} }
if (list_empty(&q->active)) if (list_empty(&q->active))
@ -100,18 +100,18 @@ static int video_open(struct file *file)
lock_kernel(); lock_kernel();
list_for_each(list, &cx25821_devlist) list_for_each(list, &cx25821_devlist)
{ {
h = list_entry(list, struct cx25821_dev, devlist); h = list_entry(list, struct cx25821_dev, devlist);
if (h->video_dev[SRAM_CH00] && h->video_dev[SRAM_CH00]->minor == minor) if (h->video_dev[SRAM_CH00] && h->video_dev[SRAM_CH00]->minor == minor)
{ {
dev = h; dev = h;
type = V4L2_BUF_TYPE_VIDEO_CAPTURE; type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
} }
} }
if (NULL == dev) { if (NULL == dev) {
unlock_kernel(); unlock_kernel();
return -ENODEV; return -ENODEV;
} }
printk("open minor=%d type=%s\n", minor, v4l2_type_names[type]); printk("open minor=%d type=%s\n", minor, v4l2_type_names[type]);
@ -119,8 +119,8 @@ static int video_open(struct file *file)
/* allocate + initialize per filehandle data */ /* allocate + initialize per filehandle data */
fh = kzalloc(sizeof(*fh), GFP_KERNEL); fh = kzalloc(sizeof(*fh), GFP_KERNEL);
if (NULL == fh) { if (NULL == fh) {
unlock_kernel(); unlock_kernel();
return -ENOMEM; return -ENOMEM;
} }
file->private_data = fh; file->private_data = fh;
@ -129,22 +129,22 @@ static int video_open(struct file *file)
fh->width = 720; fh->width = 720;
if(dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK) if(dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK)
fh->height = 576; fh->height = 576;
else else
fh->height = 480; fh->height = 480;
dev->channel_opened = SRAM_CH00; dev->channel_opened = SRAM_CH00;
pix_format = (dev->pixel_formats[dev->channel_opened] == PIXEL_FRMT_411) ? V4L2_PIX_FMT_Y41P : V4L2_PIX_FMT_YUYV; pix_format = (dev->pixel_formats[dev->channel_opened] == PIXEL_FRMT_411) ? V4L2_PIX_FMT_Y41P : V4L2_PIX_FMT_YUYV;
fh->fmt = format_by_fourcc(pix_format); fh->fmt = format_by_fourcc(pix_format);
v4l2_prio_open(&dev->prio,&fh->prio); v4l2_prio_open(&dev->prio,&fh->prio);
videobuf_queue_sg_init(&fh->vidq, &cx25821_video_qops, videobuf_queue_sg_init(&fh->vidq, &cx25821_video_qops,
&dev->pci->dev, &dev->slock, &dev->pci->dev, &dev->slock,
V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_BUF_TYPE_VIDEO_CAPTURE,
V4L2_FIELD_INTERLACED, V4L2_FIELD_INTERLACED,
sizeof(struct cx25821_buffer), sizeof(struct cx25821_buffer),
fh); fh);
dprintk(1, "post videobuf_queue_init()\n"); dprintk(1, "post videobuf_queue_init()\n");
unlock_kernel(); unlock_kernel();
@ -158,15 +158,15 @@ static ssize_t video_read(struct file *file, char __user *data, size_t count, lo
switch (fh->type) switch (fh->type)
{ {
case V4L2_BUF_TYPE_VIDEO_CAPTURE: case V4L2_BUF_TYPE_VIDEO_CAPTURE:
if (res_locked(fh->dev, RESOURCE_VIDEO0)) if (res_locked(fh->dev, RESOURCE_VIDEO0))
return -EBUSY; return -EBUSY;
return videobuf_read_one(&fh->vidq, data, count, ppos, file->f_flags & O_NONBLOCK); return videobuf_read_one(&fh->vidq, data, count, ppos, file->f_flags & O_NONBLOCK);
default: default:
BUG(); BUG();
return 0; return 0;
} }
} }
@ -176,36 +176,36 @@ static unsigned int video_poll(struct file *file, struct poll_table_struct *wait
struct cx25821_buffer *buf; struct cx25821_buffer *buf;
if (res_check(fh, RESOURCE_VIDEO0)) { if (res_check(fh, RESOURCE_VIDEO0)) {
/* streaming capture */ /* streaming capture */
if (list_empty(&fh->vidq.stream)) if (list_empty(&fh->vidq.stream))
return POLLERR; return POLLERR;
buf = list_entry(fh->vidq.stream.next, buf = list_entry(fh->vidq.stream.next,
struct cx25821_buffer, vb.stream); struct cx25821_buffer, vb.stream);
} else { } else {
/* read() capture */ /* read() capture */
buf = (struct cx25821_buffer *)fh->vidq.read_buf; buf = (struct cx25821_buffer *)fh->vidq.read_buf;
if (NULL == buf) if (NULL == buf)
return POLLERR; return POLLERR;
} }
poll_wait(file, &buf->vb.done, wait); poll_wait(file, &buf->vb.done, wait);
if (buf->vb.state == VIDEOBUF_DONE || buf->vb.state == VIDEOBUF_ERROR) if (buf->vb.state == VIDEOBUF_DONE || buf->vb.state == VIDEOBUF_ERROR)
{ {
if( buf->vb.state == VIDEOBUF_DONE ) if( buf->vb.state == VIDEOBUF_DONE )
{ {
struct cx25821_dev *dev = fh->dev; struct cx25821_dev *dev = fh->dev;
if( dev && dev->use_cif_resolution[SRAM_CH00] ) if( dev && dev->use_cif_resolution[SRAM_CH00] )
{ {
u8 cam_id = *((char*)buf->vb.baddr+3); u8 cam_id = *((char*)buf->vb.baddr+3);
memcpy((char*)buf->vb.baddr, (char*)buf->vb.baddr + (fh->width * 2), (fh->width * 2)); memcpy((char*)buf->vb.baddr, (char*)buf->vb.baddr + (fh->width * 2), (fh->width * 2));
*((char*)buf->vb.baddr+3) = cam_id; *((char*)buf->vb.baddr+3) = cam_id;
} }
} }
return POLLIN|POLLRDNORM; return POLLIN|POLLRDNORM;
} }
return 0; return 0;
} }
@ -220,13 +220,13 @@ static int video_release(struct file *file)
/* stop video capture */ /* stop video capture */
if (res_check(fh, RESOURCE_VIDEO0)) { if (res_check(fh, RESOURCE_VIDEO0)) {
videobuf_queue_cancel(&fh->vidq); videobuf_queue_cancel(&fh->vidq);
res_free(dev, fh, RESOURCE_VIDEO0); res_free(dev, fh, RESOURCE_VIDEO0);
} }
if (fh->vidq.read_buf) { if (fh->vidq.read_buf) {
buffer_release(&fh->vidq, fh->vidq.read_buf); buffer_release(&fh->vidq, fh->vidq.read_buf);
kfree(fh->vidq.read_buf); kfree(fh->vidq.read_buf);
} }
videobuf_mmap_free(&fh->vidq); videobuf_mmap_free(&fh->vidq);
@ -246,17 +246,17 @@ static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
if (unlikely(fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)) if (unlikely(fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE))
{ {
return -EINVAL; return -EINVAL;
} }
if (unlikely(i != fh->type)) if (unlikely(i != fh->type))
{ {
return -EINVAL; return -EINVAL;
} }
if (unlikely(!res_get(dev, fh, get_resource(fh, RESOURCE_VIDEO0)))) if (unlikely(!res_get(dev, fh, get_resource(fh, RESOURCE_VIDEO0))))
{ {
return -EBUSY; return -EBUSY;
} }
return videobuf_streamon(get_queue(fh)); return videobuf_streamon(get_queue(fh));
@ -269,14 +269,14 @@ static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
int err, res; int err, res;
if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
return -EINVAL; return -EINVAL;
if (i != fh->type) if (i != fh->type)
return -EINVAL; return -EINVAL;
res = get_resource(fh, RESOURCE_VIDEO0); res = get_resource(fh, RESOURCE_VIDEO0);
err = videobuf_streamoff(get_queue(fh)); err = videobuf_streamoff(get_queue(fh));
if (err < 0) if (err < 0)
return err; return err;
res_free(dev, fh, res); res_free(dev, fh, res);
return 0; return 0;
} }
@ -286,21 +286,21 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, struct v4l2_forma
{ {
struct cx25821_fh *fh = priv; struct cx25821_fh *fh = priv;
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
int err; int err;
int pix_format = PIXEL_FRMT_422; int pix_format = PIXEL_FRMT_422;
if (fh) if (fh)
{ {
err = v4l2_prio_check(&dev->prio, &fh->prio); err = v4l2_prio_check(&dev->prio, &fh->prio);
if (0 != err) if (0 != err)
return err; return err;
} }
dprintk(2, "%s()\n", __func__); dprintk(2, "%s()\n", __func__);
err = vidioc_try_fmt_vid_cap(file, priv, f); err = vidioc_try_fmt_vid_cap(file, priv, f);
if (0 != err) if (0 != err)
return err; return err;
fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat); fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat);
fh->vidq.field = f->fmt.pix.field; fh->vidq.field = f->fmt.pix.field;
@ -308,33 +308,33 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, struct v4l2_forma
// check if width and height is valid based on set standard // check if width and height is valid based on set standard
if (is_valid_width(f->fmt.pix.width, dev->tvnorm)) if (is_valid_width(f->fmt.pix.width, dev->tvnorm))
{ {
fh->width = f->fmt.pix.width; fh->width = f->fmt.pix.width;
} }
if (is_valid_height(f->fmt.pix.height, dev->tvnorm)) if (is_valid_height(f->fmt.pix.height, dev->tvnorm))
{ {
fh->height = f->fmt.pix.height; fh->height = f->fmt.pix.height;
} }
if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_Y41P) if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_Y41P)
pix_format = PIXEL_FRMT_411; pix_format = PIXEL_FRMT_411;
else if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_YUYV) else if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_YUYV)
pix_format = PIXEL_FRMT_422; pix_format = PIXEL_FRMT_422;
else else
return -EINVAL; return -EINVAL;
cx25821_set_pixel_format( dev, SRAM_CH00, pix_format );
cx25821_set_pixel_format( dev, SRAM_CH00, pix_format );
// check if cif resolution // check if cif resolution
if (fh->width == 320 || fh->width == 352) if (fh->width == 320 || fh->width == 352)
{ {
dev->use_cif_resolution[SRAM_CH00] = 1; dev->use_cif_resolution[SRAM_CH00] = 1;
}else }else
{ {
dev->use_cif_resolution[SRAM_CH00] = 0; dev->use_cif_resolution[SRAM_CH00] = 0;
} }
dev->cif_width[SRAM_CH00] = fh->width; dev->cif_width[SRAM_CH00] = fh->width;
medusa_set_resolution( dev, fh->width, SRAM_CH00 ); medusa_set_resolution( dev, fh->width, SRAM_CH00 );
dprintk(2, "%s() width=%d height=%d field=%d\n", __func__, fh->width, fh->height, fh->vidq.field); dprintk(2, "%s() width=%d height=%d field=%d\n", __func__, fh->width, fh->height, fh->vidq.field);
cx25821_call_all(dev, video, s_fmt, f); cx25821_call_all(dev, video, s_fmt, f);
@ -348,7 +348,7 @@ static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
struct cx25821_fh *fh = priv; struct cx25821_fh *fh = priv;
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
ret_val = videobuf_dqbuf(get_queue(fh), p, file->f_flags & O_NONBLOCK); ret_val = videobuf_dqbuf(get_queue(fh), p, file->f_flags & O_NONBLOCK);
p->sequence = dev->vidq[SRAM_CH00].count; p->sequence = dev->vidq[SRAM_CH00].count;
@ -360,7 +360,7 @@ static int vidioc_log_status (struct file *file, void *priv)
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
char name[32 + 2]; char name[32 + 2];
struct sram_channel *sram_ch = &dev->sram_channels[SRAM_CH00]; struct sram_channel *sram_ch = &dev->sram_channels[SRAM_CH00];
u32 tmp = 0; u32 tmp = 0;
snprintf(name, sizeof(name), "%s/2", dev->name); snprintf(name, sizeof(name), "%s/2", dev->name);
@ -378,10 +378,10 @@ static int vidioc_s_ctrl(struct file *file, void *priv,
struct v4l2_control *ctl) struct v4l2_control *ctl)
{ {
struct cx25821_fh *fh = priv; struct cx25821_fh *fh = priv;
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
int err; int err;
if (fh) { if (fh) {
err = v4l2_prio_check(&dev->prio, &fh->prio); err = v4l2_prio_check(&dev->prio, &fh->prio);
if (0 != err) if (0 != err)
return err; return err;
@ -398,7 +398,7 @@ static const struct v4l2_file_operations video_fops = {
.read = video_read, .read = video_read,
.poll = video_poll, .poll = video_poll,
.mmap = video_mmap, .mmap = video_mmap,
.ioctl = video_ioctl2, .ioctl = video_ioctl2,
}; };
static const struct v4l2_ioctl_ops video_ioctl_ops = { static const struct v4l2_ioctl_ops video_ioctl_ops = {

210
drivers/staging/cx25821/cx25821-video1.c
View file

@ -1,7 +1,7 @@
/* /*
* Driver for the Conexant CX25821 PCIe bridge * Driver for the Conexant CX25821 PCIe bridge
* *
* Copyright (C) 2009 Conexant Systems Inc. * Copyright (C) 2009 Conexant Systems Inc.
* Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com> * Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com>
* Based on Steven Toth <stoth@linuxtv.org> cx23885 driver * Based on Steven Toth <stoth@linuxtv.org> cx23885 driver
* *
@ -41,37 +41,37 @@ static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
dprintk(2, "jmp to stopper (0x%x)\n", buf->risc.jmp[1]); dprintk(2, "jmp to stopper (0x%x)\n", buf->risc.jmp[1]);
if (!list_empty(&q->queued)) { if (!list_empty(&q->queued)) {
list_add_tail(&buf->vb.queue, &q->queued); list_add_tail(&buf->vb.queue, &q->queued);
buf->vb.state = VIDEOBUF_QUEUED; buf->vb.state = VIDEOBUF_QUEUED;
dprintk(2, "[%p/%d] buffer_queue - append to queued\n", buf, buf->vb.i); dprintk(2, "[%p/%d] buffer_queue - append to queued\n", buf, buf->vb.i);
} else if (list_empty(&q->active)) { } else if (list_empty(&q->active)) {
list_add_tail(&buf->vb.queue, &q->active); list_add_tail(&buf->vb.queue, &q->active);
cx25821_start_video_dma(dev, q, buf, &dev->sram_channels[SRAM_CH01]); cx25821_start_video_dma(dev, q, buf, &dev->sram_channels[SRAM_CH01]);
buf->vb.state = VIDEOBUF_ACTIVE; buf->vb.state = VIDEOBUF_ACTIVE;
buf->count = q->count++; buf->count = q->count++;
mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT); mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
dprintk(2, "[%p/%d] buffer_queue - first active, buf cnt = %d, q->count = %d\n", dprintk(2, "[%p/%d] buffer_queue - first active, buf cnt = %d, q->count = %d\n",
buf, buf->vb. i, buf->count, q->count); buf, buf->vb. i, buf->count, q->count);
} else { } else {
prev = list_entry(q->active.prev, struct cx25821_buffer, vb.queue); prev = list_entry(q->active.prev, struct cx25821_buffer, vb.queue);
if (prev->vb.width == buf->vb.width && if (prev->vb.width == buf->vb.width &&
prev->vb.height == buf->vb.height && prev->vb.height == buf->vb.height &&
prev->fmt == buf->fmt) { prev->fmt == buf->fmt) {
list_add_tail(&buf->vb.queue, &q->active); list_add_tail(&buf->vb.queue, &q->active);
buf->vb.state = VIDEOBUF_ACTIVE; buf->vb.state = VIDEOBUF_ACTIVE;
buf->count = q->count++; buf->count = q->count++;
prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma); prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
/* 64 bit bits 63-32 */ /* 64 bit bits 63-32 */
prev->risc.jmp[2] = cpu_to_le32(0); prev->risc.jmp[2] = cpu_to_le32(0);
dprintk(2, "[%p/%d] buffer_queue - append to active, buf->count=%d\n", buf, buf->vb.i, buf->count); dprintk(2, "[%p/%d] buffer_queue - append to active, buf->count=%d\n", buf, buf->vb.i, buf->count);
} else { } else {
list_add_tail(&buf->vb.queue, &q->queued); list_add_tail(&buf->vb.queue, &q->queued);
buf->vb.state = VIDEOBUF_QUEUED; buf->vb.state = VIDEOBUF_QUEUED;
dprintk(2, "[%p/%d] buffer_queue - first queued\n", buf, buf->vb.i); dprintk(2, "[%p/%d] buffer_queue - first queued\n", buf, buf->vb.i);
} }
} }
if (list_empty(&q->active)) if (list_empty(&q->active))
@ -101,17 +101,17 @@ static int video_open(struct file *file)
lock_kernel(); lock_kernel();
list_for_each(list, &cx25821_devlist) list_for_each(list, &cx25821_devlist)
{ {
h = list_entry(list, struct cx25821_dev, devlist); h = list_entry(list, struct cx25821_dev, devlist);
if (h->video_dev[SRAM_CH01] && h->video_dev[SRAM_CH01]->minor == minor) { if (h->video_dev[SRAM_CH01] && h->video_dev[SRAM_CH01]->minor == minor) {
dev = h; dev = h;
type = V4L2_BUF_TYPE_VIDEO_CAPTURE; type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
} }
} }
if (NULL == dev) { if (NULL == dev) {
unlock_kernel(); unlock_kernel();
return -ENODEV; return -ENODEV;
} }
printk("open minor=%d type=%s\n", minor, v4l2_type_names[type]); printk("open minor=%d type=%s\n", minor, v4l2_type_names[type]);
@ -119,8 +119,8 @@ static int video_open(struct file *file)
/* allocate + initialize per filehandle data */ /* allocate + initialize per filehandle data */
fh = kzalloc(sizeof(*fh), GFP_KERNEL); fh = kzalloc(sizeof(*fh), GFP_KERNEL);
if (NULL == fh) { if (NULL == fh) {
unlock_kernel(); unlock_kernel();
return -ENOMEM; return -ENOMEM;
} }
file->private_data = fh; file->private_data = fh;
@ -129,9 +129,9 @@ static int video_open(struct file *file)
fh->width = 720; fh->width = 720;
if(dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK) if(dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK)
fh->height = 576; fh->height = 576;
else else
fh->height = 480; fh->height = 480;
dev->channel_opened = SRAM_CH01; dev->channel_opened = SRAM_CH01;
pix_format = (dev->pixel_formats[dev->channel_opened] == PIXEL_FRMT_411) ? V4L2_PIX_FMT_Y41P : V4L2_PIX_FMT_YUYV; pix_format = (dev->pixel_formats[dev->channel_opened] == PIXEL_FRMT_411) ? V4L2_PIX_FMT_Y41P : V4L2_PIX_FMT_YUYV;
@ -140,11 +140,11 @@ static int video_open(struct file *file)
v4l2_prio_open(&dev->prio,&fh->prio); v4l2_prio_open(&dev->prio,&fh->prio);
videobuf_queue_sg_init(&fh->vidq, &cx25821_video_qops, videobuf_queue_sg_init(&fh->vidq, &cx25821_video_qops,
&dev->pci->dev, &dev->slock, &dev->pci->dev, &dev->slock,
V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_BUF_TYPE_VIDEO_CAPTURE,
V4L2_FIELD_INTERLACED, V4L2_FIELD_INTERLACED,
sizeof(struct cx25821_buffer), sizeof(struct cx25821_buffer),
fh); fh);
dprintk(1, "post videobuf_queue_init()\n"); dprintk(1, "post videobuf_queue_init()\n");
unlock_kernel(); unlock_kernel();
@ -158,15 +158,15 @@ static ssize_t video_read(struct file *file, char __user *data, size_t count, lo
switch (fh->type) switch (fh->type)
{ {
case V4L2_BUF_TYPE_VIDEO_CAPTURE: case V4L2_BUF_TYPE_VIDEO_CAPTURE:
if (res_locked(fh->dev, RESOURCE_VIDEO1)) if (res_locked(fh->dev, RESOURCE_VIDEO1))
return -EBUSY; return -EBUSY;
return videobuf_read_one(&fh->vidq, data, count, ppos, file->f_flags & O_NONBLOCK); return videobuf_read_one(&fh->vidq, data, count, ppos, file->f_flags & O_NONBLOCK);
default: default:
BUG(); BUG();
return 0; return 0;
} }
} }
@ -176,36 +176,36 @@ static unsigned int video_poll(struct file *file, struct poll_table_struct *wait
struct cx25821_buffer *buf; struct cx25821_buffer *buf;
if (res_check(fh, RESOURCE_VIDEO1)) { if (res_check(fh, RESOURCE_VIDEO1)) {
/* streaming capture */ /* streaming capture */
if (list_empty(&fh->vidq.stream)) if (list_empty(&fh->vidq.stream))
return POLLERR; return POLLERR;
buf = list_entry(fh->vidq.stream.next, buf = list_entry(fh->vidq.stream.next,
struct cx25821_buffer, vb.stream); struct cx25821_buffer, vb.stream);
} else { } else {
/* read() capture */ /* read() capture */
buf = (struct cx25821_buffer *)fh->vidq.read_buf; buf = (struct cx25821_buffer *)fh->vidq.read_buf;
if (NULL == buf) if (NULL == buf)
return POLLERR; return POLLERR;
} }
poll_wait(file, &buf->vb.done, wait); poll_wait(file, &buf->vb.done, wait);
if (buf->vb.state == VIDEOBUF_DONE || buf->vb.state == VIDEOBUF_ERROR) if (buf->vb.state == VIDEOBUF_DONE || buf->vb.state == VIDEOBUF_ERROR)
{ {
if( buf->vb.state == VIDEOBUF_DONE ) if( buf->vb.state == VIDEOBUF_DONE )
{ {
struct cx25821_dev *dev = fh->dev; struct cx25821_dev *dev = fh->dev;
if( dev && dev->use_cif_resolution[SRAM_CH01] ) if( dev && dev->use_cif_resolution[SRAM_CH01] )
{ {
u8 cam_id = *((char*)buf->vb.baddr+3); u8 cam_id = *((char*)buf->vb.baddr+3);
memcpy((char*)buf->vb.baddr, (char*)buf->vb.baddr + (fh->width * 2), (fh->width * 2)); memcpy((char*)buf->vb.baddr, (char*)buf->vb.baddr + (fh->width * 2), (fh->width * 2));
*((char*)buf->vb.baddr+3) = cam_id; *((char*)buf->vb.baddr+3) = cam_id;
} }
} }
return POLLIN|POLLRDNORM; return POLLIN|POLLRDNORM;
} }
return 0; return 0;
} }
@ -219,13 +219,13 @@ static int video_release(struct file *file)
/* stop video capture */ /* stop video capture */
if (res_check(fh, RESOURCE_VIDEO1)) { if (res_check(fh, RESOURCE_VIDEO1)) {
videobuf_queue_cancel(&fh->vidq); videobuf_queue_cancel(&fh->vidq);
res_free(dev, fh, RESOURCE_VIDEO1); res_free(dev, fh, RESOURCE_VIDEO1);
} }
if (fh->vidq.read_buf) { if (fh->vidq.read_buf) {
buffer_release(&fh->vidq, fh->vidq.read_buf); buffer_release(&fh->vidq, fh->vidq.read_buf);
kfree(fh->vidq.read_buf); kfree(fh->vidq.read_buf);
} }
videobuf_mmap_free(&fh->vidq); videobuf_mmap_free(&fh->vidq);
@ -245,17 +245,17 @@ static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
if (unlikely(fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)) if (unlikely(fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE))
{ {
return -EINVAL; return -EINVAL;
} }
if (unlikely(i != fh->type)) if (unlikely(i != fh->type))
{ {
return -EINVAL; return -EINVAL;
} }
if (unlikely(!res_get(dev, fh, get_resource(fh, RESOURCE_VIDEO1)))) if (unlikely(!res_get(dev, fh, get_resource(fh, RESOURCE_VIDEO1))))
{ {
return -EBUSY; return -EBUSY;
} }
return videobuf_streamon(get_queue(fh)); return videobuf_streamon(get_queue(fh));
@ -268,14 +268,14 @@ static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
int err, res; int err, res;
if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
return -EINVAL; return -EINVAL;
if (i != fh->type) if (i != fh->type)
return -EINVAL; return -EINVAL;
res = get_resource(fh, RESOURCE_VIDEO1); res = get_resource(fh, RESOURCE_VIDEO1);
err = videobuf_streamoff(get_queue(fh)); err = videobuf_streamoff(get_queue(fh));
if (err < 0) if (err < 0)
return err; return err;
res_free(dev, fh, res); res_free(dev, fh, res);
return 0; return 0;
} }
@ -286,21 +286,21 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, struct v4l2_forma
{ {
struct cx25821_fh *fh = priv; struct cx25821_fh *fh = priv;
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
int err; int err;
int pix_format = 0; int pix_format = 0;
if (fh) if (fh)
{ {
err = v4l2_prio_check(&dev->prio, &fh->prio); err = v4l2_prio_check(&dev->prio, &fh->prio);
if (0 != err) if (0 != err)
return err; return err;
} }
dprintk(2, "%s()\n", __func__); dprintk(2, "%s()\n", __func__);
err = vidioc_try_fmt_vid_cap(file, priv, f); err = vidioc_try_fmt_vid_cap(file, priv, f);
if (0 != err) if (0 != err)
return err; return err;
fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat); fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat);
fh->vidq.field = f->fmt.pix.field; fh->vidq.field = f->fmt.pix.field;
@ -308,33 +308,33 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, struct v4l2_forma
// check if width and height is valid based on set standard // check if width and height is valid based on set standard
if (is_valid_width(f->fmt.pix.width, dev->tvnorm)) if (is_valid_width(f->fmt.pix.width, dev->tvnorm))
{ {
fh->width = f->fmt.pix.width; fh->width = f->fmt.pix.width;
} }
if (is_valid_height(f->fmt.pix.height, dev->tvnorm)) if (is_valid_height(f->fmt.pix.height, dev->tvnorm))
{ {
fh->height = f->fmt.pix.height; fh->height = f->fmt.pix.height;
} }
if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_Y41P) if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_Y41P)
pix_format = PIXEL_FRMT_411; pix_format = PIXEL_FRMT_411;
else if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_YUYV) else if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_YUYV)
pix_format = PIXEL_FRMT_422; pix_format = PIXEL_FRMT_422;
else else
return -EINVAL; return -EINVAL;
cx25821_set_pixel_format( dev, SRAM_CH01, pix_format );
cx25821_set_pixel_format( dev, SRAM_CH01, pix_format );
// check if cif resolution // check if cif resolution
if (fh->width == 320 || fh->width == 352) if (fh->width == 320 || fh->width == 352)
{ {
dev->use_cif_resolution[SRAM_CH01] = 1; dev->use_cif_resolution[SRAM_CH01] = 1;
}else }else
{ {
dev->use_cif_resolution[SRAM_CH01] = 0; dev->use_cif_resolution[SRAM_CH01] = 0;
} }
dev->cif_width[SRAM_CH01] = fh->width; dev->cif_width[SRAM_CH01] = fh->width;
medusa_set_resolution( dev, fh->width, SRAM_CH01 ); medusa_set_resolution( dev, fh->width, SRAM_CH01 );
dprintk(2, "%s() width=%d height=%d field=%d\n", __func__, fh->width, fh->height, fh->vidq.field); dprintk(2, "%s() width=%d height=%d field=%d\n", __func__, fh->width, fh->height, fh->vidq.field);
cx25821_call_all(dev, video, s_fmt, f); cx25821_call_all(dev, video, s_fmt, f);
@ -348,7 +348,7 @@ static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
struct cx25821_fh *fh = priv; struct cx25821_fh *fh = priv;
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
ret_val = videobuf_dqbuf(get_queue(fh), p, file->f_flags & O_NONBLOCK); ret_val = videobuf_dqbuf(get_queue(fh), p, file->f_flags & O_NONBLOCK);
p->sequence = dev->vidq[SRAM_CH01].count; p->sequence = dev->vidq[SRAM_CH01].count;
@ -360,7 +360,7 @@ static int vidioc_log_status (struct file *file, void *priv)
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
char name[32 + 2]; char name[32 + 2];
struct sram_channel *sram_ch = &dev->sram_channels[SRAM_CH01]; struct sram_channel *sram_ch = &dev->sram_channels[SRAM_CH01];
u32 tmp = 0; u32 tmp = 0;
snprintf(name, sizeof(name), "%s/2", dev->name); snprintf(name, sizeof(name), "%s/2", dev->name);
@ -378,10 +378,10 @@ static int vidioc_s_ctrl(struct file *file, void *priv,
struct v4l2_control *ctl) struct v4l2_control *ctl)
{ {
struct cx25821_fh *fh = priv; struct cx25821_fh *fh = priv;
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
int err; int err;
if (fh) { if (fh) {
err = v4l2_prio_check(&dev->prio, &fh->prio); err = v4l2_prio_check(&dev->prio, &fh->prio);
if (0 != err) if (0 != err)
return err; return err;
@ -397,7 +397,7 @@ static const struct v4l2_file_operations video_fops = {
.read = video_read, .read = video_read,
.poll = video_poll, .poll = video_poll,
.mmap = video_mmap, .mmap = video_mmap,
.ioctl = video_ioctl2, .ioctl = video_ioctl2,
}; };
static const struct v4l2_ioctl_ops video_ioctl_ops = { static const struct v4l2_ioctl_ops video_ioctl_ops = {

214
drivers/staging/cx25821/cx25821-video2.c
View file

@ -1,7 +1,7 @@
/* /*
* Driver for the Conexant CX25821 PCIe bridge * Driver for the Conexant CX25821 PCIe bridge
* *
* Copyright (C) 2009 Conexant Systems Inc. * Copyright (C) 2009 Conexant Systems Inc.
* Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com> * Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com>
* Based on Steven Toth <stoth@linuxtv.org> cx23885 driver * Based on Steven Toth <stoth@linuxtv.org> cx23885 driver
* *
@ -41,37 +41,37 @@ static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
dprintk(2, "jmp to stopper (0x%x)\n", buf->risc.jmp[1]); dprintk(2, "jmp to stopper (0x%x)\n", buf->risc.jmp[1]);
if (!list_empty(&q->queued)) { if (!list_empty(&q->queued)) {
list_add_tail(&buf->vb.queue, &q->queued); list_add_tail(&buf->vb.queue, &q->queued);
buf->vb.state = VIDEOBUF_QUEUED; buf->vb.state = VIDEOBUF_QUEUED;
dprintk(2, "[%p/%d] buffer_queue - append to queued\n", buf, buf->vb.i); dprintk(2, "[%p/%d] buffer_queue - append to queued\n", buf, buf->vb.i);
} else if (list_empty(&q->active)) { } else if (list_empty(&q->active)) {
list_add_tail(&buf->vb.queue, &q->active); list_add_tail(&buf->vb.queue, &q->active);
cx25821_start_video_dma(dev, q, buf, &dev->sram_channels[SRAM_CH02]); cx25821_start_video_dma(dev, q, buf, &dev->sram_channels[SRAM_CH02]);
buf->vb.state = VIDEOBUF_ACTIVE; buf->vb.state = VIDEOBUF_ACTIVE;
buf->count = q->count++; buf->count = q->count++;
mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT); mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
dprintk(2, "[%p/%d] buffer_queue - first active, buf cnt = %d, q->count = %d\n", dprintk(2, "[%p/%d] buffer_queue - first active, buf cnt = %d, q->count = %d\n",
buf, buf->vb. i, buf->count, q->count); buf, buf->vb. i, buf->count, q->count);
} else { } else {
prev = list_entry(q->active.prev, struct cx25821_buffer, vb.queue); prev = list_entry(q->active.prev, struct cx25821_buffer, vb.queue);
if (prev->vb.width == buf->vb.width && if (prev->vb.width == buf->vb.width &&
prev->vb.height == buf->vb.height && prev->vb.height == buf->vb.height &&
prev->fmt == buf->fmt) { prev->fmt == buf->fmt) {
list_add_tail(&buf->vb.queue, &q->active); list_add_tail(&buf->vb.queue, &q->active);
buf->vb.state = VIDEOBUF_ACTIVE; buf->vb.state = VIDEOBUF_ACTIVE;
buf->count = q->count++; buf->count = q->count++;
prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma); prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
/* 64 bit bits 63-32 */ /* 64 bit bits 63-32 */
prev->risc.jmp[2] = cpu_to_le32(0); prev->risc.jmp[2] = cpu_to_le32(0);
dprintk(2, "[%p/%d] buffer_queue - append to active, buf->count=%d\n", buf, buf->vb.i, buf->count); dprintk(2, "[%p/%d] buffer_queue - append to active, buf->count=%d\n", buf, buf->vb.i, buf->count);
} else { } else {
list_add_tail(&buf->vb.queue, &q->queued); list_add_tail(&buf->vb.queue, &q->queued);
buf->vb.state = VIDEOBUF_QUEUED; buf->vb.state = VIDEOBUF_QUEUED;
dprintk(2, "[%p/%d] buffer_queue - first queued\n", buf, buf->vb.i); dprintk(2, "[%p/%d] buffer_queue - first queued\n", buf, buf->vb.i);
} }
} }
if (list_empty(&q->active)) if (list_empty(&q->active))
@ -101,17 +101,17 @@ static int video_open(struct file *file)
lock_kernel(); lock_kernel();
list_for_each(list, &cx25821_devlist) list_for_each(list, &cx25821_devlist)
{ {
h = list_entry(list, struct cx25821_dev, devlist); h = list_entry(list, struct cx25821_dev, devlist);
if (h->video_dev[SRAM_CH02] && h->video_dev[SRAM_CH02]->minor == minor) { if (h->video_dev[SRAM_CH02] && h->video_dev[SRAM_CH02]->minor == minor) {
dev = h; dev = h;
type = V4L2_BUF_TYPE_VIDEO_CAPTURE; type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
} }
} }
if (NULL == dev) { if (NULL == dev) {
unlock_kernel(); unlock_kernel();
return -ENODEV; return -ENODEV;
} }
printk("open minor=%d type=%s\n", minor, v4l2_type_names[type]); printk("open minor=%d type=%s\n", minor, v4l2_type_names[type]);
@ -119,8 +119,8 @@ static int video_open(struct file *file)
/* allocate + initialize per filehandle data */ /* allocate + initialize per filehandle data */
fh = kzalloc(sizeof(*fh), GFP_KERNEL); fh = kzalloc(sizeof(*fh), GFP_KERNEL);
if (NULL == fh) { if (NULL == fh) {
unlock_kernel(); unlock_kernel();
return -ENOMEM; return -ENOMEM;
} }
file->private_data = fh; file->private_data = fh;
fh->dev = dev; fh->dev = dev;
@ -128,9 +128,9 @@ static int video_open(struct file *file)
fh->width = 720; fh->width = 720;
if(dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK) if(dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK)
fh->height = 576; fh->height = 576;
else else
fh->height = 480; fh->height = 480;
dev->channel_opened = SRAM_CH02; dev->channel_opened = SRAM_CH02;
pix_format = (dev->pixel_formats[dev->channel_opened] == PIXEL_FRMT_411) ? V4L2_PIX_FMT_Y41P : V4L2_PIX_FMT_YUYV; pix_format = (dev->pixel_formats[dev->channel_opened] == PIXEL_FRMT_411) ? V4L2_PIX_FMT_Y41P : V4L2_PIX_FMT_YUYV;
@ -139,11 +139,11 @@ static int video_open(struct file *file)
v4l2_prio_open(&dev->prio,&fh->prio); v4l2_prio_open(&dev->prio,&fh->prio);
videobuf_queue_sg_init(&fh->vidq, &cx25821_video_qops, videobuf_queue_sg_init(&fh->vidq, &cx25821_video_qops,
&dev->pci->dev, &dev->slock, &dev->pci->dev, &dev->slock,
V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_BUF_TYPE_VIDEO_CAPTURE,
V4L2_FIELD_INTERLACED, V4L2_FIELD_INTERLACED,
sizeof(struct cx25821_buffer), sizeof(struct cx25821_buffer),
fh); fh);
dprintk(1, "post videobuf_queue_init()\n"); dprintk(1, "post videobuf_queue_init()\n");
unlock_kernel(); unlock_kernel();
@ -157,15 +157,15 @@ static ssize_t video_read(struct file *file, char __user *data, size_t count, lo
switch (fh->type) switch (fh->type)
{ {
case V4L2_BUF_TYPE_VIDEO_CAPTURE: case V4L2_BUF_TYPE_VIDEO_CAPTURE:
if (res_locked(fh->dev, RESOURCE_VIDEO2)) if (res_locked(fh->dev, RESOURCE_VIDEO2))
return -EBUSY; return -EBUSY;
return videobuf_read_one(&fh->vidq, data, count, ppos, file->f_flags & O_NONBLOCK); return videobuf_read_one(&fh->vidq, data, count, ppos, file->f_flags & O_NONBLOCK);
default: default:
BUG(); BUG();
return 0; return 0;
} }
} }
@ -175,36 +175,36 @@ static unsigned int video_poll(struct file *file, struct poll_table_struct *wait
struct cx25821_buffer *buf; struct cx25821_buffer *buf;
if (res_check(fh, RESOURCE_VIDEO2)) { if (res_check(fh, RESOURCE_VIDEO2)) {
/* streaming capture */ /* streaming capture */
if (list_empty(&fh->vidq.stream)) if (list_empty(&fh->vidq.stream))
return POLLERR; return POLLERR;
buf = list_entry(fh->vidq.stream.next, buf = list_entry(fh->vidq.stream.next,
struct cx25821_buffer, vb.stream); struct cx25821_buffer, vb.stream);
} else { } else {
/* read() capture */ /* read() capture */
buf = (struct cx25821_buffer *)fh->vidq.read_buf; buf = (struct cx25821_buffer *)fh->vidq.read_buf;
if (NULL == buf) if (NULL == buf)
return POLLERR; return POLLERR;
} }
poll_wait(file, &buf->vb.done, wait); poll_wait(file, &buf->vb.done, wait);
if (buf->vb.state == VIDEOBUF_DONE || buf->vb.state == VIDEOBUF_ERROR) if (buf->vb.state == VIDEOBUF_DONE || buf->vb.state == VIDEOBUF_ERROR)
{ {
if( buf->vb.state == VIDEOBUF_DONE ) if( buf->vb.state == VIDEOBUF_DONE )
{ {
struct cx25821_dev *dev = fh->dev; struct cx25821_dev *dev = fh->dev;
if( dev && dev->use_cif_resolution[SRAM_CH02] ) if( dev && dev->use_cif_resolution[SRAM_CH02] )
{ {
u8 cam_id = *((char*)buf->vb.baddr+3); u8 cam_id = *((char*)buf->vb.baddr+3);
memcpy((char*)buf->vb.baddr, (char*)buf->vb.baddr + (fh->width * 2), (fh->width * 2)); memcpy((char*)buf->vb.baddr, (char*)buf->vb.baddr + (fh->width * 2), (fh->width * 2));
*((char*)buf->vb.baddr+3) = cam_id; *((char*)buf->vb.baddr+3) = cam_id;
} }
} }
return POLLIN|POLLRDNORM; return POLLIN|POLLRDNORM;
} }
return 0; return 0;
} }
@ -219,13 +219,13 @@ static int video_release(struct file *file)
/* stop video capture */ /* stop video capture */
if (res_check(fh, RESOURCE_VIDEO2)) { if (res_check(fh, RESOURCE_VIDEO2)) {
videobuf_queue_cancel(&fh->vidq); videobuf_queue_cancel(&fh->vidq);
res_free(dev, fh, RESOURCE_VIDEO2); res_free(dev, fh, RESOURCE_VIDEO2);
} }
if (fh->vidq.read_buf) { if (fh->vidq.read_buf) {
buffer_release(&fh->vidq, fh->vidq.read_buf); buffer_release(&fh->vidq, fh->vidq.read_buf);
kfree(fh->vidq.read_buf); kfree(fh->vidq.read_buf);
} }
videobuf_mmap_free(&fh->vidq); videobuf_mmap_free(&fh->vidq);
@ -245,17 +245,17 @@ static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
if (unlikely(fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)) if (unlikely(fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE))
{ {
return -EINVAL; return -EINVAL;
} }
if (unlikely(i != fh->type)) if (unlikely(i != fh->type))
{ {
return -EINVAL; return -EINVAL;
} }
if (unlikely(!res_get(dev, fh, get_resource(fh, RESOURCE_VIDEO2)))) if (unlikely(!res_get(dev, fh, get_resource(fh, RESOURCE_VIDEO2))))
{ {
return -EBUSY; return -EBUSY;
} }
return videobuf_streamon(get_queue(fh)); return videobuf_streamon(get_queue(fh));
@ -268,14 +268,14 @@ static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
int err, res; int err, res;
if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
return -EINVAL; return -EINVAL;
if (i != fh->type) if (i != fh->type)
return -EINVAL; return -EINVAL;
res = get_resource(fh, RESOURCE_VIDEO2); res = get_resource(fh, RESOURCE_VIDEO2);
err = videobuf_streamoff(get_queue(fh)); err = videobuf_streamoff(get_queue(fh));
if (err < 0) if (err < 0)
return err; return err;
res_free(dev, fh, res); res_free(dev, fh, res);
return 0; return 0;
} }
@ -286,21 +286,21 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, struct v4l2_forma
{ {
struct cx25821_fh *fh = priv; struct cx25821_fh *fh = priv;
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
int err; int err;
int pix_format = 0; int pix_format = 0;
if (fh) if (fh)
{ {
err = v4l2_prio_check(&dev->prio, &fh->prio); err = v4l2_prio_check(&dev->prio, &fh->prio);
if (0 != err) if (0 != err)
return err; return err;
} }
dprintk(2, "%s()\n", __func__); dprintk(2, "%s()\n", __func__);
err = vidioc_try_fmt_vid_cap(file, priv, f); err = vidioc_try_fmt_vid_cap(file, priv, f);
if (0 != err) if (0 != err)
return err; return err;
fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat); fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat);
fh->vidq.field = f->fmt.pix.field; fh->vidq.field = f->fmt.pix.field;
@ -308,33 +308,33 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, struct v4l2_forma
// check if width and height is valid based on set standard // check if width and height is valid based on set standard
if (is_valid_width(f->fmt.pix.width, dev->tvnorm)) if (is_valid_width(f->fmt.pix.width, dev->tvnorm))
{ {
fh->width = f->fmt.pix.width; fh->width = f->fmt.pix.width;
} }
if (is_valid_height(f->fmt.pix.height, dev->tvnorm)) if (is_valid_height(f->fmt.pix.height, dev->tvnorm))
{ {
fh->height = f->fmt.pix.height; fh->height = f->fmt.pix.height;
} }
if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_Y41P) if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_Y41P)
pix_format = PIXEL_FRMT_411; pix_format = PIXEL_FRMT_411;
else if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_YUYV) else if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_YUYV)
pix_format = PIXEL_FRMT_422; pix_format = PIXEL_FRMT_422;
else else
return -EINVAL; return -EINVAL;
cx25821_set_pixel_format( dev, SRAM_CH02, pix_format );
cx25821_set_pixel_format( dev, SRAM_CH02, pix_format );
// check if cif resolution // check if cif resolution
if (fh->width == 320 || fh->width == 352) if (fh->width == 320 || fh->width == 352)
{ {
dev->use_cif_resolution[SRAM_CH02] = 1; dev->use_cif_resolution[SRAM_CH02] = 1;
}else }else
{ {
dev->use_cif_resolution[SRAM_CH02] = 0; dev->use_cif_resolution[SRAM_CH02] = 0;
} }
dev->cif_width[SRAM_CH02] = fh->width; dev->cif_width[SRAM_CH02] = fh->width;
medusa_set_resolution( dev, fh->width, SRAM_CH02 ); medusa_set_resolution( dev, fh->width, SRAM_CH02 );
dprintk(2, "%s() width=%d height=%d field=%d\n", __func__, fh->width, fh->height, fh->vidq.field); dprintk(2, "%s() width=%d height=%d field=%d\n", __func__, fh->width, fh->height, fh->vidq.field);
@ -349,7 +349,7 @@ static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
struct cx25821_fh *fh = priv; struct cx25821_fh *fh = priv;
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
ret_val = videobuf_dqbuf(get_queue(fh), p, file->f_flags & O_NONBLOCK); ret_val = videobuf_dqbuf(get_queue(fh), p, file->f_flags & O_NONBLOCK);
p->sequence = dev->vidq[SRAM_CH02].count; p->sequence = dev->vidq[SRAM_CH02].count;
@ -361,15 +361,15 @@ static int vidioc_log_status (struct file *file, void *priv)
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
char name[32 + 2]; char name[32 + 2];
struct sram_channel *sram_ch = &dev->sram_channels[SRAM_CH02]; struct sram_channel *sram_ch = &dev->sram_channels[SRAM_CH02];
u32 tmp = 0; u32 tmp = 0;
snprintf(name, sizeof(name), "%s/2", dev->name); snprintf(name, sizeof(name), "%s/2", dev->name);
printk(KERN_INFO "%s/2: ============ START LOG STATUS ============\n", printk(KERN_INFO "%s/2: ============ START LOG STATUS ============\n",
dev->name); dev->name);
cx25821_call_all(dev, core, log_status); cx25821_call_all(dev, core, log_status);
tmp = cx_read(sram_ch->dma_ctl); tmp = cx_read(sram_ch->dma_ctl);
printk(KERN_INFO "Video input 2 is %s\n", (tmp & 0x11)?"streaming" : "stopped"); printk(KERN_INFO "Video input 2 is %s\n", (tmp & 0x11)?"streaming" : "stopped");
printk(KERN_INFO "%s/2: ============= END LOG STATUS =============\n", printk(KERN_INFO "%s/2: ============= END LOG STATUS =============\n",
@ -381,10 +381,10 @@ static int vidioc_s_ctrl(struct file *file, void *priv,
struct v4l2_control *ctl) struct v4l2_control *ctl)
{ {
struct cx25821_fh *fh = priv; struct cx25821_fh *fh = priv;
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
int err; int err;
if (fh) { if (fh) {
err = v4l2_prio_check(&dev->prio, &fh->prio); err = v4l2_prio_check(&dev->prio, &fh->prio);
if (0 != err) if (0 != err)
return err; return err;

212
drivers/staging/cx25821/cx25821-video3.c
View file

@ -1,7 +1,7 @@
/* /*
* Driver for the Conexant CX25821 PCIe bridge * Driver for the Conexant CX25821 PCIe bridge
* *
* Copyright (C) 2009 Conexant Systems Inc. * Copyright (C) 2009 Conexant Systems Inc.
* Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com> * Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com>
* Based on Steven Toth <stoth@linuxtv.org> cx23885 driver * Based on Steven Toth <stoth@linuxtv.org> cx23885 driver
* *
@ -41,37 +41,37 @@ static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
dprintk(2, "jmp to stopper (0x%x)\n", buf->risc.jmp[1]); dprintk(2, "jmp to stopper (0x%x)\n", buf->risc.jmp[1]);
if (!list_empty(&q->queued)) { if (!list_empty(&q->queued)) {
list_add_tail(&buf->vb.queue, &q->queued); list_add_tail(&buf->vb.queue, &q->queued);
buf->vb.state = VIDEOBUF_QUEUED; buf->vb.state = VIDEOBUF_QUEUED;
dprintk(2, "[%p/%d] buffer_queue - append to queued\n", buf, buf->vb.i); dprintk(2, "[%p/%d] buffer_queue - append to queued\n", buf, buf->vb.i);
} else if (list_empty(&q->active)) { } else if (list_empty(&q->active)) {
list_add_tail(&buf->vb.queue, &q->active); list_add_tail(&buf->vb.queue, &q->active);
cx25821_start_video_dma(dev, q, buf, &dev->sram_channels[SRAM_CH03]); cx25821_start_video_dma(dev, q, buf, &dev->sram_channels[SRAM_CH03]);
buf->vb.state = VIDEOBUF_ACTIVE; buf->vb.state = VIDEOBUF_ACTIVE;
buf->count = q->count++; buf->count = q->count++;
mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT); mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
dprintk(2, "[%p/%d] buffer_queue - first active, buf cnt = %d, q->count = %d\n", dprintk(2, "[%p/%d] buffer_queue - first active, buf cnt = %d, q->count = %d\n",
buf, buf->vb. i, buf->count, q->count); buf, buf->vb. i, buf->count, q->count);
} else { } else {
prev = list_entry(q->active.prev, struct cx25821_buffer, vb.queue); prev = list_entry(q->active.prev, struct cx25821_buffer, vb.queue);
if (prev->vb.width == buf->vb.width && if (prev->vb.width == buf->vb.width &&
prev->vb.height == buf->vb.height && prev->vb.height == buf->vb.height &&
prev->fmt == buf->fmt) { prev->fmt == buf->fmt) {
list_add_tail(&buf->vb.queue, &q->active); list_add_tail(&buf->vb.queue, &q->active);
buf->vb.state = VIDEOBUF_ACTIVE; buf->vb.state = VIDEOBUF_ACTIVE;
buf->count = q->count++; buf->count = q->count++;
prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma); prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
/* 64 bit bits 63-32 */ /* 64 bit bits 63-32 */
prev->risc.jmp[2] = cpu_to_le32(0); prev->risc.jmp[2] = cpu_to_le32(0);
dprintk(2, "[%p/%d] buffer_queue - append to active, buf->count=%d\n", buf, buf->vb.i, buf->count); dprintk(2, "[%p/%d] buffer_queue - append to active, buf->count=%d\n", buf, buf->vb.i, buf->count);
} else { } else {
list_add_tail(&buf->vb.queue, &q->queued); list_add_tail(&buf->vb.queue, &q->queued);
buf->vb.state = VIDEOBUF_QUEUED; buf->vb.state = VIDEOBUF_QUEUED;
dprintk(2, "[%p/%d] buffer_queue - first queued\n", buf, buf->vb.i); dprintk(2, "[%p/%d] buffer_queue - first queued\n", buf, buf->vb.i);
} }
} }
if (list_empty(&q->active)) if (list_empty(&q->active))
@ -101,17 +101,17 @@ static int video_open(struct file *file)
lock_kernel(); lock_kernel();
list_for_each(list, &cx25821_devlist) list_for_each(list, &cx25821_devlist)
{ {
h = list_entry(list, struct cx25821_dev, devlist); h = list_entry(list, struct cx25821_dev, devlist);
if (h->video_dev[SRAM_CH03] && h->video_dev[SRAM_CH03]->minor == minor) { if (h->video_dev[SRAM_CH03] && h->video_dev[SRAM_CH03]->minor == minor) {
dev = h; dev = h;
type = V4L2_BUF_TYPE_VIDEO_CAPTURE; type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
} }
} }
if (NULL == dev) { if (NULL == dev) {
unlock_kernel(); unlock_kernel();
return -ENODEV; return -ENODEV;
} }
printk("open minor=%d type=%s\n", minor, v4l2_type_names[type]); printk("open minor=%d type=%s\n", minor, v4l2_type_names[type]);
@ -119,8 +119,8 @@ static int video_open(struct file *file)
/* allocate + initialize per filehandle data */ /* allocate + initialize per filehandle data */
fh = kzalloc(sizeof(*fh), GFP_KERNEL); fh = kzalloc(sizeof(*fh), GFP_KERNEL);
if (NULL == fh) { if (NULL == fh) {
unlock_kernel(); unlock_kernel();
return -ENOMEM; return -ENOMEM;
} }
file->private_data = fh; file->private_data = fh;
fh->dev = dev; fh->dev = dev;
@ -128,9 +128,9 @@ static int video_open(struct file *file)
fh->width = 720; fh->width = 720;
if(dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK) if(dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK)
fh->height = 576; fh->height = 576;
else else
fh->height = 480; fh->height = 480;
dev->channel_opened = SRAM_CH03; dev->channel_opened = SRAM_CH03;
pix_format = (dev->pixel_formats[dev->channel_opened] == PIXEL_FRMT_411) ? V4L2_PIX_FMT_Y41P : V4L2_PIX_FMT_YUYV; pix_format = (dev->pixel_formats[dev->channel_opened] == PIXEL_FRMT_411) ? V4L2_PIX_FMT_Y41P : V4L2_PIX_FMT_YUYV;
@ -139,11 +139,11 @@ static int video_open(struct file *file)
v4l2_prio_open(&dev->prio,&fh->prio); v4l2_prio_open(&dev->prio,&fh->prio);
videobuf_queue_sg_init(&fh->vidq, &cx25821_video_qops, videobuf_queue_sg_init(&fh->vidq, &cx25821_video_qops,
&dev->pci->dev, &dev->slock, &dev->pci->dev, &dev->slock,
V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_BUF_TYPE_VIDEO_CAPTURE,
V4L2_FIELD_INTERLACED, V4L2_FIELD_INTERLACED,
sizeof(struct cx25821_buffer), sizeof(struct cx25821_buffer),
fh); fh);
dprintk(1, "post videobuf_queue_init()\n"); dprintk(1, "post videobuf_queue_init()\n");
unlock_kernel(); unlock_kernel();
@ -157,15 +157,15 @@ static ssize_t video_read(struct file *file, char __user *data, size_t count, lo
switch (fh->type) switch (fh->type)
{ {
case V4L2_BUF_TYPE_VIDEO_CAPTURE: case V4L2_BUF_TYPE_VIDEO_CAPTURE:
if (res_locked(fh->dev, RESOURCE_VIDEO3)) if (res_locked(fh->dev, RESOURCE_VIDEO3))
return -EBUSY; return -EBUSY;
return videobuf_read_one(&fh->vidq, data, count, ppos, file->f_flags & O_NONBLOCK); return videobuf_read_one(&fh->vidq, data, count, ppos, file->f_flags & O_NONBLOCK);
default: default:
BUG(); BUG();
return 0; return 0;
} }
} }
@ -175,36 +175,36 @@ static unsigned int video_poll(struct file *file, struct poll_table_struct *wait
struct cx25821_buffer *buf; struct cx25821_buffer *buf;
if (res_check(fh, RESOURCE_VIDEO3)) { if (res_check(fh, RESOURCE_VIDEO3)) {
/* streaming capture */ /* streaming capture */
if (list_empty(&fh->vidq.stream)) if (list_empty(&fh->vidq.stream))
return POLLERR; return POLLERR;
buf = list_entry(fh->vidq.stream.next, buf = list_entry(fh->vidq.stream.next,
struct cx25821_buffer, vb.stream); struct cx25821_buffer, vb.stream);
} else { } else {
/* read() capture */ /* read() capture */
buf = (struct cx25821_buffer *)fh->vidq.read_buf; buf = (struct cx25821_buffer *)fh->vidq.read_buf;
if (NULL == buf) if (NULL == buf)
return POLLERR; return POLLERR;
} }
poll_wait(file, &buf->vb.done, wait); poll_wait(file, &buf->vb.done, wait);
if (buf->vb.state == VIDEOBUF_DONE || buf->vb.state == VIDEOBUF_ERROR) if (buf->vb.state == VIDEOBUF_DONE || buf->vb.state == VIDEOBUF_ERROR)
{ {
if( buf->vb.state == VIDEOBUF_DONE ) if( buf->vb.state == VIDEOBUF_DONE )
{ {
struct cx25821_dev *dev = fh->dev; struct cx25821_dev *dev = fh->dev;
if( dev && dev->use_cif_resolution[SRAM_CH03] ) if( dev && dev->use_cif_resolution[SRAM_CH03] )
{ {
u8 cam_id = *((char*)buf->vb.baddr+3); u8 cam_id = *((char*)buf->vb.baddr+3);
memcpy((char*)buf->vb.baddr, (char*)buf->vb.baddr + (fh->width * 2), (fh->width * 2)); memcpy((char*)buf->vb.baddr, (char*)buf->vb.baddr + (fh->width * 2), (fh->width * 2));
*((char*)buf->vb.baddr+3) = cam_id; *((char*)buf->vb.baddr+3) = cam_id;
} }
} }
return POLLIN|POLLRDNORM; return POLLIN|POLLRDNORM;
} }
return 0; return 0;
} }
@ -219,13 +219,13 @@ static int video_release(struct file *file)
/* stop video capture */ /* stop video capture */
if (res_check(fh, RESOURCE_VIDEO3)) { if (res_check(fh, RESOURCE_VIDEO3)) {
videobuf_queue_cancel(&fh->vidq); videobuf_queue_cancel(&fh->vidq);
res_free(dev, fh, RESOURCE_VIDEO3); res_free(dev, fh, RESOURCE_VIDEO3);
} }
if (fh->vidq.read_buf) { if (fh->vidq.read_buf) {
buffer_release(&fh->vidq, fh->vidq.read_buf); buffer_release(&fh->vidq, fh->vidq.read_buf);
kfree(fh->vidq.read_buf); kfree(fh->vidq.read_buf);
} }
videobuf_mmap_free(&fh->vidq); videobuf_mmap_free(&fh->vidq);
@ -245,17 +245,17 @@ static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
if (unlikely(fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)) if (unlikely(fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE))
{ {
return -EINVAL; return -EINVAL;
} }
if (unlikely(i != fh->type)) if (unlikely(i != fh->type))
{ {
return -EINVAL; return -EINVAL;
} }
if (unlikely(!res_get(dev, fh, get_resource(fh, RESOURCE_VIDEO3)))) if (unlikely(!res_get(dev, fh, get_resource(fh, RESOURCE_VIDEO3))))
{ {
return -EBUSY; return -EBUSY;
} }
return videobuf_streamon(get_queue(fh)); return videobuf_streamon(get_queue(fh));
@ -268,14 +268,14 @@ static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
int err, res; int err, res;
if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
return -EINVAL; return -EINVAL;
if (i != fh->type) if (i != fh->type)
return -EINVAL; return -EINVAL;
res = get_resource(fh, RESOURCE_VIDEO3); res = get_resource(fh, RESOURCE_VIDEO3);
err = videobuf_streamoff(get_queue(fh)); err = videobuf_streamoff(get_queue(fh));
if (err < 0) if (err < 0)
return err; return err;
res_free(dev, fh, res); res_free(dev, fh, res);
return 0; return 0;
} }
@ -286,21 +286,21 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, struct v4l2_forma
{ {
struct cx25821_fh *fh = priv; struct cx25821_fh *fh = priv;
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
int err; int err;
int pix_format = 0; int pix_format = 0;
if (fh) if (fh)
{ {
err = v4l2_prio_check(&dev->prio, &fh->prio); err = v4l2_prio_check(&dev->prio, &fh->prio);
if (0 != err) if (0 != err)
return err; return err;
} }
dprintk(2, "%s()\n", __func__); dprintk(2, "%s()\n", __func__);
err = vidioc_try_fmt_vid_cap(file, priv, f); err = vidioc_try_fmt_vid_cap(file, priv, f);
if (0 != err) if (0 != err)
return err; return err;
fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat); fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat);
fh->vidq.field = f->fmt.pix.field; fh->vidq.field = f->fmt.pix.field;
@ -308,33 +308,33 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, struct v4l2_forma
// check if width and height is valid based on set standard // check if width and height is valid based on set standard
if (is_valid_width(f->fmt.pix.width, dev->tvnorm)) if (is_valid_width(f->fmt.pix.width, dev->tvnorm))
{ {
fh->width = f->fmt.pix.width; fh->width = f->fmt.pix.width;
} }
if (is_valid_height(f->fmt.pix.height, dev->tvnorm)) if (is_valid_height(f->fmt.pix.height, dev->tvnorm))
{ {
fh->height = f->fmt.pix.height; fh->height = f->fmt.pix.height;
} }
if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_Y41P) if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_Y41P)
pix_format = PIXEL_FRMT_411; pix_format = PIXEL_FRMT_411;
else if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_YUYV) else if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_YUYV)
pix_format = PIXEL_FRMT_422; pix_format = PIXEL_FRMT_422;
else else
return -EINVAL; return -EINVAL;
cx25821_set_pixel_format( dev, SRAM_CH03, pix_format );
cx25821_set_pixel_format( dev, SRAM_CH03, pix_format );
// check if cif resolution // check if cif resolution
if (fh->width == 320 || fh->width == 352) if (fh->width == 320 || fh->width == 352)
{ {
dev->use_cif_resolution[SRAM_CH03] = 1; dev->use_cif_resolution[SRAM_CH03] = 1;
}else }else
{ {
dev->use_cif_resolution[SRAM_CH03] = 0; dev->use_cif_resolution[SRAM_CH03] = 0;
} }
dev->cif_width[SRAM_CH03] = fh->width; dev->cif_width[SRAM_CH03] = fh->width;
medusa_set_resolution( dev, fh->width, SRAM_CH03 ); medusa_set_resolution( dev, fh->width, SRAM_CH03 );
dprintk(2, "%s() width=%d height=%d field=%d\n", __func__, fh->width, fh->height, fh->vidq.field); dprintk(2, "%s() width=%d height=%d field=%d\n", __func__, fh->width, fh->height, fh->vidq.field);
cx25821_call_all(dev, video, s_fmt, f); cx25821_call_all(dev, video, s_fmt, f);
@ -348,7 +348,7 @@ static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
struct cx25821_fh *fh = priv; struct cx25821_fh *fh = priv;
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
ret_val = videobuf_dqbuf(get_queue(fh), p, file->f_flags & O_NONBLOCK); ret_val = videobuf_dqbuf(get_queue(fh), p, file->f_flags & O_NONBLOCK);
p->sequence = dev->vidq[SRAM_CH03].count; p->sequence = dev->vidq[SRAM_CH03].count;
@ -360,7 +360,7 @@ static int vidioc_log_status (struct file *file, void *priv)
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
char name[32 + 2]; char name[32 + 2];
struct sram_channel *sram_ch = &dev->sram_channels[SRAM_CH03]; struct sram_channel *sram_ch = &dev->sram_channels[SRAM_CH03];
u32 tmp = 0; u32 tmp = 0;
snprintf(name, sizeof(name), "%s/2", dev->name); snprintf(name, sizeof(name), "%s/2", dev->name);
@ -379,10 +379,10 @@ static int vidioc_s_ctrl(struct file *file, void *priv,
struct v4l2_control *ctl) struct v4l2_control *ctl)
{ {
struct cx25821_fh *fh = priv; struct cx25821_fh *fh = priv;
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
int err; int err;
if (fh) { if (fh) {
err = v4l2_prio_check(&dev->prio, &fh->prio); err = v4l2_prio_check(&dev->prio, &fh->prio);
if (0 != err) if (0 != err)
return err; return err;

206
drivers/staging/cx25821/cx25821-video4.c
View file

@ -1,7 +1,7 @@
/* /*
* Driver for the Conexant CX25821 PCIe bridge * Driver for the Conexant CX25821 PCIe bridge
* *
* Copyright (C) 2009 Conexant Systems Inc. * Copyright (C) 2009 Conexant Systems Inc.
* Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com> * Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com>
* Based on Steven Toth <stoth@linuxtv.org> cx23885 driver * Based on Steven Toth <stoth@linuxtv.org> cx23885 driver
* *
@ -40,37 +40,37 @@ static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
dprintk(2, "jmp to stopper (0x%x)\n", buf->risc.jmp[1]); dprintk(2, "jmp to stopper (0x%x)\n", buf->risc.jmp[1]);
if (!list_empty(&q->queued)) { if (!list_empty(&q->queued)) {
list_add_tail(&buf->vb.queue, &q->queued); list_add_tail(&buf->vb.queue, &q->queued);
buf->vb.state = VIDEOBUF_QUEUED; buf->vb.state = VIDEOBUF_QUEUED;
dprintk(2, "[%p/%d] buffer_queue - append to queued\n", buf, buf->vb.i); dprintk(2, "[%p/%d] buffer_queue - append to queued\n", buf, buf->vb.i);
} else if (list_empty(&q->active)) { } else if (list_empty(&q->active)) {
list_add_tail(&buf->vb.queue, &q->active); list_add_tail(&buf->vb.queue, &q->active);
cx25821_start_video_dma(dev, q, buf, &dev->sram_channels[SRAM_CH04]); cx25821_start_video_dma(dev, q, buf, &dev->sram_channels[SRAM_CH04]);
buf->vb.state = VIDEOBUF_ACTIVE; buf->vb.state = VIDEOBUF_ACTIVE;
buf->count = q->count++; buf->count = q->count++;
mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT); mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
dprintk(2, "[%p/%d] buffer_queue - first active, buf cnt = %d, q->count = %d\n", dprintk(2, "[%p/%d] buffer_queue - first active, buf cnt = %d, q->count = %d\n",
buf, buf->vb. i, buf->count, q->count); buf, buf->vb. i, buf->count, q->count);
} else { } else {
prev = list_entry(q->active.prev, struct cx25821_buffer, vb.queue); prev = list_entry(q->active.prev, struct cx25821_buffer, vb.queue);
if (prev->vb.width == buf->vb.width && if (prev->vb.width == buf->vb.width &&
prev->vb.height == buf->vb.height && prev->vb.height == buf->vb.height &&
prev->fmt == buf->fmt) { prev->fmt == buf->fmt) {
list_add_tail(&buf->vb.queue, &q->active); list_add_tail(&buf->vb.queue, &q->active);
buf->vb.state = VIDEOBUF_ACTIVE; buf->vb.state = VIDEOBUF_ACTIVE;
buf->count = q->count++; buf->count = q->count++;
prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma); prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
/* 64 bit bits 63-32 */ /* 64 bit bits 63-32 */
prev->risc.jmp[2] = cpu_to_le32(0); prev->risc.jmp[2] = cpu_to_le32(0);
dprintk(2, "[%p/%d] buffer_queue - append to active, buf->count=%d\n", buf, buf->vb.i, buf->count); dprintk(2, "[%p/%d] buffer_queue - append to active, buf->count=%d\n", buf, buf->vb.i, buf->count);
} else { } else {
list_add_tail(&buf->vb.queue, &q->queued); list_add_tail(&buf->vb.queue, &q->queued);
buf->vb.state = VIDEOBUF_QUEUED; buf->vb.state = VIDEOBUF_QUEUED;
dprintk(2, "[%p/%d] buffer_queue - first queued\n", buf, buf->vb.i); dprintk(2, "[%p/%d] buffer_queue - first queued\n", buf, buf->vb.i);
} }
} }
if (list_empty(&q->active)) if (list_empty(&q->active))
@ -100,17 +100,17 @@ static int video_open(struct file *file)
lock_kernel(); lock_kernel();
list_for_each(list, &cx25821_devlist) list_for_each(list, &cx25821_devlist)
{ {
h = list_entry(list, struct cx25821_dev, devlist); h = list_entry(list, struct cx25821_dev, devlist);
if (h->video_dev[SRAM_CH04] && h->video_dev[SRAM_CH04]->minor == minor) { if (h->video_dev[SRAM_CH04] && h->video_dev[SRAM_CH04]->minor == minor) {
dev = h; dev = h;
type = V4L2_BUF_TYPE_VIDEO_CAPTURE; type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
} }
} }
if (NULL == dev) { if (NULL == dev) {
unlock_kernel(); unlock_kernel();
return -ENODEV; return -ENODEV;
} }
printk("open minor=%d type=%s\n", minor, v4l2_type_names[type]); printk("open minor=%d type=%s\n", minor, v4l2_type_names[type]);
@ -118,8 +118,8 @@ static int video_open(struct file *file)
/* allocate + initialize per filehandle data */ /* allocate + initialize per filehandle data */
fh = kzalloc(sizeof(*fh), GFP_KERNEL); fh = kzalloc(sizeof(*fh), GFP_KERNEL);
if (NULL == fh) { if (NULL == fh) {
unlock_kernel(); unlock_kernel();
return -ENOMEM; return -ENOMEM;
} }
file->private_data = fh; file->private_data = fh;
fh->dev = dev; fh->dev = dev;
@ -127,9 +127,9 @@ static int video_open(struct file *file)
fh->width = 720; fh->width = 720;
if(dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK) if(dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK)
fh->height = 576; fh->height = 576;
else else
fh->height = 480; fh->height = 480;
dev->channel_opened = SRAM_CH04; dev->channel_opened = SRAM_CH04;
pix_format = (dev->pixel_formats[dev->channel_opened] == PIXEL_FRMT_411) ? V4L2_PIX_FMT_Y41P : V4L2_PIX_FMT_YUYV; pix_format = (dev->pixel_formats[dev->channel_opened] == PIXEL_FRMT_411) ? V4L2_PIX_FMT_Y41P : V4L2_PIX_FMT_YUYV;
@ -137,11 +137,11 @@ static int video_open(struct file *file)
v4l2_prio_open(&dev->prio,&fh->prio); v4l2_prio_open(&dev->prio,&fh->prio);
videobuf_queue_sg_init(&fh->vidq, &cx25821_video_qops, videobuf_queue_sg_init(&fh->vidq, &cx25821_video_qops,
&dev->pci->dev, &dev->slock, &dev->pci->dev, &dev->slock,
V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_BUF_TYPE_VIDEO_CAPTURE,
V4L2_FIELD_INTERLACED, V4L2_FIELD_INTERLACED,
sizeof(struct cx25821_buffer), sizeof(struct cx25821_buffer),
fh); fh);
dprintk(1, "post videobuf_queue_init()\n"); dprintk(1, "post videobuf_queue_init()\n");
unlock_kernel(); unlock_kernel();
@ -155,15 +155,15 @@ static ssize_t video_read(struct file *file, char __user *data, size_t count, lo
switch (fh->type) switch (fh->type)
{ {
case V4L2_BUF_TYPE_VIDEO_CAPTURE: case V4L2_BUF_TYPE_VIDEO_CAPTURE:
if (res_locked(fh->dev, RESOURCE_VIDEO4)) if (res_locked(fh->dev, RESOURCE_VIDEO4))
return -EBUSY; return -EBUSY;
return videobuf_read_one(&fh->vidq, data, count, ppos, file->f_flags & O_NONBLOCK); return videobuf_read_one(&fh->vidq, data, count, ppos, file->f_flags & O_NONBLOCK);
default: default:
BUG(); BUG();
return 0; return 0;
} }
} }
@ -173,36 +173,36 @@ static unsigned int video_poll(struct file *file, struct poll_table_struct *wait
struct cx25821_buffer *buf; struct cx25821_buffer *buf;
if (res_check(fh, RESOURCE_VIDEO4)) { if (res_check(fh, RESOURCE_VIDEO4)) {
/* streaming capture */ /* streaming capture */
if (list_empty(&fh->vidq.stream)) if (list_empty(&fh->vidq.stream))
return POLLERR; return POLLERR;
buf = list_entry(fh->vidq.stream.next, buf = list_entry(fh->vidq.stream.next,
struct cx25821_buffer, vb.stream); struct cx25821_buffer, vb.stream);
} else { } else {
/* read() capture */ /* read() capture */
buf = (struct cx25821_buffer *)fh->vidq.read_buf; buf = (struct cx25821_buffer *)fh->vidq.read_buf;
if (NULL == buf) if (NULL == buf)
return POLLERR; return POLLERR;
} }
poll_wait(file, &buf->vb.done, wait); poll_wait(file, &buf->vb.done, wait);
if (buf->vb.state == VIDEOBUF_DONE || buf->vb.state == VIDEOBUF_ERROR) if (buf->vb.state == VIDEOBUF_DONE || buf->vb.state == VIDEOBUF_ERROR)
{ {
if( buf->vb.state == VIDEOBUF_DONE ) if( buf->vb.state == VIDEOBUF_DONE )
{ {
struct cx25821_dev *dev = fh->dev; struct cx25821_dev *dev = fh->dev;
if( dev && dev->use_cif_resolution[SRAM_CH04] ) if( dev && dev->use_cif_resolution[SRAM_CH04] )
{ {
u8 cam_id = *((char*)buf->vb.baddr+3); u8 cam_id = *((char*)buf->vb.baddr+3);
memcpy((char*)buf->vb.baddr, (char*)buf->vb.baddr + (fh->width * 2), (fh->width * 2)); memcpy((char*)buf->vb.baddr, (char*)buf->vb.baddr + (fh->width * 2), (fh->width * 2));
*((char*)buf->vb.baddr+3) = cam_id; *((char*)buf->vb.baddr+3) = cam_id;
} }
} }
return POLLIN|POLLRDNORM; return POLLIN|POLLRDNORM;
} }
return 0; return 0;
} }
@ -217,13 +217,13 @@ static int video_release(struct file *file)
/* stop video capture */ /* stop video capture */
if (res_check(fh, RESOURCE_VIDEO4)) { if (res_check(fh, RESOURCE_VIDEO4)) {
videobuf_queue_cancel(&fh->vidq); videobuf_queue_cancel(&fh->vidq);
res_free(dev, fh, RESOURCE_VIDEO4); res_free(dev, fh, RESOURCE_VIDEO4);
} }
if (fh->vidq.read_buf) { if (fh->vidq.read_buf) {
buffer_release(&fh->vidq, fh->vidq.read_buf); buffer_release(&fh->vidq, fh->vidq.read_buf);
kfree(fh->vidq.read_buf); kfree(fh->vidq.read_buf);
} }
videobuf_mmap_free(&fh->vidq); videobuf_mmap_free(&fh->vidq);
@ -243,17 +243,17 @@ static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
if (unlikely(fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)) if (unlikely(fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE))
{ {
return -EINVAL; return -EINVAL;
} }
if (unlikely(i != fh->type)) if (unlikely(i != fh->type))
{ {
return -EINVAL; return -EINVAL;
} }
if (unlikely(!res_get(dev, fh, get_resource(fh, RESOURCE_VIDEO4)))) if (unlikely(!res_get(dev, fh, get_resource(fh, RESOURCE_VIDEO4))))
{ {
return -EBUSY; return -EBUSY;
} }
return videobuf_streamon(get_queue(fh)); return videobuf_streamon(get_queue(fh));
@ -266,14 +266,14 @@ static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
int err, res; int err, res;
if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
return -EINVAL; return -EINVAL;
if (i != fh->type) if (i != fh->type)
return -EINVAL; return -EINVAL;
res = get_resource(fh, RESOURCE_VIDEO4); res = get_resource(fh, RESOURCE_VIDEO4);
err = videobuf_streamoff(get_queue(fh)); err = videobuf_streamoff(get_queue(fh));
if (err < 0) if (err < 0)
return err; return err;
res_free(dev, fh, res); res_free(dev, fh, res);
return 0; return 0;
} }
@ -284,21 +284,21 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, struct v4l2_forma
{ {
struct cx25821_fh *fh = priv; struct cx25821_fh *fh = priv;
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
int err; int err;
int pix_format = 0; int pix_format = 0;
// check priority // check priority
if (fh) if (fh)
{ {
err = v4l2_prio_check(&dev->prio, &fh->prio); err = v4l2_prio_check(&dev->prio, &fh->prio);
if (0 != err) if (0 != err)
return err; return err;
} }
dprintk(2, "%s()\n", __func__); dprintk(2, "%s()\n", __func__);
err = vidioc_try_fmt_vid_cap(file, priv, f); err = vidioc_try_fmt_vid_cap(file, priv, f);
if (0 != err) if (0 != err)
return err; return err;
fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat); fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat);
fh->vidq.field = f->fmt.pix.field; fh->vidq.field = f->fmt.pix.field;
@ -306,33 +306,33 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, struct v4l2_forma
// check if width and height is valid based on set standard // check if width and height is valid based on set standard
if (is_valid_width(f->fmt.pix.width, dev->tvnorm)) if (is_valid_width(f->fmt.pix.width, dev->tvnorm))
{ {
fh->width = f->fmt.pix.width; fh->width = f->fmt.pix.width;
} }
if (is_valid_height(f->fmt.pix.height, dev->tvnorm)) if (is_valid_height(f->fmt.pix.height, dev->tvnorm))
{ {
fh->height = f->fmt.pix.height; fh->height = f->fmt.pix.height;
} }
if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_Y41P) if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_Y41P)
pix_format = PIXEL_FRMT_411; pix_format = PIXEL_FRMT_411;
else if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_YUYV) else if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_YUYV)
pix_format = PIXEL_FRMT_422; pix_format = PIXEL_FRMT_422;
else else
return -EINVAL; return -EINVAL;
cx25821_set_pixel_format( dev, SRAM_CH04, pix_format );
cx25821_set_pixel_format( dev, SRAM_CH04, pix_format );
// check if cif resolution // check if cif resolution
if (fh->width == 320 || fh->width == 352) if (fh->width == 320 || fh->width == 352)
{ {
dev->use_cif_resolution[SRAM_CH04] = 1; dev->use_cif_resolution[SRAM_CH04] = 1;
}else }else
{ {
dev->use_cif_resolution[SRAM_CH04] = 0; dev->use_cif_resolution[SRAM_CH04] = 0;
} }
dev->cif_width[SRAM_CH04] = fh->width; dev->cif_width[SRAM_CH04] = fh->width;
medusa_set_resolution( dev, fh->width, SRAM_CH04); medusa_set_resolution( dev, fh->width, SRAM_CH04);
dprintk(2, "%s() width=%d height=%d field=%d\n", __func__, fh->width, fh->height, fh->vidq.field); dprintk(2, "%s() width=%d height=%d field=%d\n", __func__, fh->width, fh->height, fh->vidq.field);
cx25821_call_all(dev, video, s_fmt, f); cx25821_call_all(dev, video, s_fmt, f);
@ -346,7 +346,7 @@ static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
struct cx25821_fh *fh = priv; struct cx25821_fh *fh = priv;
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
ret_val = videobuf_dqbuf(get_queue(fh), p, file->f_flags & O_NONBLOCK); ret_val = videobuf_dqbuf(get_queue(fh), p, file->f_flags & O_NONBLOCK);
p->sequence = dev->vidq[SRAM_CH04].count; p->sequence = dev->vidq[SRAM_CH04].count;
@ -358,7 +358,7 @@ static int vidioc_log_status (struct file *file, void *priv)
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
char name[32 + 2]; char name[32 + 2];
struct sram_channel *sram_ch = &dev->sram_channels[SRAM_CH04]; struct sram_channel *sram_ch = &dev->sram_channels[SRAM_CH04];
u32 tmp = 0; u32 tmp = 0;
snprintf(name, sizeof(name), "%s/2", dev->name); snprintf(name, sizeof(name), "%s/2", dev->name);
@ -377,10 +377,10 @@ static int vidioc_s_ctrl(struct file *file, void *priv,
struct v4l2_control *ctl) struct v4l2_control *ctl)
{ {
struct cx25821_fh *fh = priv; struct cx25821_fh *fh = priv;
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
int err; int err;
if (fh) { if (fh) {
err = v4l2_prio_check(&dev->prio, &fh->prio); err = v4l2_prio_check(&dev->prio, &fh->prio);
if (0 != err) if (0 != err)
return err; return err;

210
drivers/staging/cx25821/cx25821-video5.c
View file

@ -1,7 +1,7 @@
/* /*
* Driver for the Conexant CX25821 PCIe bridge * Driver for the Conexant CX25821 PCIe bridge
* *
* Copyright (C) 2009 Conexant Systems Inc. * Copyright (C) 2009 Conexant Systems Inc.
* Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com> * Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com>
* Based on Steven Toth <stoth@linuxtv.org> cx23885 driver * Based on Steven Toth <stoth@linuxtv.org> cx23885 driver
* *
@ -40,37 +40,37 @@ static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
dprintk(2, "jmp to stopper (0x%x)\n", buf->risc.jmp[1]); dprintk(2, "jmp to stopper (0x%x)\n", buf->risc.jmp[1]);
if (!list_empty(&q->queued)) { if (!list_empty(&q->queued)) {
list_add_tail(&buf->vb.queue, &q->queued); list_add_tail(&buf->vb.queue, &q->queued);
buf->vb.state = VIDEOBUF_QUEUED; buf->vb.state = VIDEOBUF_QUEUED;
dprintk(2, "[%p/%d] buffer_queue - append to queued\n", buf, buf->vb.i); dprintk(2, "[%p/%d] buffer_queue - append to queued\n", buf, buf->vb.i);
} else if (list_empty(&q->active)) { } else if (list_empty(&q->active)) {
list_add_tail(&buf->vb.queue, &q->active); list_add_tail(&buf->vb.queue, &q->active);
cx25821_start_video_dma(dev, q, buf, &dev->sram_channels[SRAM_CH05]); cx25821_start_video_dma(dev, q, buf, &dev->sram_channels[SRAM_CH05]);
buf->vb.state = VIDEOBUF_ACTIVE; buf->vb.state = VIDEOBUF_ACTIVE;
buf->count = q->count++; buf->count = q->count++;
mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT); mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
dprintk(2, "[%p/%d] buffer_queue - first active, buf cnt = %d, q->count = %d\n", dprintk(2, "[%p/%d] buffer_queue - first active, buf cnt = %d, q->count = %d\n",
buf, buf->vb. i, buf->count, q->count); buf, buf->vb. i, buf->count, q->count);
} else { } else {
prev = list_entry(q->active.prev, struct cx25821_buffer, vb.queue); prev = list_entry(q->active.prev, struct cx25821_buffer, vb.queue);
if (prev->vb.width == buf->vb.width && if (prev->vb.width == buf->vb.width &&
prev->vb.height == buf->vb.height && prev->vb.height == buf->vb.height &&
prev->fmt == buf->fmt) { prev->fmt == buf->fmt) {
list_add_tail(&buf->vb.queue, &q->active); list_add_tail(&buf->vb.queue, &q->active);
buf->vb.state = VIDEOBUF_ACTIVE; buf->vb.state = VIDEOBUF_ACTIVE;
buf->count = q->count++; buf->count = q->count++;
prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma); prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
/* 64 bit bits 63-32 */ /* 64 bit bits 63-32 */
prev->risc.jmp[2] = cpu_to_le32(0); prev->risc.jmp[2] = cpu_to_le32(0);
dprintk(2, "[%p/%d] buffer_queue - append to active, buf->count=%d\n", buf, buf->vb.i, buf->count); dprintk(2, "[%p/%d] buffer_queue - append to active, buf->count=%d\n", buf, buf->vb.i, buf->count);
} else { } else {
list_add_tail(&buf->vb.queue, &q->queued); list_add_tail(&buf->vb.queue, &q->queued);
buf->vb.state = VIDEOBUF_QUEUED; buf->vb.state = VIDEOBUF_QUEUED;
dprintk(2, "[%p/%d] buffer_queue - first queued\n", buf, buf->vb.i); dprintk(2, "[%p/%d] buffer_queue - first queued\n", buf, buf->vb.i);
} }
} }
if (list_empty(&q->active)) if (list_empty(&q->active))
@ -100,17 +100,17 @@ static int video_open(struct file *file)
lock_kernel(); lock_kernel();
list_for_each(list, &cx25821_devlist) list_for_each(list, &cx25821_devlist)
{ {
h = list_entry(list, struct cx25821_dev, devlist); h = list_entry(list, struct cx25821_dev, devlist);
if (h->video_dev[SRAM_CH05] && h->video_dev[SRAM_CH05]->minor == minor) { if (h->video_dev[SRAM_CH05] && h->video_dev[SRAM_CH05]->minor == minor) {
dev = h; dev = h;
type = V4L2_BUF_TYPE_VIDEO_CAPTURE; type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
} }
} }
if (NULL == dev) { if (NULL == dev) {
unlock_kernel(); unlock_kernel();
return -ENODEV; return -ENODEV;
} }
printk("open minor=%d type=%s\n", minor, v4l2_type_names[type]); printk("open minor=%d type=%s\n", minor, v4l2_type_names[type]);
@ -118,8 +118,8 @@ static int video_open(struct file *file)
/* allocate + initialize per filehandle data */ /* allocate + initialize per filehandle data */
fh = kzalloc(sizeof(*fh), GFP_KERNEL); fh = kzalloc(sizeof(*fh), GFP_KERNEL);
if (NULL == fh) { if (NULL == fh) {
unlock_kernel(); unlock_kernel();
return -ENOMEM; return -ENOMEM;
} }
file->private_data = fh; file->private_data = fh;
fh->dev = dev; fh->dev = dev;
@ -127,9 +127,9 @@ static int video_open(struct file *file)
fh->width = 720; fh->width = 720;
if(dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK) if(dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK)
fh->height = 576; fh->height = 576;
else else
fh->height = 480; fh->height = 480;
dev->channel_opened = SRAM_CH05; dev->channel_opened = SRAM_CH05;
pix_format = (dev->pixel_formats[dev->channel_opened] == PIXEL_FRMT_411) ? V4L2_PIX_FMT_Y41P : V4L2_PIX_FMT_YUYV; pix_format = (dev->pixel_formats[dev->channel_opened] == PIXEL_FRMT_411) ? V4L2_PIX_FMT_Y41P : V4L2_PIX_FMT_YUYV;
@ -138,11 +138,11 @@ static int video_open(struct file *file)
v4l2_prio_open(&dev->prio,&fh->prio); v4l2_prio_open(&dev->prio,&fh->prio);
videobuf_queue_sg_init(&fh->vidq, &cx25821_video_qops, videobuf_queue_sg_init(&fh->vidq, &cx25821_video_qops,
&dev->pci->dev, &dev->slock, &dev->pci->dev, &dev->slock,
V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_BUF_TYPE_VIDEO_CAPTURE,
V4L2_FIELD_INTERLACED, V4L2_FIELD_INTERLACED,
sizeof(struct cx25821_buffer), sizeof(struct cx25821_buffer),
fh); fh);
dprintk(1, "post videobuf_queue_init()\n"); dprintk(1, "post videobuf_queue_init()\n");
unlock_kernel(); unlock_kernel();
@ -156,15 +156,15 @@ static ssize_t video_read(struct file *file, char __user *data, size_t count, lo
switch (fh->type) switch (fh->type)
{ {
case V4L2_BUF_TYPE_VIDEO_CAPTURE: case V4L2_BUF_TYPE_VIDEO_CAPTURE:
if (res_locked(fh->dev, RESOURCE_VIDEO5)) if (res_locked(fh->dev, RESOURCE_VIDEO5))
return -EBUSY; return -EBUSY;
return videobuf_read_one(&fh->vidq, data, count, ppos, file->f_flags & O_NONBLOCK); return videobuf_read_one(&fh->vidq, data, count, ppos, file->f_flags & O_NONBLOCK);
default: default:
BUG(); BUG();
return 0; return 0;
} }
} }
@ -174,34 +174,34 @@ static unsigned int video_poll(struct file *file, struct poll_table_struct *wait
struct cx25821_buffer *buf; struct cx25821_buffer *buf;
if (res_check(fh, RESOURCE_VIDEO5)) { if (res_check(fh, RESOURCE_VIDEO5)) {
/* streaming capture */ /* streaming capture */
if (list_empty(&fh->vidq.stream)) if (list_empty(&fh->vidq.stream))
return POLLERR; return POLLERR;
buf = list_entry(fh->vidq.stream.next, buf = list_entry(fh->vidq.stream.next,
struct cx25821_buffer, vb.stream); struct cx25821_buffer, vb.stream);
} else { } else {
/* read() capture */ /* read() capture */
buf = (struct cx25821_buffer *)fh->vidq.read_buf; buf = (struct cx25821_buffer *)fh->vidq.read_buf;
if (NULL == buf) if (NULL == buf)
return POLLERR; return POLLERR;
} }
poll_wait(file, &buf->vb.done, wait); poll_wait(file, &buf->vb.done, wait);
if (buf->vb.state == VIDEOBUF_DONE || buf->vb.state == VIDEOBUF_ERROR) if (buf->vb.state == VIDEOBUF_DONE || buf->vb.state == VIDEOBUF_ERROR)
{ {
if( buf->vb.state == VIDEOBUF_DONE ) if( buf->vb.state == VIDEOBUF_DONE )
{ {
struct cx25821_dev *dev = fh->dev; struct cx25821_dev *dev = fh->dev;
if( dev && dev->use_cif_resolution[SRAM_CH05] ) if( dev && dev->use_cif_resolution[SRAM_CH05] )
{ {
u8 cam_id = *((char*)buf->vb.baddr+3); u8 cam_id = *((char*)buf->vb.baddr+3);
memcpy((char*)buf->vb.baddr, (char*)buf->vb.baddr + (fh->width * 2), (fh->width * 2)); memcpy((char*)buf->vb.baddr, (char*)buf->vb.baddr + (fh->width * 2), (fh->width * 2));
*((char*)buf->vb.baddr+3) = cam_id; *((char*)buf->vb.baddr+3) = cam_id;
} }
} }
return POLLIN|POLLRDNORM; return POLLIN|POLLRDNORM;
} }
return 0; return 0;
@ -218,13 +218,13 @@ static int video_release(struct file *file)
/* stop video capture */ /* stop video capture */
if (res_check(fh, RESOURCE_VIDEO5)) { if (res_check(fh, RESOURCE_VIDEO5)) {
videobuf_queue_cancel(&fh->vidq); videobuf_queue_cancel(&fh->vidq);
res_free(dev, fh, RESOURCE_VIDEO5); res_free(dev, fh, RESOURCE_VIDEO5);
} }
if (fh->vidq.read_buf) { if (fh->vidq.read_buf) {
buffer_release(&fh->vidq, fh->vidq.read_buf); buffer_release(&fh->vidq, fh->vidq.read_buf);
kfree(fh->vidq.read_buf); kfree(fh->vidq.read_buf);
} }
videobuf_mmap_free(&fh->vidq); videobuf_mmap_free(&fh->vidq);
@ -244,17 +244,17 @@ static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
if (unlikely(fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)) if (unlikely(fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE))
{ {
return -EINVAL; return -EINVAL;
} }
if (unlikely(i != fh->type)) if (unlikely(i != fh->type))
{ {
return -EINVAL; return -EINVAL;
} }
if (unlikely(!res_get(dev, fh, get_resource(fh, RESOURCE_VIDEO5)))) if (unlikely(!res_get(dev, fh, get_resource(fh, RESOURCE_VIDEO5))))
{ {
return -EBUSY; return -EBUSY;
} }
return videobuf_streamon(get_queue(fh)); return videobuf_streamon(get_queue(fh));
@ -267,14 +267,14 @@ static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
int err, res; int err, res;
if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
return -EINVAL; return -EINVAL;
if (i != fh->type) if (i != fh->type)
return -EINVAL; return -EINVAL;
res = get_resource(fh, RESOURCE_VIDEO5); res = get_resource(fh, RESOURCE_VIDEO5);
err = videobuf_streamoff(get_queue(fh)); err = videobuf_streamoff(get_queue(fh));
if (err < 0) if (err < 0)
return err; return err;
res_free(dev, fh, res); res_free(dev, fh, res);
return 0; return 0;
} }
@ -284,21 +284,21 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, struct v4l2_forma
{ {
struct cx25821_fh *fh = priv; struct cx25821_fh *fh = priv;
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
int err; int err;
int pix_format = 0; int pix_format = 0;
if (fh) if (fh)
{ {
err = v4l2_prio_check(&dev->prio, &fh->prio); err = v4l2_prio_check(&dev->prio, &fh->prio);
if (0 != err) if (0 != err)
return err; return err;
} }
dprintk(2, "%s()\n", __func__); dprintk(2, "%s()\n", __func__);
err = vidioc_try_fmt_vid_cap(file, priv, f); err = vidioc_try_fmt_vid_cap(file, priv, f);
if (0 != err) if (0 != err)
return err; return err;
fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat); fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat);
fh->vidq.field = f->fmt.pix.field; fh->vidq.field = f->fmt.pix.field;
@ -306,33 +306,33 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, struct v4l2_forma
// check if width and height is valid based on set standard // check if width and height is valid based on set standard
if (is_valid_width(f->fmt.pix.width, dev->tvnorm)) if (is_valid_width(f->fmt.pix.width, dev->tvnorm))
{ {
fh->width = f->fmt.pix.width; fh->width = f->fmt.pix.width;
} }
if (is_valid_height(f->fmt.pix.height, dev->tvnorm)) if (is_valid_height(f->fmt.pix.height, dev->tvnorm))
{ {
fh->height = f->fmt.pix.height; fh->height = f->fmt.pix.height;
} }
if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_Y41P) if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_Y41P)
pix_format = PIXEL_FRMT_411; pix_format = PIXEL_FRMT_411;
else if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_YUYV) else if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_YUYV)
pix_format = PIXEL_FRMT_422; pix_format = PIXEL_FRMT_422;
else else
return -EINVAL; return -EINVAL;
cx25821_set_pixel_format( dev, SRAM_CH05, pix_format );
cx25821_set_pixel_format( dev, SRAM_CH05, pix_format );
// check if cif resolution // check if cif resolution
if (fh->width == 320 || fh->width == 352) if (fh->width == 320 || fh->width == 352)
{ {
dev->use_cif_resolution[SRAM_CH05] = 1; dev->use_cif_resolution[SRAM_CH05] = 1;
}else }else
{ {
dev->use_cif_resolution[SRAM_CH05] = 0; dev->use_cif_resolution[SRAM_CH05] = 0;
} }
dev->cif_width[SRAM_CH05] = fh->width; dev->cif_width[SRAM_CH05] = fh->width;
medusa_set_resolution( dev, fh->width, SRAM_CH05 ); medusa_set_resolution( dev, fh->width, SRAM_CH05 );
dprintk(2, "%s() width=%d height=%d field=%d\n", __func__, fh->width, fh->height, fh->vidq.field); dprintk(2, "%s() width=%d height=%d field=%d\n", __func__, fh->width, fh->height, fh->vidq.field);
cx25821_call_all(dev, video, s_fmt, f); cx25821_call_all(dev, video, s_fmt, f);
@ -346,7 +346,7 @@ static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
struct cx25821_fh *fh = priv; struct cx25821_fh *fh = priv;
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
ret_val = videobuf_dqbuf(get_queue(fh), p, file->f_flags & O_NONBLOCK); ret_val = videobuf_dqbuf(get_queue(fh), p, file->f_flags & O_NONBLOCK);
p->sequence = dev->vidq[SRAM_CH05].count; p->sequence = dev->vidq[SRAM_CH05].count;
@ -357,14 +357,14 @@ static int vidioc_log_status (struct file *file, void *priv)
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
char name[32 + 2]; char name[32 + 2];
struct sram_channel *sram_ch = &dev->sram_channels[SRAM_CH05]; struct sram_channel *sram_ch = &dev->sram_channels[SRAM_CH05];
u32 tmp = 0; u32 tmp = 0;
snprintf(name, sizeof(name), "%s/2", dev->name); snprintf(name, sizeof(name), "%s/2", dev->name);
printk(KERN_INFO "%s/2: ============ START LOG STATUS ============\n", printk(KERN_INFO "%s/2: ============ START LOG STATUS ============\n",
dev->name); dev->name);
cx25821_call_all(dev, core, log_status); cx25821_call_all(dev, core, log_status);
tmp = cx_read(sram_ch->dma_ctl); tmp = cx_read(sram_ch->dma_ctl);
printk(KERN_INFO "Video input 5 is %s\n", (tmp & 0x11)?"streaming" : "stopped"); printk(KERN_INFO "Video input 5 is %s\n", (tmp & 0x11)?"streaming" : "stopped");
printk(KERN_INFO "%s/2: ============= END LOG STATUS =============\n", printk(KERN_INFO "%s/2: ============= END LOG STATUS =============\n",
@ -376,10 +376,10 @@ static int vidioc_s_ctrl(struct file *file, void *priv,
struct v4l2_control *ctl) struct v4l2_control *ctl)
{ {
struct cx25821_fh *fh = priv; struct cx25821_fh *fh = priv;
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
int err; int err;
if (fh) { if (fh) {
err = v4l2_prio_check(&dev->prio, &fh->prio); err = v4l2_prio_check(&dev->prio, &fh->prio);
if (0 != err) if (0 != err)
return err; return err;

212
drivers/staging/cx25821/cx25821-video6.c
View file

@ -1,7 +1,7 @@
/* /*
* Driver for the Conexant CX25821 PCIe bridge * Driver for the Conexant CX25821 PCIe bridge
* *
* Copyright (C) 2009 Conexant Systems Inc. * Copyright (C) 2009 Conexant Systems Inc.
* Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com> * Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com>
* Based on Steven Toth <stoth@linuxtv.org> cx23885 driver * Based on Steven Toth <stoth@linuxtv.org> cx23885 driver
* *
@ -40,37 +40,37 @@ static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
dprintk(2, "jmp to stopper (0x%x)\n", buf->risc.jmp[1]); dprintk(2, "jmp to stopper (0x%x)\n", buf->risc.jmp[1]);
if (!list_empty(&q->queued)) { if (!list_empty(&q->queued)) {
list_add_tail(&buf->vb.queue, &q->queued); list_add_tail(&buf->vb.queue, &q->queued);
buf->vb.state = VIDEOBUF_QUEUED; buf->vb.state = VIDEOBUF_QUEUED;
dprintk(2, "[%p/%d] buffer_queue - append to queued\n", buf, buf->vb.i); dprintk(2, "[%p/%d] buffer_queue - append to queued\n", buf, buf->vb.i);
} else if (list_empty(&q->active)) { } else if (list_empty(&q->active)) {
list_add_tail(&buf->vb.queue, &q->active); list_add_tail(&buf->vb.queue, &q->active);
cx25821_start_video_dma(dev, q, buf, &dev->sram_channels[SRAM_CH06]); cx25821_start_video_dma(dev, q, buf, &dev->sram_channels[SRAM_CH06]);
buf->vb.state = VIDEOBUF_ACTIVE; buf->vb.state = VIDEOBUF_ACTIVE;
buf->count = q->count++; buf->count = q->count++;
mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT); mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
dprintk(2, "[%p/%d] buffer_queue - first active, buf cnt = %d, q->count = %d\n", dprintk(2, "[%p/%d] buffer_queue - first active, buf cnt = %d, q->count = %d\n",
buf, buf->vb. i, buf->count, q->count); buf, buf->vb. i, buf->count, q->count);
} else { } else {
prev = list_entry(q->active.prev, struct cx25821_buffer, vb.queue); prev = list_entry(q->active.prev, struct cx25821_buffer, vb.queue);
if (prev->vb.width == buf->vb.width && if (prev->vb.width == buf->vb.width &&
prev->vb.height == buf->vb.height && prev->vb.height == buf->vb.height &&
prev->fmt == buf->fmt) { prev->fmt == buf->fmt) {
list_add_tail(&buf->vb.queue, &q->active); list_add_tail(&buf->vb.queue, &q->active);
buf->vb.state = VIDEOBUF_ACTIVE; buf->vb.state = VIDEOBUF_ACTIVE;
buf->count = q->count++; buf->count = q->count++;
prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma); prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
/* 64 bit bits 63-32 */ /* 64 bit bits 63-32 */
prev->risc.jmp[2] = cpu_to_le32(0); prev->risc.jmp[2] = cpu_to_le32(0);
dprintk(2, "[%p/%d] buffer_queue - append to active, buf->count=%d\n", buf, buf->vb.i, buf->count); dprintk(2, "[%p/%d] buffer_queue - append to active, buf->count=%d\n", buf, buf->vb.i, buf->count);
} else { } else {
list_add_tail(&buf->vb.queue, &q->queued); list_add_tail(&buf->vb.queue, &q->queued);
buf->vb.state = VIDEOBUF_QUEUED; buf->vb.state = VIDEOBUF_QUEUED;
dprintk(2, "[%p/%d] buffer_queue - first queued\n", buf, buf->vb.i); dprintk(2, "[%p/%d] buffer_queue - first queued\n", buf, buf->vb.i);
} }
} }
if (list_empty(&q->active)) if (list_empty(&q->active))
@ -100,17 +100,17 @@ static int video_open(struct file *file)
lock_kernel(); lock_kernel();
list_for_each(list, &cx25821_devlist) list_for_each(list, &cx25821_devlist)
{ {
h = list_entry(list, struct cx25821_dev, devlist); h = list_entry(list, struct cx25821_dev, devlist);
if (h->video_dev[SRAM_CH06] && h->video_dev[SRAM_CH06]->minor == minor) { if (h->video_dev[SRAM_CH06] && h->video_dev[SRAM_CH06]->minor == minor) {
dev = h; dev = h;
type = V4L2_BUF_TYPE_VIDEO_CAPTURE; type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
} }
} }
if (NULL == dev) { if (NULL == dev) {
unlock_kernel(); unlock_kernel();
return -ENODEV; return -ENODEV;
} }
printk("open minor=%d type=%s\n", minor, v4l2_type_names[type]); printk("open minor=%d type=%s\n", minor, v4l2_type_names[type]);
@ -118,8 +118,8 @@ static int video_open(struct file *file)
/* allocate + initialize per filehandle data */ /* allocate + initialize per filehandle data */
fh = kzalloc(sizeof(*fh), GFP_KERNEL); fh = kzalloc(sizeof(*fh), GFP_KERNEL);
if (NULL == fh) { if (NULL == fh) {
unlock_kernel(); unlock_kernel();
return -ENOMEM; return -ENOMEM;
} }
file->private_data = fh; file->private_data = fh;
fh->dev = dev; fh->dev = dev;
@ -127,9 +127,9 @@ static int video_open(struct file *file)
fh->width = 720; fh->width = 720;
if(dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK) if(dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK)
fh->height = 576; fh->height = 576;
else else
fh->height = 480; fh->height = 480;
dev->channel_opened = SRAM_CH06; dev->channel_opened = SRAM_CH06;
pix_format = (dev->pixel_formats[dev->channel_opened] == PIXEL_FRMT_411) ? V4L2_PIX_FMT_Y41P : V4L2_PIX_FMT_YUYV; pix_format = (dev->pixel_formats[dev->channel_opened] == PIXEL_FRMT_411) ? V4L2_PIX_FMT_Y41P : V4L2_PIX_FMT_YUYV;
@ -138,11 +138,11 @@ static int video_open(struct file *file)
v4l2_prio_open(&dev->prio,&fh->prio); v4l2_prio_open(&dev->prio,&fh->prio);
videobuf_queue_sg_init(&fh->vidq, &cx25821_video_qops, videobuf_queue_sg_init(&fh->vidq, &cx25821_video_qops,
&dev->pci->dev, &dev->slock, &dev->pci->dev, &dev->slock,
V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_BUF_TYPE_VIDEO_CAPTURE,
V4L2_FIELD_INTERLACED, V4L2_FIELD_INTERLACED,
sizeof(struct cx25821_buffer), sizeof(struct cx25821_buffer),
fh); fh);
dprintk(1, "post videobuf_queue_init()\n"); dprintk(1, "post videobuf_queue_init()\n");
unlock_kernel(); unlock_kernel();
@ -156,15 +156,15 @@ static ssize_t video_read(struct file *file, char __user *data, size_t count, lo
switch (fh->type) switch (fh->type)
{ {
case V4L2_BUF_TYPE_VIDEO_CAPTURE: case V4L2_BUF_TYPE_VIDEO_CAPTURE:
if (res_locked(fh->dev, RESOURCE_VIDEO6)) if (res_locked(fh->dev, RESOURCE_VIDEO6))
return -EBUSY; return -EBUSY;
return videobuf_read_one(&fh->vidq, data, count, ppos, file->f_flags & O_NONBLOCK); return videobuf_read_one(&fh->vidq, data, count, ppos, file->f_flags & O_NONBLOCK);
default: default:
BUG(); BUG();
return 0; return 0;
} }
} }
@ -174,36 +174,36 @@ static unsigned int video_poll(struct file *file, struct poll_table_struct *wait
struct cx25821_buffer *buf; struct cx25821_buffer *buf;
if (res_check(fh, RESOURCE_VIDEO6)) { if (res_check(fh, RESOURCE_VIDEO6)) {
/* streaming capture */ /* streaming capture */
if (list_empty(&fh->vidq.stream)) if (list_empty(&fh->vidq.stream))
return POLLERR; return POLLERR;
buf = list_entry(fh->vidq.stream.next, buf = list_entry(fh->vidq.stream.next,
struct cx25821_buffer, vb.stream); struct cx25821_buffer, vb.stream);
} else { } else {
/* read() capture */ /* read() capture */
buf = (struct cx25821_buffer *)fh->vidq.read_buf; buf = (struct cx25821_buffer *)fh->vidq.read_buf;
if (NULL == buf) if (NULL == buf)
return POLLERR; return POLLERR;
} }
poll_wait(file, &buf->vb.done, wait); poll_wait(file, &buf->vb.done, wait);
if (buf->vb.state == VIDEOBUF_DONE || buf->vb.state == VIDEOBUF_ERROR) if (buf->vb.state == VIDEOBUF_DONE || buf->vb.state == VIDEOBUF_ERROR)
{ {
if( buf->vb.state == VIDEOBUF_DONE ) if( buf->vb.state == VIDEOBUF_DONE )
{ {
struct cx25821_dev *dev = fh->dev; struct cx25821_dev *dev = fh->dev;
if( dev && dev->use_cif_resolution[SRAM_CH06] ) if( dev && dev->use_cif_resolution[SRAM_CH06] )
{ {
u8 cam_id = *((char*)buf->vb.baddr+3); u8 cam_id = *((char*)buf->vb.baddr+3);
memcpy((char*)buf->vb.baddr, (char*)buf->vb.baddr + (fh->width * 2), (fh->width * 2)); memcpy((char*)buf->vb.baddr, (char*)buf->vb.baddr + (fh->width * 2), (fh->width * 2));
*((char*)buf->vb.baddr+3) = cam_id; *((char*)buf->vb.baddr+3) = cam_id;
} }
} }
return POLLIN|POLLRDNORM; return POLLIN|POLLRDNORM;
} }
return 0; return 0;
} }
@ -218,12 +218,12 @@ static int video_release(struct file *file)
/* stop video capture */ /* stop video capture */
if (res_check(fh, RESOURCE_VIDEO6)) { if (res_check(fh, RESOURCE_VIDEO6)) {
videobuf_queue_cancel(&fh->vidq); videobuf_queue_cancel(&fh->vidq);
res_free(dev, fh, RESOURCE_VIDEO6); res_free(dev, fh, RESOURCE_VIDEO6);
} }
if (fh->vidq.read_buf) { if (fh->vidq.read_buf) {
buffer_release(&fh->vidq, fh->vidq.read_buf); buffer_release(&fh->vidq, fh->vidq.read_buf);
kfree(fh->vidq.read_buf); kfree(fh->vidq.read_buf);
} }
videobuf_mmap_free(&fh->vidq); videobuf_mmap_free(&fh->vidq);
@ -243,17 +243,17 @@ static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
if (unlikely(fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)) if (unlikely(fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE))
{ {
return -EINVAL; return -EINVAL;
} }
if (unlikely(i != fh->type)) if (unlikely(i != fh->type))
{ {
return -EINVAL; return -EINVAL;
} }
if (unlikely(!res_get(dev, fh, get_resource(fh, RESOURCE_VIDEO6)))) if (unlikely(!res_get(dev, fh, get_resource(fh, RESOURCE_VIDEO6))))
{ {
return -EBUSY; return -EBUSY;
} }
return videobuf_streamon(get_queue(fh)); return videobuf_streamon(get_queue(fh));
@ -266,14 +266,14 @@ static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
int err, res; int err, res;
if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
return -EINVAL; return -EINVAL;
if (i != fh->type) if (i != fh->type)
return -EINVAL; return -EINVAL;
res = get_resource(fh, RESOURCE_VIDEO6); res = get_resource(fh, RESOURCE_VIDEO6);
err = videobuf_streamoff(get_queue(fh)); err = videobuf_streamoff(get_queue(fh));
if (err < 0) if (err < 0)
return err; return err;
res_free(dev, fh, res); res_free(dev, fh, res);
return 0; return 0;
} }
@ -283,21 +283,21 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, struct v4l2_forma
{ {
struct cx25821_fh *fh = priv; struct cx25821_fh *fh = priv;
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
int err; int err;
int pix_format = 0; int pix_format = 0;
if (fh) if (fh)
{ {
err = v4l2_prio_check(&dev->prio, &fh->prio); err = v4l2_prio_check(&dev->prio, &fh->prio);
if (0 != err) if (0 != err)
return err; return err;
} }
dprintk(2, "%s()\n", __func__); dprintk(2, "%s()\n", __func__);
err = vidioc_try_fmt_vid_cap(file, priv, f); err = vidioc_try_fmt_vid_cap(file, priv, f);
if (0 != err) if (0 != err)
return err; return err;
fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat); fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat);
fh->vidq.field = f->fmt.pix.field; fh->vidq.field = f->fmt.pix.field;
@ -305,33 +305,33 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, struct v4l2_forma
// check if width and height is valid based on set standard // check if width and height is valid based on set standard
if (is_valid_width(f->fmt.pix.width, dev->tvnorm)) if (is_valid_width(f->fmt.pix.width, dev->tvnorm))
{ {
fh->width = f->fmt.pix.width; fh->width = f->fmt.pix.width;
} }
if (is_valid_height(f->fmt.pix.height, dev->tvnorm)) if (is_valid_height(f->fmt.pix.height, dev->tvnorm))
{ {
fh->height = f->fmt.pix.height; fh->height = f->fmt.pix.height;
} }
if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_Y41P) if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_Y41P)
pix_format = PIXEL_FRMT_411; pix_format = PIXEL_FRMT_411;
else if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_YUYV) else if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_YUYV)
pix_format = PIXEL_FRMT_422; pix_format = PIXEL_FRMT_422;
else else
return -EINVAL; return -EINVAL;
cx25821_set_pixel_format( dev, SRAM_CH06, pix_format );
cx25821_set_pixel_format( dev, SRAM_CH06, pix_format );
// check if cif resolution // check if cif resolution
if (fh->width == 320 || fh->width == 352) if (fh->width == 320 || fh->width == 352)
{ {
dev->use_cif_resolution[SRAM_CH06] = 1; dev->use_cif_resolution[SRAM_CH06] = 1;
}else }else
{ {
dev->use_cif_resolution[SRAM_CH06] = 0; dev->use_cif_resolution[SRAM_CH06] = 0;
} }
dev->cif_width[SRAM_CH06] = fh->width; dev->cif_width[SRAM_CH06] = fh->width;
medusa_set_resolution( dev, fh->width, SRAM_CH06 ); medusa_set_resolution( dev, fh->width, SRAM_CH06 );
dprintk(2, "%s() width=%d height=%d field=%d\n", __func__, fh->width, fh->height, fh->vidq.field); dprintk(2, "%s() width=%d height=%d field=%d\n", __func__, fh->width, fh->height, fh->vidq.field);
cx25821_call_all(dev, video, s_fmt, f); cx25821_call_all(dev, video, s_fmt, f);
@ -345,7 +345,7 @@ static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
struct cx25821_fh *fh = priv; struct cx25821_fh *fh = priv;
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
ret_val = videobuf_dqbuf(get_queue(fh), p, file->f_flags & O_NONBLOCK); ret_val = videobuf_dqbuf(get_queue(fh), p, file->f_flags & O_NONBLOCK);
p->sequence = dev->vidq[SRAM_CH06].count; p->sequence = dev->vidq[SRAM_CH06].count;
@ -357,14 +357,14 @@ static int vidioc_log_status (struct file *file, void *priv)
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
char name[32 + 2]; char name[32 + 2];
struct sram_channel *sram_ch = &dev->sram_channels[SRAM_CH06]; struct sram_channel *sram_ch = &dev->sram_channels[SRAM_CH06];
u32 tmp = 0; u32 tmp = 0;
snprintf(name, sizeof(name), "%s/2", dev->name); snprintf(name, sizeof(name), "%s/2", dev->name);
printk(KERN_INFO "%s/2: ============ START LOG STATUS ============\n", printk(KERN_INFO "%s/2: ============ START LOG STATUS ============\n",
dev->name); dev->name);
cx25821_call_all(dev, core, log_status); cx25821_call_all(dev, core, log_status);
tmp = cx_read(sram_ch->dma_ctl); tmp = cx_read(sram_ch->dma_ctl);
printk(KERN_INFO "Video input 6 is %s\n", (tmp & 0x11)?"streaming" : "stopped"); printk(KERN_INFO "Video input 6 is %s\n", (tmp & 0x11)?"streaming" : "stopped");
printk(KERN_INFO "%s/2: ============= END LOG STATUS =============\n", printk(KERN_INFO "%s/2: ============= END LOG STATUS =============\n",
@ -376,10 +376,10 @@ static int vidioc_s_ctrl(struct file *file, void *priv,
struct v4l2_control *ctl) struct v4l2_control *ctl)
{ {
struct cx25821_fh *fh = priv; struct cx25821_fh *fh = priv;
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
int err; int err;
if (fh) { if (fh) {
err = v4l2_prio_check(&dev->prio, &fh->prio); err = v4l2_prio_check(&dev->prio, &fh->prio);
if (0 != err) if (0 != err)
return err; return err;

210
drivers/staging/cx25821/cx25821-video7.c
View file

@ -1,7 +1,7 @@
/* /*
* Driver for the Conexant CX25821 PCIe bridge * Driver for the Conexant CX25821 PCIe bridge
* *
* Copyright (C) 2009 Conexant Systems Inc. * Copyright (C) 2009 Conexant Systems Inc.
* Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com> * Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com>
* Based on Steven Toth <stoth@linuxtv.org> cx23885 driver * Based on Steven Toth <stoth@linuxtv.org> cx23885 driver
* *
@ -37,39 +37,39 @@ static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
buf->risc.jmp[1] = cpu_to_le32(q->stopper.dma); buf->risc.jmp[1] = cpu_to_le32(q->stopper.dma);
buf->risc.jmp[2] = cpu_to_le32(0); /* bits 63-32 */ buf->risc.jmp[2] = cpu_to_le32(0); /* bits 63-32 */
dprintk(2, "jmp to stopper (0x%x)\n", buf->risc.jmp[1]); dprintk(2, "jmp to stopper (0x%x)\n", buf->risc.jmp[1]);
if (!list_empty(&q->queued)) { if (!list_empty(&q->queued)) {
list_add_tail(&buf->vb.queue, &q->queued); list_add_tail(&buf->vb.queue, &q->queued);
buf->vb.state = VIDEOBUF_QUEUED; buf->vb.state = VIDEOBUF_QUEUED;
dprintk(2, "[%p/%d] buffer_queue - append to queued\n", buf, buf->vb.i); dprintk(2, "[%p/%d] buffer_queue - append to queued\n", buf, buf->vb.i);
} else if (list_empty(&q->active)) { } else if (list_empty(&q->active)) {
list_add_tail(&buf->vb.queue, &q->active); list_add_tail(&buf->vb.queue, &q->active);
cx25821_start_video_dma(dev, q, buf, &dev->sram_channels[SRAM_CH07]); cx25821_start_video_dma(dev, q, buf, &dev->sram_channels[SRAM_CH07]);
buf->vb.state = VIDEOBUF_ACTIVE; buf->vb.state = VIDEOBUF_ACTIVE;
buf->count = q->count++; buf->count = q->count++;
mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT); mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
dprintk(2, "[%p/%d] buffer_queue - first active, buf cnt = %d, q->count = %d\n", dprintk(2, "[%p/%d] buffer_queue - first active, buf cnt = %d, q->count = %d\n",
buf, buf->vb. i, buf->count, q->count); buf, buf->vb. i, buf->count, q->count);
} else { } else {
prev = list_entry(q->active.prev, struct cx25821_buffer, vb.queue); prev = list_entry(q->active.prev, struct cx25821_buffer, vb.queue);
if (prev->vb.width == buf->vb.width && if (prev->vb.width == buf->vb.width &&
prev->vb.height == buf->vb.height && prev->vb.height == buf->vb.height &&
prev->fmt == buf->fmt) { prev->fmt == buf->fmt) {
list_add_tail(&buf->vb.queue, &q->active); list_add_tail(&buf->vb.queue, &q->active);
buf->vb.state = VIDEOBUF_ACTIVE; buf->vb.state = VIDEOBUF_ACTIVE;
buf->count = q->count++; buf->count = q->count++;
prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma); prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
/* 64 bit bits 63-32 */ /* 64 bit bits 63-32 */
prev->risc.jmp[2] = cpu_to_le32(0); prev->risc.jmp[2] = cpu_to_le32(0);
dprintk(2, "[%p/%d] buffer_queue - append to active, buf->count=%d\n", buf, buf->vb.i, buf->count); dprintk(2, "[%p/%d] buffer_queue - append to active, buf->count=%d\n", buf, buf->vb.i, buf->count);
} else { } else {
list_add_tail(&buf->vb.queue, &q->queued); list_add_tail(&buf->vb.queue, &q->queued);
buf->vb.state = VIDEOBUF_QUEUED; buf->vb.state = VIDEOBUF_QUEUED;
dprintk(2, "[%p/%d] buffer_queue - first queued\n", buf, buf->vb.i); dprintk(2, "[%p/%d] buffer_queue - first queued\n", buf, buf->vb.i);
} }
} }
if (list_empty(&q->active)) if (list_empty(&q->active))
@ -99,17 +99,17 @@ static int video_open(struct file *file)
lock_kernel(); lock_kernel();
list_for_each(list, &cx25821_devlist) list_for_each(list, &cx25821_devlist)
{ {
h = list_entry(list, struct cx25821_dev, devlist); h = list_entry(list, struct cx25821_dev, devlist);
if (h->video_dev[SRAM_CH07] && h->video_dev[SRAM_CH07]->minor == minor) { if (h->video_dev[SRAM_CH07] && h->video_dev[SRAM_CH07]->minor == minor) {
dev = h; dev = h;
type = V4L2_BUF_TYPE_VIDEO_CAPTURE; type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
} }
} }
if (NULL == dev) { if (NULL == dev) {
unlock_kernel(); unlock_kernel();
return -ENODEV; return -ENODEV;
} }
printk("open minor=%d type=%s\n", minor, v4l2_type_names[type]); printk("open minor=%d type=%s\n", minor, v4l2_type_names[type]);
@ -117,8 +117,8 @@ static int video_open(struct file *file)
/* allocate + initialize per filehandle data */ /* allocate + initialize per filehandle data */
fh = kzalloc(sizeof(*fh), GFP_KERNEL); fh = kzalloc(sizeof(*fh), GFP_KERNEL);
if (NULL == fh) { if (NULL == fh) {
unlock_kernel(); unlock_kernel();
return -ENOMEM; return -ENOMEM;
} }
file->private_data = fh; file->private_data = fh;
fh->dev = dev; fh->dev = dev;
@ -126,22 +126,22 @@ static int video_open(struct file *file)
fh->width = 720; fh->width = 720;
if(dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK) if(dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK)
fh->height = 576; fh->height = 576;
else else
fh->height = 480; fh->height = 480;
dev->channel_opened = SRAM_CH07; dev->channel_opened = SRAM_CH07;
pix_format = (dev->pixel_formats[dev->channel_opened] == PIXEL_FRMT_411) ? V4L2_PIX_FMT_Y41P : V4L2_PIX_FMT_YUYV; pix_format = (dev->pixel_formats[dev->channel_opened] == PIXEL_FRMT_411) ? V4L2_PIX_FMT_Y41P : V4L2_PIX_FMT_YUYV;
fh->fmt = format_by_fourcc(pix_format); fh->fmt = format_by_fourcc(pix_format);
v4l2_prio_open(&dev->prio,&fh->prio); v4l2_prio_open(&dev->prio,&fh->prio);
videobuf_queue_sg_init(&fh->vidq, &cx25821_video_qops, videobuf_queue_sg_init(&fh->vidq, &cx25821_video_qops,
&dev->pci->dev, &dev->slock, &dev->pci->dev, &dev->slock,
V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_BUF_TYPE_VIDEO_CAPTURE,
V4L2_FIELD_INTERLACED, V4L2_FIELD_INTERLACED,
sizeof(struct cx25821_buffer), sizeof(struct cx25821_buffer),
fh); fh);
dprintk(1, "post videobuf_queue_init()\n"); dprintk(1, "post videobuf_queue_init()\n");
unlock_kernel(); unlock_kernel();
@ -155,15 +155,15 @@ static ssize_t video_read(struct file *file, char __user *data, size_t count, lo
switch (fh->type) switch (fh->type)
{ {
case V4L2_BUF_TYPE_VIDEO_CAPTURE: case V4L2_BUF_TYPE_VIDEO_CAPTURE:
if (res_locked(fh->dev, RESOURCE_VIDEO7)) if (res_locked(fh->dev, RESOURCE_VIDEO7))
return -EBUSY; return -EBUSY;
return videobuf_read_one(&fh->vidq, data, count, ppos, file->f_flags & O_NONBLOCK); return videobuf_read_one(&fh->vidq, data, count, ppos, file->f_flags & O_NONBLOCK);
default: default:
BUG(); BUG();
return 0; return 0;
} }
} }
@ -173,34 +173,34 @@ static unsigned int video_poll(struct file *file, struct poll_table_struct *wait
struct cx25821_buffer *buf; struct cx25821_buffer *buf;
if (res_check(fh, RESOURCE_VIDEO7)) { if (res_check(fh, RESOURCE_VIDEO7)) {
/* streaming capture */ /* streaming capture */
if (list_empty(&fh->vidq.stream)) if (list_empty(&fh->vidq.stream))
return POLLERR; return POLLERR;
buf = list_entry(fh->vidq.stream.next, buf = list_entry(fh->vidq.stream.next,
struct cx25821_buffer, vb.stream); struct cx25821_buffer, vb.stream);
} else { } else {
/* read() capture */ /* read() capture */
buf = (struct cx25821_buffer *)fh->vidq.read_buf; buf = (struct cx25821_buffer *)fh->vidq.read_buf;
if (NULL == buf) if (NULL == buf)
return POLLERR; return POLLERR;
} }
poll_wait(file, &buf->vb.done, wait); poll_wait(file, &buf->vb.done, wait);
if (buf->vb.state == VIDEOBUF_DONE || buf->vb.state == VIDEOBUF_ERROR) if (buf->vb.state == VIDEOBUF_DONE || buf->vb.state == VIDEOBUF_ERROR)
{ {
if( buf->vb.state == VIDEOBUF_DONE ) if( buf->vb.state == VIDEOBUF_DONE )
{ {
struct cx25821_dev *dev = fh->dev; struct cx25821_dev *dev = fh->dev;
if( dev && dev->use_cif_resolution[SRAM_CH07] ) if( dev && dev->use_cif_resolution[SRAM_CH07] )
{ {
u8 cam_id = *((char*)buf->vb.baddr+3); u8 cam_id = *((char*)buf->vb.baddr+3);
memcpy((char*)buf->vb.baddr, (char*)buf->vb.baddr + (fh->width * 2), (fh->width * 2)); memcpy((char*)buf->vb.baddr, (char*)buf->vb.baddr + (fh->width * 2), (fh->width * 2));
*((char*)buf->vb.baddr+3) = cam_id; *((char*)buf->vb.baddr+3) = cam_id;
} }
} }
return POLLIN|POLLRDNORM; return POLLIN|POLLRDNORM;
} }
return 0; return 0;
@ -217,13 +217,13 @@ static int video_release(struct file *file)
/* stop video capture */ /* stop video capture */
if (res_check(fh, RESOURCE_VIDEO7)) { if (res_check(fh, RESOURCE_VIDEO7)) {
videobuf_queue_cancel(&fh->vidq); videobuf_queue_cancel(&fh->vidq);
res_free(dev, fh, RESOURCE_VIDEO7); res_free(dev, fh, RESOURCE_VIDEO7);
} }
if (fh->vidq.read_buf) { if (fh->vidq.read_buf) {
buffer_release(&fh->vidq, fh->vidq.read_buf); buffer_release(&fh->vidq, fh->vidq.read_buf);
kfree(fh->vidq.read_buf); kfree(fh->vidq.read_buf);
} }
videobuf_mmap_free(&fh->vidq); videobuf_mmap_free(&fh->vidq);
@ -243,17 +243,17 @@ static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
if (unlikely(fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)) if (unlikely(fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE))
{ {
return -EINVAL; return -EINVAL;
} }
if (unlikely(i != fh->type)) if (unlikely(i != fh->type))
{ {
return -EINVAL; return -EINVAL;
} }
if (unlikely(!res_get(dev, fh, get_resource(fh, RESOURCE_VIDEO7)))) if (unlikely(!res_get(dev, fh, get_resource(fh, RESOURCE_VIDEO7))))
{ {
return -EBUSY; return -EBUSY;
} }
return videobuf_streamon(get_queue(fh)); return videobuf_streamon(get_queue(fh));
@ -266,14 +266,14 @@ static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
int err, res; int err, res;
if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
return -EINVAL; return -EINVAL;
if (i != fh->type) if (i != fh->type)
return -EINVAL; return -EINVAL;
res = get_resource(fh, RESOURCE_VIDEO7); res = get_resource(fh, RESOURCE_VIDEO7);
err = videobuf_streamoff(get_queue(fh)); err = videobuf_streamoff(get_queue(fh));
if (err < 0) if (err < 0)
return err; return err;
res_free(dev, fh, res); res_free(dev, fh, res);
return 0; return 0;
} }
@ -283,13 +283,13 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, struct v4l2_forma
{ {
struct cx25821_fh *fh = priv; struct cx25821_fh *fh = priv;
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
int err; int err;
int pix_format = 0; int pix_format = 0;
if (fh) if (fh)
{ {
err = v4l2_prio_check(&dev->prio, &fh->prio); err = v4l2_prio_check(&dev->prio, &fh->prio);
if (0 != err) if (0 != err)
return err; return err;
} }
@ -297,7 +297,7 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, struct v4l2_forma
err = vidioc_try_fmt_vid_cap(file, priv, f); err = vidioc_try_fmt_vid_cap(file, priv, f);
if (0 != err) if (0 != err)
return err; return err;
fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat); fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat);
fh->vidq.field = f->fmt.pix.field; fh->vidq.field = f->fmt.pix.field;
@ -305,33 +305,33 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, struct v4l2_forma
// check if width and height is valid based on set standard // check if width and height is valid based on set standard
if (is_valid_width(f->fmt.pix.width, dev->tvnorm)) if (is_valid_width(f->fmt.pix.width, dev->tvnorm))
{ {
fh->width = f->fmt.pix.width; fh->width = f->fmt.pix.width;
} }
if (is_valid_height(f->fmt.pix.height, dev->tvnorm)) if (is_valid_height(f->fmt.pix.height, dev->tvnorm))
{ {
fh->height = f->fmt.pix.height; fh->height = f->fmt.pix.height;
} }
if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_Y41P) if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_Y41P)
pix_format = PIXEL_FRMT_411; pix_format = PIXEL_FRMT_411;
else if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_YUYV) else if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_YUYV)
pix_format = PIXEL_FRMT_422; pix_format = PIXEL_FRMT_422;
else else
return -EINVAL; return -EINVAL;
cx25821_set_pixel_format( dev, SRAM_CH07, pix_format );
cx25821_set_pixel_format( dev, SRAM_CH07, pix_format );
// check if cif resolution // check if cif resolution
if (fh->width == 320 || fh->width == 352) if (fh->width == 320 || fh->width == 352)
{ {
dev->use_cif_resolution[SRAM_CH07] = 1; dev->use_cif_resolution[SRAM_CH07] = 1;
}else }else
{ {
dev->use_cif_resolution[SRAM_CH07] = 0; dev->use_cif_resolution[SRAM_CH07] = 0;
} }
dev->cif_width[SRAM_CH07] = fh->width; dev->cif_width[SRAM_CH07] = fh->width;
medusa_set_resolution( dev, fh->width, SRAM_CH07 ); medusa_set_resolution( dev, fh->width, SRAM_CH07 );
dprintk(2, "%s() width=%d height=%d field=%d\n", __func__, fh->width, fh->height, fh->vidq.field); dprintk(2, "%s() width=%d height=%d field=%d\n", __func__, fh->width, fh->height, fh->vidq.field);
cx25821_call_all(dev, video, s_fmt, f); cx25821_call_all(dev, video, s_fmt, f);
@ -345,7 +345,7 @@ static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
struct cx25821_fh *fh = priv; struct cx25821_fh *fh = priv;
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
ret_val = videobuf_dqbuf(get_queue(fh), p, file->f_flags & O_NONBLOCK); ret_val = videobuf_dqbuf(get_queue(fh), p, file->f_flags & O_NONBLOCK);
p->sequence = dev->vidq[SRAM_CH07].count; p->sequence = dev->vidq[SRAM_CH07].count;
@ -356,14 +356,14 @@ static int vidioc_log_status (struct file *file, void *priv)
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
char name[32 + 2]; char name[32 + 2];
struct sram_channel *sram_ch = &dev->sram_channels[SRAM_CH07]; struct sram_channel *sram_ch = &dev->sram_channels[SRAM_CH07];
u32 tmp = 0; u32 tmp = 0;
snprintf(name, sizeof(name), "%s/2", dev->name); snprintf(name, sizeof(name), "%s/2", dev->name);
printk(KERN_INFO "%s/2: ============ START LOG STATUS ============\n", printk(KERN_INFO "%s/2: ============ START LOG STATUS ============\n",
dev->name); dev->name);
cx25821_call_all(dev, core, log_status); cx25821_call_all(dev, core, log_status);
tmp = cx_read(sram_ch->dma_ctl); tmp = cx_read(sram_ch->dma_ctl);
printk(KERN_INFO "Video input 7 is %s\n", (tmp & 0x11)?"streaming" : "stopped"); printk(KERN_INFO "Video input 7 is %s\n", (tmp & 0x11)?"streaming" : "stopped");
printk(KERN_INFO "%s/2: ============= END LOG STATUS =============\n", printk(KERN_INFO "%s/2: ============= END LOG STATUS =============\n",
@ -375,10 +375,10 @@ static int vidioc_s_ctrl(struct file *file, void *priv,
struct v4l2_control *ctl) struct v4l2_control *ctl)
{ {
struct cx25821_fh *fh = priv; struct cx25821_fh *fh = priv;
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
int err; int err;
if (fh) { if (fh) {
err = v4l2_prio_check(&dev->prio, &fh->prio); err = v4l2_prio_check(&dev->prio, &fh->prio);
if (0 != err) if (0 != err)
return err; return err;

332
drivers/staging/cx25821/cx25821-videoioctl.c
View file

@ -1,7 +1,7 @@
/* /*
* Driver for the Conexant CX25821 PCIe bridge * Driver for the Conexant CX25821 PCIe bridge
* *
* Copyright (C) 2009 Conexant Systems Inc. * Copyright (C) 2009 Conexant Systems Inc.
* Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com> * Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com>
* Based on Steven Toth <stoth@linuxtv.org> cx23885 driver * Based on Steven Toth <stoth@linuxtv.org> cx23885 driver
* *
@ -40,37 +40,37 @@ static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
dprintk(2, "jmp to stopper (0x%x)\n", buf->risc.jmp[1]); dprintk(2, "jmp to stopper (0x%x)\n", buf->risc.jmp[1]);
if (!list_empty(&q->queued)) { if (!list_empty(&q->queued)) {
list_add_tail(&buf->vb.queue, &q->queued); list_add_tail(&buf->vb.queue, &q->queued);
buf->vb.state = VIDEOBUF_QUEUED; buf->vb.state = VIDEOBUF_QUEUED;
dprintk(2, "[%p/%d] buffer_queue - append to queued\n", buf, buf->vb.i); dprintk(2, "[%p/%d] buffer_queue - append to queued\n", buf, buf->vb.i);
} else if (list_empty(&q->active)) { } else if (list_empty(&q->active)) {
list_add_tail(&buf->vb.queue, &q->active); list_add_tail(&buf->vb.queue, &q->active);
cx25821_start_video_dma(dev, q, buf, &dev->sram_channels[VIDEO_IOCTL_CH]); cx25821_start_video_dma(dev, q, buf, &dev->sram_channels[VIDEO_IOCTL_CH]);
buf->vb.state = VIDEOBUF_ACTIVE; buf->vb.state = VIDEOBUF_ACTIVE;
buf->count = q->count++; buf->count = q->count++;
mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT); mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
dprintk(2, "[%p/%d] buffer_queue - first active, buf cnt = %d, q->count = %d\n", dprintk(2, "[%p/%d] buffer_queue - first active, buf cnt = %d, q->count = %d\n",
buf, buf->vb. i, buf->count, q->count); buf, buf->vb. i, buf->count, q->count);
} else { } else {
prev = list_entry(q->active.prev, struct cx25821_buffer, vb.queue); prev = list_entry(q->active.prev, struct cx25821_buffer, vb.queue);
if (prev->vb.width == buf->vb.width && if (prev->vb.width == buf->vb.width &&
prev->vb.height == buf->vb.height && prev->vb.height == buf->vb.height &&
prev->fmt == buf->fmt) { prev->fmt == buf->fmt) {
list_add_tail(&buf->vb.queue, &q->active); list_add_tail(&buf->vb.queue, &q->active);
buf->vb.state = VIDEOBUF_ACTIVE; buf->vb.state = VIDEOBUF_ACTIVE;
buf->count = q->count++; buf->count = q->count++;
prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma); prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
/* 64 bit bits 63-32 */ /* 64 bit bits 63-32 */
prev->risc.jmp[2] = cpu_to_le32(0); prev->risc.jmp[2] = cpu_to_le32(0);
dprintk(2, "[%p/%d] buffer_queue - append to active, buf->count=%d\n", buf, buf->vb.i, buf->count); dprintk(2, "[%p/%d] buffer_queue - append to active, buf->count=%d\n", buf, buf->vb.i, buf->count);
} else { } else {
list_add_tail(&buf->vb.queue, &q->queued); list_add_tail(&buf->vb.queue, &q->queued);
buf->vb.state = VIDEOBUF_QUEUED; buf->vb.state = VIDEOBUF_QUEUED;
dprintk(2, "[%p/%d] buffer_queue - first queued\n", buf, buf->vb.i); dprintk(2, "[%p/%d] buffer_queue - first queued\n", buf, buf->vb.i);
} }
} }
if (list_empty(&q->active)) if (list_empty(&q->active))
@ -100,18 +100,18 @@ static int video_open(struct file *file)
lock_kernel(); lock_kernel();
list_for_each(list, &cx25821_devlist) list_for_each(list, &cx25821_devlist)
{ {
h = list_entry(list, struct cx25821_dev, devlist); h = list_entry(list, struct cx25821_dev, devlist);
if (h->ioctl_dev && h->ioctl_dev->minor == minor) if (h->ioctl_dev && h->ioctl_dev->minor == minor)
{ {
dev = h; dev = h;
type = V4L2_BUF_TYPE_VIDEO_CAPTURE; type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
} }
} }
if (NULL == dev) { if (NULL == dev) {
unlock_kernel(); unlock_kernel();
return -ENODEV; return -ENODEV;
} }
printk("open minor=%d type=%s\n", minor, v4l2_type_names[type]); printk("open minor=%d type=%s\n", minor, v4l2_type_names[type]);
@ -119,8 +119,8 @@ static int video_open(struct file *file)
/* allocate + initialize per filehandle data */ /* allocate + initialize per filehandle data */
fh = kzalloc(sizeof(*fh), GFP_KERNEL); fh = kzalloc(sizeof(*fh), GFP_KERNEL);
if (NULL == fh) { if (NULL == fh) {
unlock_kernel(); unlock_kernel();
return -ENOMEM; return -ENOMEM;
} }
file->private_data = fh; file->private_data = fh;
@ -129,22 +129,22 @@ static int video_open(struct file *file)
fh->width = 720; fh->width = 720;
if(dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK) if(dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK)
fh->height = 576; fh->height = 576;
else else
fh->height = 480; fh->height = 480;
dev->channel_opened = VIDEO_IOCTL_CH; dev->channel_opened = VIDEO_IOCTL_CH;
pix_format = V4L2_PIX_FMT_YUYV; pix_format = V4L2_PIX_FMT_YUYV;
fh->fmt = format_by_fourcc(pix_format); fh->fmt = format_by_fourcc(pix_format);
v4l2_prio_open(&dev->prio,&fh->prio); v4l2_prio_open(&dev->prio,&fh->prio);
videobuf_queue_sg_init(&fh->vidq, &cx25821_video_qops, videobuf_queue_sg_init(&fh->vidq, &cx25821_video_qops,
&dev->pci->dev, &dev->slock, &dev->pci->dev, &dev->slock,
V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_BUF_TYPE_VIDEO_CAPTURE,
V4L2_FIELD_INTERLACED, V4L2_FIELD_INTERLACED,
sizeof(struct cx25821_buffer), sizeof(struct cx25821_buffer),
fh); fh);
dprintk(1, "post videobuf_queue_init()\n"); dprintk(1, "post videobuf_queue_init()\n");
unlock_kernel(); unlock_kernel();
@ -158,15 +158,15 @@ static ssize_t video_read(struct file *file, char __user *data, size_t count, lo
switch (fh->type) switch (fh->type)
{ {
case V4L2_BUF_TYPE_VIDEO_CAPTURE: case V4L2_BUF_TYPE_VIDEO_CAPTURE:
if (res_locked(fh->dev, RESOURCE_VIDEO_IOCTL)) if (res_locked(fh->dev, RESOURCE_VIDEO_IOCTL))
return -EBUSY; return -EBUSY;
return videobuf_read_one(&fh->vidq, data, count, ppos, file->f_flags & O_NONBLOCK); return videobuf_read_one(&fh->vidq, data, count, ppos, file->f_flags & O_NONBLOCK);
default: default:
BUG(); BUG();
return 0; return 0;
} }
} }
@ -176,22 +176,22 @@ static unsigned int video_poll(struct file *file, struct poll_table_struct *wait
struct cx25821_buffer *buf; struct cx25821_buffer *buf;
if (res_check(fh, RESOURCE_VIDEO_IOCTL)) { if (res_check(fh, RESOURCE_VIDEO_IOCTL)) {
/* streaming capture */ /* streaming capture */
if (list_empty(&fh->vidq.stream)) if (list_empty(&fh->vidq.stream))
return POLLERR; return POLLERR;
buf = list_entry(fh->vidq.stream.next, buf = list_entry(fh->vidq.stream.next,
struct cx25821_buffer, vb.stream); struct cx25821_buffer, vb.stream);
} else { } else {
/* read() capture */ /* read() capture */
buf = (struct cx25821_buffer *)fh->vidq.read_buf; buf = (struct cx25821_buffer *)fh->vidq.read_buf;
if (NULL == buf) if (NULL == buf)
return POLLERR; return POLLERR;
} }
poll_wait(file, &buf->vb.done, wait); poll_wait(file, &buf->vb.done, wait);
if (buf->vb.state == VIDEOBUF_DONE || buf->vb.state == VIDEOBUF_ERROR) if (buf->vb.state == VIDEOBUF_DONE || buf->vb.state == VIDEOBUF_ERROR)
return POLLIN|POLLRDNORM; return POLLIN|POLLRDNORM;
return 0; return 0;
} }
@ -199,17 +199,17 @@ static unsigned int video_poll(struct file *file, struct poll_table_struct *wait
static int video_release(struct file *file) static int video_release(struct file *file)
{ {
struct cx25821_fh *fh = file->private_data; struct cx25821_fh *fh = file->private_data;
struct cx25821_dev *dev = fh->dev; struct cx25821_dev *dev = fh->dev;
/* stop video capture */ /* stop video capture */
if (res_check(fh, RESOURCE_VIDEO_IOCTL)) { if (res_check(fh, RESOURCE_VIDEO_IOCTL)) {
videobuf_queue_cancel(&fh->vidq); videobuf_queue_cancel(&fh->vidq);
res_free(dev, fh, RESOURCE_VIDEO_IOCTL); res_free(dev, fh, RESOURCE_VIDEO_IOCTL);
} }
if (fh->vidq.read_buf) { if (fh->vidq.read_buf) {
buffer_release(&fh->vidq, fh->vidq.read_buf); buffer_release(&fh->vidq, fh->vidq.read_buf);
kfree(fh->vidq.read_buf); kfree(fh->vidq.read_buf);
} }
videobuf_mmap_free(&fh->vidq); videobuf_mmap_free(&fh->vidq);
@ -230,17 +230,17 @@ static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
if (unlikely(fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)) if (unlikely(fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE))
{ {
return -EINVAL; return -EINVAL;
} }
if (unlikely(i != fh->type)) if (unlikely(i != fh->type))
{ {
return -EINVAL; return -EINVAL;
} }
if (unlikely(!res_get(dev, fh, get_resource(fh, RESOURCE_VIDEO_IOCTL)))) if (unlikely(!res_get(dev, fh, get_resource(fh, RESOURCE_VIDEO_IOCTL))))
{ {
return -EBUSY; return -EBUSY;
} }
return videobuf_streamon(get_queue(fh)); return videobuf_streamon(get_queue(fh));
@ -253,14 +253,14 @@ static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
int err, res; int err, res;
if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
return -EINVAL; return -EINVAL;
if (i != fh->type) if (i != fh->type)
return -EINVAL; return -EINVAL;
res = get_resource(fh, RESOURCE_VIDEO_IOCTL); res = get_resource(fh, RESOURCE_VIDEO_IOCTL);
err = videobuf_streamoff(get_queue(fh)); err = videobuf_streamoff(get_queue(fh));
if (err < 0) if (err < 0)
return err; return err;
res_free(dev, fh, res); res_free(dev, fh, res);
return 0; return 0;
} }
@ -272,18 +272,18 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, struct v4l2_forma
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
int err; int err;
if (fh) if (fh)
{ {
err = v4l2_prio_check(&dev->prio, &fh->prio); err = v4l2_prio_check(&dev->prio, &fh->prio);
if (0 != err) if (0 != err)
return err; return err;
} }
dprintk(2, "%s()\n", __func__); dprintk(2, "%s()\n", __func__);
err = vidioc_try_fmt_vid_cap(file, priv, f); err = vidioc_try_fmt_vid_cap(file, priv, f);
if (0 != err) if (0 != err)
return err; return err;
fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat); fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat);
fh->width = f->fmt.pix.width; fh->width = f->fmt.pix.width;
fh->height = f->fmt.pix.height; fh->height = f->fmt.pix.height;
@ -299,8 +299,8 @@ static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
return videobuf_dqbuf(get_queue(fh), p, file->f_flags & O_NONBLOCK); return videobuf_dqbuf(get_queue(fh), p, file->f_flags & O_NONBLOCK);
} }
static long video_ioctl_set(struct file *file, unsigned int cmd, unsigned long arg) static long video_ioctl_set(struct file *file, unsigned int cmd, unsigned long arg)
{ {
struct cx25821_fh *fh = file->private_data; struct cx25821_fh *fh = file->private_data;
struct cx25821_dev *dev = fh->dev; struct cx25821_dev *dev = fh->dev;
struct downstream_user_struct *data_from_user; struct downstream_user_struct *data_from_user;
@ -310,96 +310,96 @@ static long video_ioctl_set(struct file *file, unsigned int cmd, unsigned long a
int cif_enable = 0, cif_width = 0; int cif_enable = 0, cif_width = 0;
u32 value = 0; u32 value = 0;
data_from_user = (struct downstream_user_struct *)arg; data_from_user = (struct downstream_user_struct *)arg;
if( !data_from_user ) if( !data_from_user )
{ {
printk("cx25821 in %s(): User data is INVALID. Returning.\n", __func__); printk("cx25821 in %s(): User data is INVALID. Returning.\n", __func__);
return 0; return 0;
} }
command = data_from_user->command; command = data_from_user->command;
if( command != SET_VIDEO_STD && command != SET_PIXEL_FORMAT && command != ENABLE_CIF_RESOLUTION && if( command != SET_VIDEO_STD && command != SET_PIXEL_FORMAT && command != ENABLE_CIF_RESOLUTION &&
command != REG_READ && command != REG_WRITE && command != MEDUSA_READ && command != MEDUSA_WRITE) command != REG_READ && command != REG_WRITE && command != MEDUSA_READ && command != MEDUSA_WRITE)
{ {
return 0; return 0;
} }
switch(command) switch(command)
{ {
case SET_VIDEO_STD: case SET_VIDEO_STD:
dev->tvnorm = !strcmp(data_from_user->vid_stdname,"PAL") ? V4L2_STD_PAL_BG : V4L2_STD_NTSC_M; dev->tvnorm = !strcmp(data_from_user->vid_stdname,"PAL") ? V4L2_STD_PAL_BG : V4L2_STD_NTSC_M;
medusa_set_videostandard(dev); medusa_set_videostandard(dev);
break; break;
case SET_PIXEL_FORMAT:
selected_channel = data_from_user->decoder_select;
pix_format = data_from_user->pixel_format;
if( !(selected_channel <= 7 && selected_channel >= 0) ) case SET_PIXEL_FORMAT:
{ selected_channel = data_from_user->decoder_select;
selected_channel -= 4; pix_format = data_from_user->pixel_format;
selected_channel = selected_channel % 8;
}
if( selected_channel >= 0 )
cx25821_set_pixel_format( dev, selected_channel, pix_format );
break;
case ENABLE_CIF_RESOLUTION:
selected_channel = data_from_user->decoder_select;
cif_enable = data_from_user->cif_resolution_enable;
cif_width = data_from_user->cif_width;
if( cif_enable )
{
if( dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK )
width = 352;
else
width = (cif_width == 320 || cif_width == 352) ? cif_width : 320;
}
if( !(selected_channel <= 7 && selected_channel >= 0) )
{
selected_channel -= 4;
selected_channel = selected_channel % 8;
}
if( selected_channel <= 7 && selected_channel >= 0 )
{
dev->use_cif_resolution[selected_channel] = cif_enable;
dev->cif_width[selected_channel] = width;
}
else
{
for( i=0; i < VID_CHANNEL_NUM; i++ )
{
dev->use_cif_resolution[i] = cif_enable;
dev->cif_width[i] = width;
}
}
medusa_set_resolution( dev, width, selected_channel ); if( !(selected_channel <= 7 && selected_channel >= 0) )
break; {
case REG_READ: selected_channel -= 4;
data_from_user->reg_data = cx_read(data_from_user->reg_address); selected_channel = selected_channel % 8;
break; }
case REG_WRITE:
cx_write(data_from_user->reg_address, data_from_user->reg_data); if( selected_channel >= 0 )
break; cx25821_set_pixel_format( dev, selected_channel, pix_format );
case MEDUSA_READ:
value = cx25821_i2c_read(&dev->i2c_bus[0], (u16)data_from_user->reg_address, &data_from_user->reg_data); break;
break;
case MEDUSA_WRITE: case ENABLE_CIF_RESOLUTION:
cx25821_i2c_write(&dev->i2c_bus[0], (u16)data_from_user->reg_address, data_from_user->reg_data); selected_channel = data_from_user->decoder_select;
break; cif_enable = data_from_user->cif_resolution_enable;
cif_width = data_from_user->cif_width;
if( cif_enable )
{
if( dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK )
width = 352;
else
width = (cif_width == 320 || cif_width == 352) ? cif_width : 320;
}
if( !(selected_channel <= 7 && selected_channel >= 0) )
{
selected_channel -= 4;
selected_channel = selected_channel % 8;
}
if( selected_channel <= 7 && selected_channel >= 0 )
{
dev->use_cif_resolution[selected_channel] = cif_enable;
dev->cif_width[selected_channel] = width;
}
else
{
for( i=0; i < VID_CHANNEL_NUM; i++ )
{
dev->use_cif_resolution[i] = cif_enable;
dev->cif_width[i] = width;
}
}
medusa_set_resolution( dev, width, selected_channel );
break;
case REG_READ:
data_from_user->reg_data = cx_read(data_from_user->reg_address);
break;
case REG_WRITE:
cx_write(data_from_user->reg_address, data_from_user->reg_data);
break;
case MEDUSA_READ:
value = cx25821_i2c_read(&dev->i2c_bus[0], (u16)data_from_user->reg_address, &data_from_user->reg_data);
break;
case MEDUSA_WRITE:
cx25821_i2c_write(&dev->i2c_bus[0], (u16)data_from_user->reg_address, data_from_user->reg_data);
break;
} }
return 0; return 0;
} }
@ -423,12 +423,12 @@ static int vidioc_s_ctrl(struct file *file, void *priv,
struct cx25821_fh *fh = priv; struct cx25821_fh *fh = priv;
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
int err; int err;
if (fh) if (fh)
{ {
err = v4l2_prio_check(&dev->prio, &fh->prio); err = v4l2_prio_check(&dev->prio, &fh->prio);
if (0 != err) if (0 != err)
return err; return err;
} }
return 0; return 0;

208
drivers/staging/cx25821/cx25821-vidups10.c
View file

@ -1,7 +1,7 @@
/* /*
* Driver for the Conexant CX25821 PCIe bridge * Driver for the Conexant CX25821 PCIe bridge
* *
* Copyright (C) 2009 Conexant Systems Inc. * Copyright (C) 2009 Conexant Systems Inc.
* Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com> * Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com>
* Based on Steven Toth <stoth@linuxtv.org> cx23885 driver * Based on Steven Toth <stoth@linuxtv.org> cx23885 driver
* *
@ -41,37 +41,37 @@ static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
dprintk(2, "jmp to stopper (0x%x)\n", buf->risc.jmp[1]); dprintk(2, "jmp to stopper (0x%x)\n", buf->risc.jmp[1]);
if (!list_empty(&q->queued)) { if (!list_empty(&q->queued)) {
list_add_tail(&buf->vb.queue, &q->queued); list_add_tail(&buf->vb.queue, &q->queued);
buf->vb.state = VIDEOBUF_QUEUED; buf->vb.state = VIDEOBUF_QUEUED;
dprintk(2, "[%p/%d] buffer_queue - append to queued\n", buf, buf->vb.i); dprintk(2, "[%p/%d] buffer_queue - append to queued\n", buf, buf->vb.i);
} else if (list_empty(&q->active)) { } else if (list_empty(&q->active)) {
list_add_tail(&buf->vb.queue, &q->active); list_add_tail(&buf->vb.queue, &q->active);
cx25821_start_video_dma(dev, q, buf, &dev->sram_channels[SRAM_CH10]); cx25821_start_video_dma(dev, q, buf, &dev->sram_channels[SRAM_CH10]);
buf->vb.state = VIDEOBUF_ACTIVE; buf->vb.state = VIDEOBUF_ACTIVE;
buf->count = q->count++; buf->count = q->count++;
mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT); mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
dprintk(2, "[%p/%d] buffer_queue - first active, buf cnt = %d, q->count = %d\n", dprintk(2, "[%p/%d] buffer_queue - first active, buf cnt = %d, q->count = %d\n",
buf, buf->vb. i, buf->count, q->count); buf, buf->vb. i, buf->count, q->count);
} else { } else {
prev = list_entry(q->active.prev, struct cx25821_buffer, vb.queue); prev = list_entry(q->active.prev, struct cx25821_buffer, vb.queue);
if (prev->vb.width == buf->vb.width && if (prev->vb.width == buf->vb.width &&
prev->vb.height == buf->vb.height && prev->vb.height == buf->vb.height &&
prev->fmt == buf->fmt) { prev->fmt == buf->fmt) {
list_add_tail(&buf->vb.queue, &q->active); list_add_tail(&buf->vb.queue, &q->active);
buf->vb.state = VIDEOBUF_ACTIVE; buf->vb.state = VIDEOBUF_ACTIVE;
buf->count = q->count++; buf->count = q->count++;
prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma); prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
/* 64 bit bits 63-32 */ /* 64 bit bits 63-32 */
prev->risc.jmp[2] = cpu_to_le32(0); prev->risc.jmp[2] = cpu_to_le32(0);
dprintk(2, "[%p/%d] buffer_queue - append to active, buf->count=%d\n", buf, buf->vb.i, buf->count); dprintk(2, "[%p/%d] buffer_queue - append to active, buf->count=%d\n", buf, buf->vb.i, buf->count);
} else { } else {
list_add_tail(&buf->vb.queue, &q->queued); list_add_tail(&buf->vb.queue, &q->queued);
buf->vb.state = VIDEOBUF_QUEUED; buf->vb.state = VIDEOBUF_QUEUED;
dprintk(2, "[%p/%d] buffer_queue - first queued\n", buf, buf->vb.i); dprintk(2, "[%p/%d] buffer_queue - first queued\n", buf, buf->vb.i);
} }
} }
if (list_empty(&q->active)) if (list_empty(&q->active))
@ -100,17 +100,17 @@ static int video_open(struct file *file)
lock_kernel(); lock_kernel();
list_for_each(list, &cx25821_devlist) list_for_each(list, &cx25821_devlist)
{ {
h = list_entry(list, struct cx25821_dev, devlist); h = list_entry(list, struct cx25821_dev, devlist);
if (h->video_dev[SRAM_CH10] && h->video_dev[SRAM_CH10]->minor == minor) { if (h->video_dev[SRAM_CH10] && h->video_dev[SRAM_CH10]->minor == minor) {
dev = h; dev = h;
type = V4L2_BUF_TYPE_VIDEO_CAPTURE; type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
} }
} }
if (NULL == dev) { if (NULL == dev) {
unlock_kernel(); unlock_kernel();
return -ENODEV; return -ENODEV;
} }
printk("open minor=%d type=%s\n", minor, v4l2_type_names[type]); printk("open minor=%d type=%s\n", minor, v4l2_type_names[type]);
@ -118,8 +118,8 @@ static int video_open(struct file *file)
/* allocate + initialize per filehandle data */ /* allocate + initialize per filehandle data */
fh = kzalloc(sizeof(*fh), GFP_KERNEL); fh = kzalloc(sizeof(*fh), GFP_KERNEL);
if (NULL == fh) { if (NULL == fh) {
unlock_kernel(); unlock_kernel();
return -ENOMEM; return -ENOMEM;
} }
file->private_data = fh; file->private_data = fh;
@ -128,22 +128,22 @@ static int video_open(struct file *file)
fh->width = 720; fh->width = 720;
if(dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK) if(dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK)
fh->height = 576; fh->height = 576;
else else
fh->height = 480; fh->height = 480;
dev->channel_opened = 9; dev->channel_opened = 9;
fh->fmt = format_by_fourcc(V4L2_PIX_FMT_YUYV); fh->fmt = format_by_fourcc(V4L2_PIX_FMT_YUYV);
v4l2_prio_open(&dev->prio,&fh->prio); v4l2_prio_open(&dev->prio,&fh->prio);
videobuf_queue_sg_init(&fh->vidq, &cx25821_video_qops, videobuf_queue_sg_init(&fh->vidq, &cx25821_video_qops,
&dev->pci->dev, &dev->slock, &dev->pci->dev, &dev->slock,
V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_BUF_TYPE_VIDEO_CAPTURE,
V4L2_FIELD_INTERLACED, V4L2_FIELD_INTERLACED,
sizeof(struct cx25821_buffer), sizeof(struct cx25821_buffer),
fh); fh);
dprintk(1, "post videobuf_queue_init()\n"); dprintk(1, "post videobuf_queue_init()\n");
unlock_kernel(); unlock_kernel();
@ -157,15 +157,15 @@ static ssize_t video_read(struct file *file, char __user *data, size_t count, lo
switch (fh->type) switch (fh->type)
{ {
case V4L2_BUF_TYPE_VIDEO_CAPTURE: case V4L2_BUF_TYPE_VIDEO_CAPTURE:
if (res_locked(fh->dev, RESOURCE_VIDEO10)) if (res_locked(fh->dev, RESOURCE_VIDEO10))
return -EBUSY; return -EBUSY;
return videobuf_read_one(&fh->vidq, data, count, ppos, file->f_flags & O_NONBLOCK); return videobuf_read_one(&fh->vidq, data, count, ppos, file->f_flags & O_NONBLOCK);
default: default:
BUG(); BUG();
return 0; return 0;
} }
} }
@ -175,21 +175,21 @@ static unsigned int video_poll(struct file *file, struct poll_table_struct *wait
struct cx25821_buffer *buf; struct cx25821_buffer *buf;
if (res_check(fh, RESOURCE_VIDEO10)) { if (res_check(fh, RESOURCE_VIDEO10)) {
/* streaming capture */ /* streaming capture */
if (list_empty(&fh->vidq.stream)) if (list_empty(&fh->vidq.stream))
return POLLERR; return POLLERR;
buf = list_entry(fh->vidq.stream.next, buf = list_entry(fh->vidq.stream.next,
struct cx25821_buffer, vb.stream); struct cx25821_buffer, vb.stream);
} else { } else {
/* read() capture */ /* read() capture */
buf = (struct cx25821_buffer *)fh->vidq.read_buf; buf = (struct cx25821_buffer *)fh->vidq.read_buf;
if (NULL == buf) if (NULL == buf)
return POLLERR; return POLLERR;
} }
poll_wait(file, &buf->vb.done, wait); poll_wait(file, &buf->vb.done, wait);
if (buf->vb.state == VIDEOBUF_DONE || buf->vb.state == VIDEOBUF_ERROR) if (buf->vb.state == VIDEOBUF_DONE || buf->vb.state == VIDEOBUF_ERROR)
return POLLIN|POLLRDNORM; return POLLIN|POLLRDNORM;
return 0; return 0;
} }
@ -199,17 +199,17 @@ static int video_release(struct file *file)
struct cx25821_dev *dev = fh->dev; struct cx25821_dev *dev = fh->dev;
//stop the risc engine and fifo //stop the risc engine and fifo
//cx_write(channel10->dma_ctl, 0); //cx_write(channel10->dma_ctl, 0);
/* stop video capture */ /* stop video capture */
if (res_check(fh, RESOURCE_VIDEO10)) { if (res_check(fh, RESOURCE_VIDEO10)) {
videobuf_queue_cancel(&fh->vidq); videobuf_queue_cancel(&fh->vidq);
res_free(dev, fh, RESOURCE_VIDEO10); res_free(dev, fh, RESOURCE_VIDEO10);
} }
if (fh->vidq.read_buf) { if (fh->vidq.read_buf) {
buffer_release(&fh->vidq, fh->vidq.read_buf); buffer_release(&fh->vidq, fh->vidq.read_buf);
kfree(fh->vidq.read_buf); kfree(fh->vidq.read_buf);
} }
videobuf_mmap_free(&fh->vidq); videobuf_mmap_free(&fh->vidq);
@ -230,17 +230,17 @@ static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
if (unlikely(fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)) if (unlikely(fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE))
{ {
return -EINVAL; return -EINVAL;
} }
if (unlikely(i != fh->type)) if (unlikely(i != fh->type))
{ {
return -EINVAL; return -EINVAL;
} }
if (unlikely(!res_get(dev, fh, get_resource(fh, RESOURCE_VIDEO10)))) if (unlikely(!res_get(dev, fh, get_resource(fh, RESOURCE_VIDEO10))))
{ {
return -EBUSY; return -EBUSY;
} }
return videobuf_streamon(get_queue(fh)); return videobuf_streamon(get_queue(fh));
@ -253,61 +253,61 @@ static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
int err, res; int err, res;
if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
return -EINVAL; return -EINVAL;
if (i != fh->type) if (i != fh->type)
return -EINVAL; return -EINVAL;
res = get_resource(fh, RESOURCE_VIDEO10); res = get_resource(fh, RESOURCE_VIDEO10);
err = videobuf_streamoff(get_queue(fh)); err = videobuf_streamoff(get_queue(fh));
if (err < 0) if (err < 0)
return err; return err;
res_free(dev, fh, res); res_free(dev, fh, res);
return 0; return 0;
} }
static long video_ioctl_upstream10(struct file *file, unsigned int cmd, unsigned long arg) static long video_ioctl_upstream10(struct file *file, unsigned int cmd, unsigned long arg)
{ {
struct cx25821_fh *fh = file->private_data; struct cx25821_fh *fh = file->private_data;
struct cx25821_dev *dev = fh->dev; struct cx25821_dev *dev = fh->dev;
int command = 0; int command = 0;
struct upstream_user_struct *data_from_user; struct upstream_user_struct *data_from_user;
data_from_user = (struct upstream_user_struct *)arg;
data_from_user = (struct upstream_user_struct *)arg;
if( !data_from_user ) if( !data_from_user )
{ {
printk("cx25821 in %s(): Upstream data is INVALID. Returning.\n", __func__); printk("cx25821 in %s(): Upstream data is INVALID. Returning.\n", __func__);
return 0; return 0;
} }
command = data_from_user->command; command = data_from_user->command;
if( command != UPSTREAM_START_VIDEO && command != UPSTREAM_STOP_VIDEO ) if( command != UPSTREAM_START_VIDEO && command != UPSTREAM_STOP_VIDEO )
{ {
return 0; return 0;
} }
dev->input_filename_ch2 = data_from_user->input_filename; dev->input_filename_ch2 = data_from_user->input_filename;
dev->input_audiofilename = data_from_user->input_filename; dev->input_audiofilename = data_from_user->input_filename;
dev->vid_stdname_ch2 = data_from_user->vid_stdname; dev->vid_stdname_ch2 = data_from_user->vid_stdname;
dev->pixel_format_ch2 = data_from_user->pixel_format; dev->pixel_format_ch2 = data_from_user->pixel_format;
dev->channel_select_ch2 = data_from_user->channel_select; dev->channel_select_ch2 = data_from_user->channel_select;
dev->command_ch2 = data_from_user->command; dev->command_ch2 = data_from_user->command;
switch(command)
{
case UPSTREAM_START_VIDEO:
cx25821_start_upstream_video_ch2(dev, data_from_user);
break;
case UPSTREAM_STOP_VIDEO:
cx25821_stop_upstream_video_ch2(dev); switch(command)
break; {
case UPSTREAM_START_VIDEO:
cx25821_start_upstream_video_ch2(dev, data_from_user);
break;
case UPSTREAM_STOP_VIDEO:
cx25821_stop_upstream_video_ch2(dev);
break;
} }
return 0; return 0;
} }
@ -318,18 +318,18 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, struct v4l2_forma
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
int err; int err;
if (fh) if (fh)
{ {
err = v4l2_prio_check(&dev->prio, &fh->prio); err = v4l2_prio_check(&dev->prio, &fh->prio);
if (0 != err) if (0 != err)
return err; return err;
} }
dprintk(2, "%s()\n", __func__); dprintk(2, "%s()\n", __func__);
err = vidioc_try_fmt_vid_cap(file, priv, f); err = vidioc_try_fmt_vid_cap(file, priv, f);
if (0 != err) if (0 != err)
return err; return err;
fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat); fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat);
fh->width = f->fmt.pix.width; fh->width = f->fmt.pix.width;
fh->height = f->fmt.pix.height; fh->height = f->fmt.pix.height;
@ -366,11 +366,11 @@ static int vidioc_s_ctrl(struct file *file, void *priv,
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
int err; int err;
if (fh) if (fh)
{ {
err = v4l2_prio_check(&dev->prio, &fh->prio); err = v4l2_prio_check(&dev->prio, &fh->prio);
if (0 != err) if (0 != err)
return err; return err;
} }
return 0; return 0;
@ -384,7 +384,7 @@ static const struct v4l2_file_operations video_fops = {
.read = video_read, .read = video_read,
.poll = video_poll, .poll = video_poll,
.mmap = video_mmap, .mmap = video_mmap,
.ioctl = video_ioctl_upstream10, .ioctl = video_ioctl_upstream10,
}; };
static const struct v4l2_ioctl_ops video_ioctl_ops = { static const struct v4l2_ioctl_ops video_ioctl_ops = {

214
drivers/staging/cx25821/cx25821-vidups9.c
View file

@ -1,7 +1,7 @@
/* /*
* Driver for the Conexant CX25821 PCIe bridge * Driver for the Conexant CX25821 PCIe bridge
* *
* Copyright (C) 2009 Conexant Systems Inc. * Copyright (C) 2009 Conexant Systems Inc.
* Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com> * Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com>
* Based on Steven Toth <stoth@linuxtv.org> cx23885 driver * Based on Steven Toth <stoth@linuxtv.org> cx23885 driver
* *
@ -40,37 +40,37 @@ static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
dprintk(2, "jmp to stopper (0x%x)\n", buf->risc.jmp[1]); dprintk(2, "jmp to stopper (0x%x)\n", buf->risc.jmp[1]);
if (!list_empty(&q->queued)) { if (!list_empty(&q->queued)) {
list_add_tail(&buf->vb.queue, &q->queued); list_add_tail(&buf->vb.queue, &q->queued);
buf->vb.state = VIDEOBUF_QUEUED; buf->vb.state = VIDEOBUF_QUEUED;
dprintk(2, "[%p/%d] buffer_queue - append to queued\n", buf, buf->vb.i); dprintk(2, "[%p/%d] buffer_queue - append to queued\n", buf, buf->vb.i);
} else if (list_empty(&q->active)) { } else if (list_empty(&q->active)) {
list_add_tail(&buf->vb.queue, &q->active); list_add_tail(&buf->vb.queue, &q->active);
cx25821_start_video_dma(dev, q, buf, &dev->sram_channels[SRAM_CH09]); cx25821_start_video_dma(dev, q, buf, &dev->sram_channels[SRAM_CH09]);
buf->vb.state = VIDEOBUF_ACTIVE; buf->vb.state = VIDEOBUF_ACTIVE;
buf->count = q->count++; buf->count = q->count++;
mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT); mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
dprintk(2, "[%p/%d] buffer_queue - first active, buf cnt = %d, q->count = %d\n", dprintk(2, "[%p/%d] buffer_queue - first active, buf cnt = %d, q->count = %d\n",
buf, buf->vb. i, buf->count, q->count); buf, buf->vb. i, buf->count, q->count);
} else { } else {
prev = list_entry(q->active.prev, struct cx25821_buffer, vb.queue); prev = list_entry(q->active.prev, struct cx25821_buffer, vb.queue);
if (prev->vb.width == buf->vb.width && if (prev->vb.width == buf->vb.width &&
prev->vb.height == buf->vb.height && prev->vb.height == buf->vb.height &&
prev->fmt == buf->fmt) { prev->fmt == buf->fmt) {
list_add_tail(&buf->vb.queue, &q->active); list_add_tail(&buf->vb.queue, &q->active);
buf->vb.state = VIDEOBUF_ACTIVE; buf->vb.state = VIDEOBUF_ACTIVE;
buf->count = q->count++; buf->count = q->count++;
prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma); prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
/* 64 bit bits 63-32 */ /* 64 bit bits 63-32 */
prev->risc.jmp[2] = cpu_to_le32(0); prev->risc.jmp[2] = cpu_to_le32(0);
dprintk(2, "[%p/%d] buffer_queue - append to active, buf->count=%d\n", buf, buf->vb.i, buf->count); dprintk(2, "[%p/%d] buffer_queue - append to active, buf->count=%d\n", buf, buf->vb.i, buf->count);
} else { } else {
list_add_tail(&buf->vb.queue, &q->queued); list_add_tail(&buf->vb.queue, &q->queued);
buf->vb.state = VIDEOBUF_QUEUED; buf->vb.state = VIDEOBUF_QUEUED;
dprintk(2, "[%p/%d] buffer_queue - first queued\n", buf, buf->vb.i); dprintk(2, "[%p/%d] buffer_queue - first queued\n", buf, buf->vb.i);
} }
} }
if (list_empty(&q->active)) if (list_empty(&q->active))
@ -99,18 +99,18 @@ static int video_open(struct file *file)
lock_kernel(); lock_kernel();
list_for_each(list, &cx25821_devlist) list_for_each(list, &cx25821_devlist)
{ {
h = list_entry(list, struct cx25821_dev, devlist); h = list_entry(list, struct cx25821_dev, devlist);
if (h->video_dev[SRAM_CH09] && h->video_dev[SRAM_CH09]->minor == minor) if (h->video_dev[SRAM_CH09] && h->video_dev[SRAM_CH09]->minor == minor)
{ {
dev = h; dev = h;
type = V4L2_BUF_TYPE_VIDEO_CAPTURE; type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
} }
} }
if (NULL == dev) { if (NULL == dev) {
unlock_kernel(); unlock_kernel();
return -ENODEV; return -ENODEV;
} }
printk("open minor=%d type=%s\n", minor, v4l2_type_names[type]); printk("open minor=%d type=%s\n", minor, v4l2_type_names[type]);
@ -118,8 +118,8 @@ static int video_open(struct file *file)
/* allocate + initialize per filehandle data */ /* allocate + initialize per filehandle data */
fh = kzalloc(sizeof(*fh), GFP_KERNEL); fh = kzalloc(sizeof(*fh), GFP_KERNEL);
if (NULL == fh) { if (NULL == fh) {
unlock_kernel(); unlock_kernel();
return -ENOMEM; return -ENOMEM;
} }
file->private_data = fh; file->private_data = fh;
@ -128,9 +128,9 @@ static int video_open(struct file *file)
fh->width = 720; fh->width = 720;
if(dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK) if(dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK)
fh->height = 576; fh->height = 576;
else else
fh->height = 480; fh->height = 480;
dev->channel_opened = 8; dev->channel_opened = 8;
fh->fmt = format_by_fourcc(V4L2_PIX_FMT_YUYV); fh->fmt = format_by_fourcc(V4L2_PIX_FMT_YUYV);
@ -138,11 +138,11 @@ static int video_open(struct file *file)
v4l2_prio_open(&dev->prio,&fh->prio); v4l2_prio_open(&dev->prio,&fh->prio);
videobuf_queue_sg_init(&fh->vidq, &cx25821_video_qops, videobuf_queue_sg_init(&fh->vidq, &cx25821_video_qops,
&dev->pci->dev, &dev->slock, &dev->pci->dev, &dev->slock,
V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_BUF_TYPE_VIDEO_CAPTURE,
V4L2_FIELD_INTERLACED, V4L2_FIELD_INTERLACED,
sizeof(struct cx25821_buffer), sizeof(struct cx25821_buffer),
fh); fh);
dprintk(1, "post videobuf_queue_init()\n"); dprintk(1, "post videobuf_queue_init()\n");
unlock_kernel(); unlock_kernel();
@ -156,15 +156,15 @@ static ssize_t video_read(struct file *file, char __user *data, size_t count, lo
switch (fh->type) switch (fh->type)
{ {
case V4L2_BUF_TYPE_VIDEO_CAPTURE: case V4L2_BUF_TYPE_VIDEO_CAPTURE:
if (res_locked(fh->dev, RESOURCE_VIDEO9)) if (res_locked(fh->dev, RESOURCE_VIDEO9))
return -EBUSY; return -EBUSY;
return videobuf_read_one(&fh->vidq, data, count, ppos, file->f_flags & O_NONBLOCK); return videobuf_read_one(&fh->vidq, data, count, ppos, file->f_flags & O_NONBLOCK);
default: default:
BUG(); BUG();
return 0; return 0;
} }
} }
@ -174,21 +174,21 @@ static unsigned int video_poll(struct file *file, struct poll_table_struct *wait
struct cx25821_buffer *buf; struct cx25821_buffer *buf;
if (res_check(fh, RESOURCE_VIDEO9)) { if (res_check(fh, RESOURCE_VIDEO9)) {
/* streaming capture */ /* streaming capture */
if (list_empty(&fh->vidq.stream)) if (list_empty(&fh->vidq.stream))
return POLLERR; return POLLERR;
buf = list_entry(fh->vidq.stream.next, buf = list_entry(fh->vidq.stream.next,
struct cx25821_buffer, vb.stream); struct cx25821_buffer, vb.stream);
} else { } else {
/* read() capture */ /* read() capture */
buf = (struct cx25821_buffer *)fh->vidq.read_buf; buf = (struct cx25821_buffer *)fh->vidq.read_buf;
if (NULL == buf) if (NULL == buf)
return POLLERR; return POLLERR;
} }
poll_wait(file, &buf->vb.done, wait); poll_wait(file, &buf->vb.done, wait);
if (buf->vb.state == VIDEOBUF_DONE || buf->vb.state == VIDEOBUF_ERROR) if (buf->vb.state == VIDEOBUF_DONE || buf->vb.state == VIDEOBUF_ERROR)
return POLLIN|POLLRDNORM; return POLLIN|POLLRDNORM;
return 0; return 0;
} }
@ -199,17 +199,17 @@ static int video_release(struct file *file)
struct cx25821_dev *dev = fh->dev; struct cx25821_dev *dev = fh->dev;
//stop the risc engine and fifo //stop the risc engine and fifo
//cx_write(channel9->dma_ctl, 0); //cx_write(channel9->dma_ctl, 0);
/* stop video capture */ /* stop video capture */
if (res_check(fh, RESOURCE_VIDEO9)) { if (res_check(fh, RESOURCE_VIDEO9)) {
videobuf_queue_cancel(&fh->vidq); videobuf_queue_cancel(&fh->vidq);
res_free(dev, fh, RESOURCE_VIDEO9); res_free(dev, fh, RESOURCE_VIDEO9);
} }
if (fh->vidq.read_buf) { if (fh->vidq.read_buf) {
buffer_release(&fh->vidq, fh->vidq.read_buf); buffer_release(&fh->vidq, fh->vidq.read_buf);
kfree(fh->vidq.read_buf); kfree(fh->vidq.read_buf);
} }
videobuf_mmap_free(&fh->vidq); videobuf_mmap_free(&fh->vidq);
@ -230,17 +230,17 @@ static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
if (unlikely(fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)) if (unlikely(fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE))
{ {
return -EINVAL; return -EINVAL;
} }
if (unlikely(i != fh->type)) if (unlikely(i != fh->type))
{ {
return -EINVAL; return -EINVAL;
} }
if (unlikely(!res_get(dev, fh, get_resource(fh, RESOURCE_VIDEO9)))) if (unlikely(!res_get(dev, fh, get_resource(fh, RESOURCE_VIDEO9))))
{ {
return -EBUSY; return -EBUSY;
} }
return videobuf_streamon(get_queue(fh)); return videobuf_streamon(get_queue(fh));
@ -253,62 +253,62 @@ static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
int err, res; int err, res;
if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
return -EINVAL; return -EINVAL;
if (i != fh->type) if (i != fh->type)
return -EINVAL; return -EINVAL;
res = get_resource(fh, RESOURCE_VIDEO9); res = get_resource(fh, RESOURCE_VIDEO9);
err = videobuf_streamoff(get_queue(fh)); err = videobuf_streamoff(get_queue(fh));
if (err < 0) if (err < 0)
return err; return err;
res_free(dev, fh, res); res_free(dev, fh, res);
return 0; return 0;
} }
static long video_ioctl_upstream9(struct file *file, unsigned int cmd, unsigned long arg) static long video_ioctl_upstream9(struct file *file, unsigned int cmd, unsigned long arg)
{ {
struct cx25821_fh *fh = file->private_data; struct cx25821_fh *fh = file->private_data;
struct cx25821_dev *dev = fh->dev; struct cx25821_dev *dev = fh->dev;
int command = 0; int command = 0;
struct upstream_user_struct *data_from_user; struct upstream_user_struct *data_from_user;
data_from_user = (struct upstream_user_struct *)arg; data_from_user = (struct upstream_user_struct *)arg;
if( !data_from_user ) if( !data_from_user )
{ {
printk("cx25821 in %s(): Upstream data is INVALID. Returning.\n", __func__); printk("cx25821 in %s(): Upstream data is INVALID. Returning.\n", __func__);
return 0; return 0;
} }
command = data_from_user->command; command = data_from_user->command;
if( command != UPSTREAM_START_VIDEO && command != UPSTREAM_STOP_VIDEO ) if( command != UPSTREAM_START_VIDEO && command != UPSTREAM_STOP_VIDEO )
{ {
return 0; return 0;
} }
dev->input_filename = data_from_user->input_filename; dev->input_filename = data_from_user->input_filename;
dev->input_audiofilename = data_from_user->input_filename; dev->input_audiofilename = data_from_user->input_filename;
dev->vid_stdname = data_from_user->vid_stdname; dev->vid_stdname = data_from_user->vid_stdname;
dev->pixel_format = data_from_user->pixel_format; dev->pixel_format = data_from_user->pixel_format;
dev->channel_select = data_from_user->channel_select; dev->channel_select = data_from_user->channel_select;
dev->command = data_from_user->command; dev->command = data_from_user->command;
switch(command) switch(command)
{ {
case UPSTREAM_START_VIDEO: case UPSTREAM_START_VIDEO:
cx25821_start_upstream_video_ch1(dev, data_from_user); cx25821_start_upstream_video_ch1(dev, data_from_user);
break; break;
case UPSTREAM_STOP_VIDEO: case UPSTREAM_STOP_VIDEO:
cx25821_stop_upstream_video_ch1(dev); cx25821_stop_upstream_video_ch1(dev);
break; break;
} }
return 0; return 0;
} }
@ -319,18 +319,18 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, struct v4l2_forma
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
int err; int err;
if (fh) if (fh)
{ {
err = v4l2_prio_check(&dev->prio, &fh->prio); err = v4l2_prio_check(&dev->prio, &fh->prio);
if (0 != err) if (0 != err)
return err; return err;
} }
dprintk(2, "%s()\n", __func__); dprintk(2, "%s()\n", __func__);
err = vidioc_try_fmt_vid_cap(file, priv, f); err = vidioc_try_fmt_vid_cap(file, priv, f);
if (0 != err) if (0 != err)
return err; return err;
fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat); fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat);
fh->width = f->fmt.pix.width; fh->width = f->fmt.pix.width;
fh->height = f->fmt.pix.height; fh->height = f->fmt.pix.height;
@ -365,11 +365,11 @@ static int vidioc_s_ctrl(struct file *file, void *priv,
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
struct cx25821_fh *fh = priv; struct cx25821_fh *fh = priv;
int err; int err;
if (fh) if (fh)
{ {
err = v4l2_prio_check(&dev->prio, &fh->prio); err = v4l2_prio_check(&dev->prio, &fh->prio);
if (0 != err) if (0 != err)
return err; return err;
} }
return 0; return 0;
@ -382,7 +382,7 @@ static const struct v4l2_file_operations video_fops = {
.read = video_read, .read = video_read,
.poll = video_poll, .poll = video_poll,
.mmap = video_mmap, .mmap = video_mmap,
.ioctl = video_ioctl_upstream9, .ioctl = video_ioctl_upstream9,
}; };
static const struct v4l2_ioctl_ops video_ioctl_ops = { static const struct v4l2_ioctl_ops video_ioctl_ops = {

112
drivers/staging/cx25821/cx25821.h
View file

@ -1,7 +1,7 @@
/* /*
* Driver for the Conexant CX25821 PCIe bridge * Driver for the Conexant CX25821 PCIe bridge
* *
* Copyright (C) 2009 Conexant Systems Inc. * Copyright (C) 2009 Conexant Systems Inc.
* Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com> * Authors <shu.lin@conexant.com>, <hiep.huynh@conexant.com>
* Based on Steven Toth <stoth@linuxtv.org> cx23885 driver * Based on Steven Toth <stoth@linuxtv.org> cx23885 driver
* *
@ -35,7 +35,7 @@
#include <linux/smp_lock.h> #include <linux/smp_lock.h>
#include <media/v4l2-common.h> #include <media/v4l2-common.h>
#include <media/v4l2-device.h> #include <media/v4l2-device.h>
#include <media/tuner.h> #include <media/tuner.h>
#include <media/tveeprom.h> #include <media/tveeprom.h>
#include <media/videobuf-dma-sg.h> #include <media/videobuf-dma-sg.h>
@ -62,7 +62,7 @@
#define FALSE 0 #define FALSE 0
#define LINE_SIZE_D1 1440 #define LINE_SIZE_D1 1440
// Number of decoders and encoders // Number of decoders and encoders
#define MAX_DECODERS 8 #define MAX_DECODERS 8
#define MAX_ENCODERS 2 #define MAX_ENCODERS 2
#define QUAD_DECODERS 4 #define QUAD_DECODERS 4
@ -91,7 +91,7 @@
#define UNKNOWN_BOARD 0 #define UNKNOWN_BOARD 0
#define CX25821_BOARD 1 #define CX25821_BOARD 1
/* Currently supported by the driver */ /* Currently supported by the driver */
#define CX25821_NORMS (\ #define CX25821_NORMS (\
V4L2_STD_NTSC_M | V4L2_STD_NTSC_M_JP | V4L2_STD_NTSC_M_KR | \ V4L2_STD_NTSC_M | V4L2_STD_NTSC_M_JP | V4L2_STD_NTSC_M_KR | \
V4L2_STD_PAL_BG | V4L2_STD_PAL_DK | V4L2_STD_PAL_I | \ V4L2_STD_PAL_BG | V4L2_STD_PAL_DK | V4L2_STD_PAL_I | \
@ -292,7 +292,7 @@ struct cx25821_dev {
struct cx25821_data timeout_data[MAX_VID_CHANNEL_NUM]; struct cx25821_data timeout_data[MAX_VID_CHANNEL_NUM];
/* Analog Audio Upstream */ /* Analog Audio Upstream */
int _audio_is_running; int _audio_is_running;
int _audiopixel_format; int _audiopixel_format;
int _is_first_audio_frame; int _is_first_audio_frame;
int _audiofile_status; int _audiofile_status;
@ -311,7 +311,7 @@ struct cx25821_dev {
unsigned int _audiodata_buf_size; unsigned int _audiodata_buf_size;
__le32 * _audiodata_buf_virt_addr; __le32 * _audiodata_buf_virt_addr;
dma_addr_t _audiodata_buf_phys_addr; dma_addr_t _audiodata_buf_phys_addr;
char *_audiofilename; char *_audiofilename;
/* V4l */ /* V4l */
u32 freq; u32 freq;
@ -322,7 +322,7 @@ struct cx25821_dev {
struct cx25821_dmaqueue vidq[MAX_VID_CHANNEL_NUM]; struct cx25821_dmaqueue vidq[MAX_VID_CHANNEL_NUM];
spinlock_t slock; spinlock_t slock;
/* Video Upstream */ /* Video Upstream */
int _line_size; int _line_size;
int _prog_cnt; int _prog_cnt;
@ -343,8 +343,8 @@ struct cx25821_dev {
unsigned int _data_buf_size; unsigned int _data_buf_size;
__le32 * _data_buf_virt_addr; __le32 * _data_buf_virt_addr;
dma_addr_t _data_buf_phys_addr; dma_addr_t _data_buf_phys_addr;
char * _filename; char * _filename;
char * _defaultname; char * _defaultname;
int _line_size_ch2; int _line_size_ch2;
@ -366,8 +366,8 @@ struct cx25821_dev {
unsigned int _data_buf_size_ch2; unsigned int _data_buf_size_ch2;
__le32 * _data_buf_virt_addr_ch2; __le32 * _data_buf_virt_addr_ch2;
dma_addr_t _data_buf_phys_addr_ch2; dma_addr_t _data_buf_phys_addr_ch2;
char * _filename_ch2; char * _filename_ch2;
char * _defaultname_ch2; char * _defaultname_ch2;
/* MPEG Encoder ONLY settings */ /* MPEG Encoder ONLY settings */
u32 cx23417_mailbox; u32 cx23417_mailbox;
@ -375,26 +375,26 @@ struct cx25821_dev {
struct video_device *v4l_device; struct video_device *v4l_device;
atomic_t v4l_reader_count; atomic_t v4l_reader_count;
struct cx25821_tvnorm encodernorm; struct cx25821_tvnorm encodernorm;
u32 upstream_riscbuf_size; u32 upstream_riscbuf_size;
u32 upstream_databuf_size; u32 upstream_databuf_size;
u32 upstream_riscbuf_size_ch2; u32 upstream_riscbuf_size_ch2;
u32 upstream_databuf_size_ch2; u32 upstream_databuf_size_ch2;
u32 audio_upstream_riscbuf_size; u32 audio_upstream_riscbuf_size;
u32 audio_upstream_databuf_size; u32 audio_upstream_databuf_size;
int _isNTSC; int _isNTSC;
int _frame_index; int _frame_index;
int _audioframe_index; int _audioframe_index;
struct workqueue_struct * _irq_queues; struct workqueue_struct * _irq_queues;
struct work_struct _irq_work_entry; struct work_struct _irq_work_entry;
struct workqueue_struct * _irq_queues_ch2; struct workqueue_struct * _irq_queues_ch2;
struct work_struct _irq_work_entry_ch2; struct work_struct _irq_work_entry_ch2;
struct workqueue_struct * _irq_audio_queues; struct workqueue_struct * _irq_audio_queues;
struct work_struct _audio_work_entry; struct work_struct _audio_work_entry;
char *input_filename; char *input_filename;
char *input_filename_ch2; char *input_filename_ch2;
int _frame_index_ch2; int _frame_index_ch2;
int _isNTSC_ch2; int _isNTSC_ch2;
char *vid_stdname_ch2; char *vid_stdname_ch2;
int pixel_format_ch2; int pixel_format_ch2;
int channel_select_ch2; int channel_select_ch2;
@ -439,7 +439,7 @@ static inline struct cx25821_dev *get_cx25821(struct v4l2_device *v4l2_dev)
#define cx25821_call_all(dev, o, f, args...) \ #define cx25821_call_all(dev, o, f, args...) \
v4l2_device_call_all(&dev->v4l2_dev, 0, o, f, ##args) v4l2_device_call_all(&dev->v4l2_dev, 0, o, f, ##args)
extern struct list_head cx25821_devlist; extern struct list_head cx25821_devlist;
extern struct cx25821_board cx25821_boards[]; extern struct cx25821_board cx25821_boards[];
extern struct cx25821_subid cx25821_subids[]; extern struct cx25821_subid cx25821_subids[];
@ -487,16 +487,16 @@ struct sram_channel {
u32 aud_cfg; u32 aud_cfg;
u32 fld_aud_fifo_en; u32 fld_aud_fifo_en;
u32 fld_aud_risc_en; u32 fld_aud_risc_en;
//For Upstream Video //For Upstream Video
u32 vid_fmt_ctl; u32 vid_fmt_ctl;
u32 vid_active_ctl1; u32 vid_active_ctl1;
u32 vid_active_ctl2; u32 vid_active_ctl2;
u32 vid_cdt_size; u32 vid_cdt_size;
u32 vip_ctl; u32 vip_ctl;
u32 pix_frmt; u32 pix_frmt;
u32 jumponly; u32 jumponly;
u32 irq_bit; u32 irq_bit;
}; };
extern struct sram_channel cx25821_sram_channels[]; extern struct sram_channel cx25821_sram_channels[];
@ -529,9 +529,9 @@ extern int cx25821_i2c_write(struct cx25821_i2c *bus, u16 reg_addr, int value);
extern int cx25821_i2c_unregister(struct cx25821_i2c *bus); extern int cx25821_i2c_unregister(struct cx25821_i2c *bus);
extern void cx25821_gpio_init(struct cx25821_dev *dev); extern void cx25821_gpio_init(struct cx25821_dev *dev);
extern void cx25821_set_gpiopin_direction( struct cx25821_dev *dev, extern void cx25821_set_gpiopin_direction( struct cx25821_dev *dev,
int pin_number, int pin_number,
int pin_logic_value); int pin_logic_value);
extern int medusa_video_init(struct cx25821_dev *dev); extern int medusa_video_init(struct cx25821_dev *dev);
extern int medusa_set_videostandard(struct cx25821_dev *dev); extern int medusa_set_videostandard(struct cx25821_dev *dev);
extern void medusa_set_resolution(struct cx25821_dev *dev, int width, int decoder_select); extern void medusa_set_resolution(struct cx25821_dev *dev, int width, int decoder_select);
@ -543,18 +543,18 @@ extern int medusa_set_saturation(struct cx25821_dev *dev, int saturation, int d
extern int cx25821_sram_channel_setup(struct cx25821_dev *dev, struct sram_channel *ch, unsigned int bpl, u32 risc); extern int cx25821_sram_channel_setup(struct cx25821_dev *dev, struct sram_channel *ch, unsigned int bpl, u32 risc);
extern int cx25821_risc_buffer(struct pci_dev *pci, struct btcx_riscmem *risc, extern int cx25821_risc_buffer(struct pci_dev *pci, struct btcx_riscmem *risc,
struct scatterlist *sglist, struct scatterlist *sglist,
unsigned int top_offset, unsigned int top_offset,
unsigned int bottom_offset, unsigned int bottom_offset,
unsigned int bpl, unsigned int bpl,
unsigned int padding, unsigned int padding,
unsigned int lines); unsigned int lines);
extern int cx25821_risc_databuffer_audio(struct pci_dev *pci, extern int cx25821_risc_databuffer_audio(struct pci_dev *pci,
struct btcx_riscmem *risc, struct btcx_riscmem *risc,
struct scatterlist *sglist, struct scatterlist *sglist,
unsigned int bpl, unsigned int bpl,
unsigned int lines, unsigned int lines,
unsigned int lpi); unsigned int lpi);
extern void cx25821_free_buffer(struct videobuf_queue *q, struct cx25821_buffer *buf); extern void cx25821_free_buffer(struct videobuf_queue *q, struct cx25821_buffer *buf);
extern int cx25821_risc_stopper(struct pci_dev *pci, struct btcx_riscmem *risc,u32 reg, u32 mask, u32 value); extern int cx25821_risc_stopper(struct pci_dev *pci, struct btcx_riscmem *risc,u32 reg, u32 mask, u32 value);
extern void cx25821_sram_channel_dump(struct cx25821_dev *dev, struct sram_channel *ch); extern void cx25821_sram_channel_dump(struct cx25821_dev *dev, struct sram_channel *ch);
@ -565,26 +565,26 @@ extern struct cx25821_dev* cx25821_dev_get(struct pci_dev *pci);
extern void cx25821_print_irqbits(char *name, char *tag, char **strings, int len, u32 bits, u32 mask); extern void cx25821_print_irqbits(char *name, char *tag, char **strings, int len, u32 bits, u32 mask);
extern void cx25821_dev_unregister(struct cx25821_dev *dev); extern void cx25821_dev_unregister(struct cx25821_dev *dev);
extern int cx25821_sram_channel_setup_audio(struct cx25821_dev *dev, extern int cx25821_sram_channel_setup_audio(struct cx25821_dev *dev,
struct sram_channel *ch, struct sram_channel *ch,
unsigned int bpl, u32 risc); unsigned int bpl, u32 risc);
extern int cx25821_vidupstream_init_ch1(struct cx25821_dev *dev, int channel_select, int pixel_format); extern int cx25821_vidupstream_init_ch1(struct cx25821_dev *dev, int channel_select, int pixel_format);
extern int cx25821_vidupstream_init_ch2(struct cx25821_dev *dev, int channel_select, int pixel_format); extern int cx25821_vidupstream_init_ch2(struct cx25821_dev *dev, int channel_select, int pixel_format);
extern int cx25821_audio_upstream_init(struct cx25821_dev *dev, int channel_select); extern int cx25821_audio_upstream_init(struct cx25821_dev *dev, int channel_select);
extern void cx25821_free_mem_upstream_ch1(struct cx25821_dev *dev); extern void cx25821_free_mem_upstream_ch1(struct cx25821_dev *dev);
extern void cx25821_free_mem_upstream_ch2(struct cx25821_dev *dev); extern void cx25821_free_mem_upstream_ch2(struct cx25821_dev *dev);
extern void cx25821_free_mem_upstream_audio(struct cx25821_dev *dev); extern void cx25821_free_mem_upstream_audio(struct cx25821_dev *dev);
extern void cx25821_start_upstream_video_ch1(struct cx25821_dev *dev, struct upstream_user_struct *up_data); extern void cx25821_start_upstream_video_ch1(struct cx25821_dev *dev, struct upstream_user_struct *up_data);
extern void cx25821_start_upstream_video_ch2(struct cx25821_dev *dev, struct upstream_user_struct *up_data); extern void cx25821_start_upstream_video_ch2(struct cx25821_dev *dev, struct upstream_user_struct *up_data);
extern void cx25821_start_upstream_audio(struct cx25821_dev *dev, struct upstream_user_struct *up_data); extern void cx25821_start_upstream_audio(struct cx25821_dev *dev, struct upstream_user_struct *up_data);
extern void cx25821_stop_upstream_video_ch1(struct cx25821_dev *dev); extern void cx25821_stop_upstream_video_ch1(struct cx25821_dev *dev);
extern void cx25821_stop_upstream_video_ch2(struct cx25821_dev *dev); extern void cx25821_stop_upstream_video_ch2(struct cx25821_dev *dev);
extern void cx25821_stop_upstream_audio(struct cx25821_dev *dev); extern void cx25821_stop_upstream_audio(struct cx25821_dev *dev);
extern int cx25821_sram_channel_setup_upstream( struct cx25821_dev *dev, struct sram_channel *ch, unsigned int bpl, u32 risc); extern int cx25821_sram_channel_setup_upstream( struct cx25821_dev *dev, struct sram_channel *ch, unsigned int bpl, u32 risc);
extern void cx25821_set_pixel_format(struct cx25821_dev *dev, int channel, u32 format); extern void cx25821_set_pixel_format(struct cx25821_dev *dev, int channel, u32 format);
extern void cx25821_videoioctl_unregister(struct cx25821_dev *dev); extern void cx25821_videoioctl_unregister(struct cx25821_dev *dev);
extern struct video_device *cx25821_vdev_init(struct cx25821_dev *dev, extern struct video_device *cx25821_vdev_init(struct cx25821_dev *dev,
struct pci_dev *pci, struct pci_dev *pci,
struct video_device *template, struct video_device *template,
char *type); char *type);
#endif #endif