Skip to content

L
linux
Commit a5d0568e authored by Mauro Carvalho Chehab's avatar Mauro Carvalho Chehab
Browse files
Options

Merge branch 'topic/cx25821' into patchwork 

* topic/cx25821: (31 commits)
  [media] cx25821: remove cx25821-audio-upstream.c from the Makefile
  [media] cx25821: replace custom ioctls with write()
  [media] cx25821: drop cx25821-video-upstream-ch2.c/h
  [media] cx25821: add output format ioctls
  [media] cx25821: prepare querycap for output support
  [media] cx25821: group all fmt functions together
  [media] cx25821: setup output nodes correctly
  [media] cx25821: remove references to subdevices that aren't there
  [media] cx25821: remove custom ioctls that duplicate v4l2 ioctls
  [media] cx25821: g/s/try/enum_fmt related fixes and cleanups
  [media] cx25821: switch to v4l2_fh, add event and prio handling
  [media] cx25821: replace resource management functions with fh ownership
  [media] cx25821: move vidq from cx25821_fh to cx25821_channel
  [media] cx25821: remove 'type' field from cx25821_fh
  [media] cx25821: use core locking
  [media] cx25821: remove unnecessary debug messages
  [media] cx25821: remove TRUE/FALSE/STATUS_(UN)SUCCESSFUL defines
  [media] cx25821: convert to the control framework
  [media] cx25821: embed video_device, clean up some kernel log spam
  [media] cx25821: remove bogus dependencies
  ...
parents 966a1601 486a7a28
Show whitespace changes
Inline Side-by-side
Showing with 790 additions and 3253 deletions
drivers/media/pci/cx25821/Kconfig
View file @ a5d0568e
config VIDEO_CX25821 config VIDEO_CX25821
tristate "Conexant cx25821 support" tristate "Conexant cx25821 support"
depends on DVB_CORE && VIDEO_DEV && PCI && I2C depends on VIDEO_DEV && PCI && I2C
select I2C_ALGOBIT select I2C_ALGOBIT
select VIDEO_BTCX select VIDEO_BTCX
select VIDEO_TVEEPROM
depends on RC_CORE
select VIDEOBUF_DVB
select VIDEOBUF_DMA_SG select VIDEOBUF_DMA_SG
select VIDEO_CX25840
select VIDEO_CX2341X
---help--- ---help---
This is a video4linux driver for Conexant 25821 based This is a video4linux driver for Conexant 25821 based
TV cards. TV cards.
......
drivers/media/pci/cx25821/Makefile
View file @ a5d0568e
cx25821-y := cx25821-core.o cx25821-cards.o cx25821-i2c.o \ cx25821-y := cx25821-core.o cx25821-cards.o cx25821-i2c.o \
cx25821-gpio.o cx25821-medusa-video.o \ cx25821-gpio.o cx25821-medusa-video.o \
cx25821-video.o cx25821-video-upstream.o \ cx25821-video.o cx25821-video-upstream.o
cx25821-video-upstream-ch2.o \
cx25821-audio-upstream.o
obj-$(CONFIG_VIDEO_CX25821) += cx25821.o obj-$(CONFIG_VIDEO_CX25821) += cx25821.o
obj-$(CONFIG_VIDEO_CX25821_ALSA) += cx25821-alsa.o obj-$(CONFIG_VIDEO_CX25821_ALSA) += cx25821-alsa.o
ccflags-y += -Idrivers/media/i2c ccflags-y += -Idrivers/media/i2c
ccflags-y += -Idrivers/media/common ccflags-y += -Idrivers/media/common
ccflags-y += -Idrivers/media/tuners
ccflags-y += -Idrivers/media/dvb-core
ccflags-y += -Idrivers/media/dvb-frontends
drivers/media/pci/cx25821/cx25821-alsa.c
View file @ a5d0568e
...@@ -59,7 +59,6 @@ do { \ ...@@ -59,7 +59,6 @@ do { \
Data type declarations - Can be moded to a header file later Data type declarations - Can be moded to a header file later
****************************************************************************/ ****************************************************************************/
static struct snd_card *snd_cx25821_cards[SNDRV_CARDS];
static int devno; static int devno;
struct cx25821_audio_buffer { struct cx25821_audio_buffer {
...@@ -151,7 +150,7 @@ static int _cx25821_start_audio_dma(struct cx25821_audio_dev *chip) ...@@ -151,7 +150,7 @@ static int _cx25821_start_audio_dma(struct cx25821_audio_dev *chip)
{ {
struct cx25821_audio_buffer *buf = chip->buf; struct cx25821_audio_buffer *buf = chip->buf;
struct cx25821_dev *dev = chip->dev; struct cx25821_dev *dev = chip->dev;
struct sram_channel *audio_ch = const struct sram_channel *audio_ch =
&cx25821_sram_channels[AUDIO_SRAM_CHANNEL]; &cx25821_sram_channels[AUDIO_SRAM_CHANNEL];
u32 tmp = 0; u32 tmp = 0;
...@@ -626,34 +625,6 @@ static DEFINE_PCI_DEVICE_TABLE(cx25821_audio_pci_tbl) = { ...@@ -626,34 +625,6 @@ static DEFINE_PCI_DEVICE_TABLE(cx25821_audio_pci_tbl) = {
MODULE_DEVICE_TABLE(pci, cx25821_audio_pci_tbl); MODULE_DEVICE_TABLE(pci, cx25821_audio_pci_tbl);
/*
* Not used in the function snd_cx25821_dev_free so removing
* from the file.
*/
/*
static int snd_cx25821_free(struct cx25821_audio_dev *chip)
{
if (chip->irq >= 0)
free_irq(chip->irq, chip);
cx25821_dev_unregister(chip->dev);
pci_disable_device(chip->pci);
return 0;
}
*/
/*
* Component Destructor
*/
static void snd_cx25821_dev_free(struct snd_card *card)
{
struct cx25821_audio_dev *chip = card->private_data;
/* snd_cx25821_free(chip); */
snd_card_free(chip->card);
}
/* /*
* Alsa Constructor - Component probe * Alsa Constructor - Component probe
*/ */
...@@ -685,7 +656,6 @@ static int cx25821_audio_initdev(struct cx25821_dev *dev) ...@@ -685,7 +656,6 @@ static int cx25821_audio_initdev(struct cx25821_dev *dev)
strcpy(card->driver, "cx25821"); strcpy(card->driver, "cx25821");
/* Card "creation" */ /* Card "creation" */
card->private_free = snd_cx25821_dev_free;
chip = card->private_data; chip = card->private_data;
spin_lock_init(&chip->reg_lock); spin_lock_init(&chip->reg_lock);
...@@ -729,8 +699,7 @@ static int cx25821_audio_initdev(struct cx25821_dev *dev) ...@@ -729,8 +699,7 @@ static int cx25821_audio_initdev(struct cx25821_dev *dev)
goto error; goto error;
} }
snd_cx25821_cards[devno] = card; dev->card = card;
devno++; devno++;
return 0; return 0;
...@@ -742,9 +711,31 @@ static int cx25821_audio_initdev(struct cx25821_dev *dev) ...@@ -742,9 +711,31 @@ static int cx25821_audio_initdev(struct cx25821_dev *dev)
/**************************************************************************** /****************************************************************************
LINUX MODULE INIT LINUX MODULE INIT
****************************************************************************/ ****************************************************************************/
static int cx25821_alsa_exit_callback(struct device *dev, void *data)
{
struct v4l2_device *v4l2_dev = dev_get_drvdata(dev);
struct cx25821_dev *cxdev = get_cx25821(v4l2_dev);
snd_card_free(cxdev->card);
return 0;
}
static void cx25821_audio_fini(void) static void cx25821_audio_fini(void)
{ {
snd_card_free(snd_cx25821_cards[0]); struct device_driver *drv = driver_find("cx25821", &pci_bus_type);
int ret;
ret = driver_for_each_device(drv, NULL, NULL, cx25821_alsa_exit_callback);
}
static int cx25821_alsa_init_callback(struct device *dev, void *data)
{
struct v4l2_device *v4l2_dev = dev_get_drvdata(dev);
struct cx25821_dev *cxdev = get_cx25821(v4l2_dev);
cx25821_audio_initdev(cxdev);
return 0;
} }
/* /*
...@@ -756,29 +747,11 @@ static void cx25821_audio_fini(void) ...@@ -756,29 +747,11 @@ static void cx25821_audio_fini(void)
*/ */
static int cx25821_alsa_init(void) static int cx25821_alsa_init(void)
{ {
struct cx25821_dev *dev = NULL; struct device_driver *drv = driver_find("cx25821", &pci_bus_type);
struct list_head *list;
mutex_lock(&cx25821_devlist_mutex); return driver_for_each_device(drv, NULL, NULL, cx25821_alsa_init_callback);
list_for_each(list, &cx25821_devlist) {
dev = list_entry(list, struct cx25821_dev, devlist);
cx25821_audio_initdev(dev);
}
mutex_unlock(&cx25821_devlist_mutex);
if (dev == NULL)
pr_info("ERROR ALSA: no cx25821 cards found\n");
return 0;
} }
late_initcall(cx25821_alsa_init); late_initcall(cx25821_alsa_init);
module_exit(cx25821_audio_fini); module_exit(cx25821_audio_fini);
/* ----------------------------------------------------------- */
/*
* Local variables:
* c-basic-offset: 8
* End:
*/
drivers/media/pci/cx25821/cx25821-audio-upstream.c
View file @ a5d0568e
...@@ -45,7 +45,7 @@ static int _intr_msk = FLD_AUD_SRC_RISCI1 | FLD_AUD_SRC_OF | ...@@ -45,7 +45,7 @@ static int _intr_msk = FLD_AUD_SRC_RISCI1 | FLD_AUD_SRC_OF |
FLD_AUD_SRC_SYNC | FLD_AUD_SRC_OPC_ERR; FLD_AUD_SRC_SYNC | FLD_AUD_SRC_OPC_ERR;
static int cx25821_sram_channel_setup_upstream_audio(struct cx25821_dev *dev, static int cx25821_sram_channel_setup_upstream_audio(struct cx25821_dev *dev,
struct sram_channel *ch, const struct sram_channel *ch,
unsigned int bpl, u32 risc) unsigned int bpl, u32 risc)
{ {
unsigned int i, lines; unsigned int i, lines;
...@@ -106,7 +106,7 @@ static __le32 *cx25821_risc_field_upstream_audio(struct cx25821_dev *dev, ...@@ -106,7 +106,7 @@ static __le32 *cx25821_risc_field_upstream_audio(struct cx25821_dev *dev,
int fifo_enable) int fifo_enable)
{ {
unsigned int line; unsigned int line;
struct sram_channel *sram_ch = const struct sram_channel *sram_ch =
dev->channels[dev->_audio_upstream_channel].sram_channels; dev->channels[dev->_audio_upstream_channel].sram_channels;
int offset = 0; int offset = 0;
...@@ -215,7 +215,7 @@ static void cx25821_free_memory_audio(struct cx25821_dev *dev) ...@@ -215,7 +215,7 @@ static void cx25821_free_memory_audio(struct cx25821_dev *dev)
void cx25821_stop_upstream_audio(struct cx25821_dev *dev) void cx25821_stop_upstream_audio(struct cx25821_dev *dev)
{ {
struct sram_channel *sram_ch = const struct sram_channel *sram_ch =
dev->channels[AUDIO_UPSTREAM_SRAM_CHANNEL_B].sram_channels; dev->channels[AUDIO_UPSTREAM_SRAM_CHANNEL_B].sram_channels;
u32 tmp = 0; u32 tmp = 0;
...@@ -257,7 +257,7 @@ void cx25821_free_mem_upstream_audio(struct cx25821_dev *dev) ...@@ -257,7 +257,7 @@ void cx25821_free_mem_upstream_audio(struct cx25821_dev *dev)
} }
static int cx25821_get_audio_data(struct cx25821_dev *dev, static int cx25821_get_audio_data(struct cx25821_dev *dev,
struct sram_channel *sram_ch) const struct sram_channel *sram_ch)
{ {
struct file *myfile; struct file *myfile;
int frame_index_temp = dev->_audioframe_index; int frame_index_temp = dev->_audioframe_index;
...@@ -352,7 +352,7 @@ static void cx25821_audioups_handler(struct work_struct *work) ...@@ -352,7 +352,7 @@ static void cx25821_audioups_handler(struct work_struct *work)
} }
static int cx25821_openfile_audio(struct cx25821_dev *dev, static int cx25821_openfile_audio(struct cx25821_dev *dev,
struct sram_channel *sram_ch) const struct sram_channel *sram_ch)
{ {
struct file *myfile; struct file *myfile;
int i = 0, j = 0; int i = 0, j = 0;
...@@ -433,7 +433,7 @@ static int cx25821_openfile_audio(struct cx25821_dev *dev, ...@@ -433,7 +433,7 @@ static int cx25821_openfile_audio(struct cx25821_dev *dev,
} }
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, const struct sram_channel *sram_ch,
int bpl) int bpl)
{ {
int ret = 0; int ret = 0;
...@@ -495,7 +495,7 @@ static int cx25821_audio_upstream_irq(struct cx25821_dev *dev, int chan_num, ...@@ -495,7 +495,7 @@ static int cx25821_audio_upstream_irq(struct cx25821_dev *dev, int chan_num,
{ {
int i = 0; int i = 0;
u32 int_msk_tmp; u32 int_msk_tmp;
struct sram_channel *channel = dev->channels[chan_num].sram_channels; const struct sram_channel *channel = dev->channels[chan_num].sram_channels;
dma_addr_t risc_phys_jump_addr; dma_addr_t risc_phys_jump_addr;
__le32 *rp; __le32 *rp;
...@@ -587,7 +587,7 @@ static irqreturn_t cx25821_upstream_irq_audio(int irq, void *dev_id) ...@@ -587,7 +587,7 @@ static irqreturn_t cx25821_upstream_irq_audio(int irq, void *dev_id)
struct cx25821_dev *dev = dev_id; struct cx25821_dev *dev = dev_id;
u32 audio_status; u32 audio_status;
int handled = 0; int handled = 0;
struct sram_channel *sram_ch; const struct sram_channel *sram_ch;
if (!dev) if (!dev)
return -1; return -1;
...@@ -611,7 +611,7 @@ static irqreturn_t cx25821_upstream_irq_audio(int irq, void *dev_id) ...@@ -611,7 +611,7 @@ static irqreturn_t cx25821_upstream_irq_audio(int irq, void *dev_id)
} }
static void cx25821_wait_fifo_enable(struct cx25821_dev *dev, static void cx25821_wait_fifo_enable(struct cx25821_dev *dev,
struct sram_channel *sram_ch) const struct sram_channel *sram_ch)
{ {
int count = 0; int count = 0;
u32 tmp; u32 tmp;
...@@ -635,7 +635,7 @@ static void cx25821_wait_fifo_enable(struct cx25821_dev *dev, ...@@ -635,7 +635,7 @@ static void cx25821_wait_fifo_enable(struct cx25821_dev *dev,
} }
static int cx25821_start_audio_dma_upstream(struct cx25821_dev *dev, static int cx25821_start_audio_dma_upstream(struct cx25821_dev *dev,
struct sram_channel *sram_ch) const struct sram_channel *sram_ch)
{ {
u32 tmp = 0; u32 tmp = 0;
int err = 0; int err = 0;
...@@ -699,7 +699,7 @@ static int cx25821_start_audio_dma_upstream(struct cx25821_dev *dev, ...@@ -699,7 +699,7 @@ static int cx25821_start_audio_dma_upstream(struct cx25821_dev *dev,
int cx25821_audio_upstream_init(struct cx25821_dev *dev, int channel_select) int cx25821_audio_upstream_init(struct cx25821_dev *dev, int channel_select)
{ {
struct sram_channel *sram_ch; const struct sram_channel *sram_ch;
int err = 0; int err = 0;
if (dev->_audio_is_running) { if (dev->_audio_is_running) {
......
drivers/media/pci/cx25821/cx25821-cards.c
View file @ a5d0568e
...@@ -26,11 +26,8 @@ ...@@ -26,11 +26,8 @@
#include <linux/init.h> #include <linux/init.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/pci.h> #include <linux/pci.h>
#include <linux/delay.h>
#include <media/cx25840.h>
#include "cx25821.h" #include "cx25821.h"
#include "tuner-xc2028.h"
/* board config info */ /* board config info */
...@@ -45,28 +42,8 @@ struct cx25821_board cx25821_boards[] = { ...@@ -45,28 +42,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,
}, },
}; };
const unsigned int cx25821_bcount = ARRAY_SIZE(cx25821_boards); const unsigned int cx25821_bcount = ARRAY_SIZE(cx25821_boards);
struct cx25821_subid cx25821_subids[] = {
{
.subvendor = 0x14f1,
.subdevice = 0x0920,
.card = CX25821_BOARD,
},
};
void cx25821_card_setup(struct cx25821_dev *dev)
{
static u8 eeprom[256];
if (dev->i2c_bus[0].i2c_rc == 0) {
dev->i2c_bus[0].i2c_client.addr = 0xa0 >> 1;
tveeprom_read(&dev->i2c_bus[0].i2c_client, eeprom,
sizeof(eeprom));
}
}
drivers/media/pci/cx25821/cx25821-core.c
View file @ a5d0568e
...@@ -41,14 +41,7 @@ static unsigned int card[] = {[0 ... (CX25821_MAXBOARDS - 1)] = UNSET }; ...@@ -41,14 +41,7 @@ static unsigned int card[] = {[0 ... (CX25821_MAXBOARDS - 1)] = UNSET };
module_param_array(card, int, NULL, 0444); module_param_array(card, int, NULL, 0444);
MODULE_PARM_DESC(card, "card type"); MODULE_PARM_DESC(card, "card type");
static unsigned int cx25821_devcount; const struct sram_channel cx25821_sram_channels[] = {
DEFINE_MUTEX(cx25821_devlist_mutex);
EXPORT_SYMBOL(cx25821_devlist_mutex);
LIST_HEAD(cx25821_devlist);
EXPORT_SYMBOL(cx25821_devlist);
struct sram_channel cx25821_sram_channels[] = {
[SRAM_CH00] = { [SRAM_CH00] = {
.i = SRAM_CH00, .i = SRAM_CH00,
.name = "VID A", .name = "VID A",
...@@ -317,20 +310,6 @@ struct sram_channel cx25821_sram_channels[] = { ...@@ -317,20 +310,6 @@ struct sram_channel cx25821_sram_channels[] = {
}; };
EXPORT_SYMBOL(cx25821_sram_channels); EXPORT_SYMBOL(cx25821_sram_channels);
struct sram_channel *channel0 = &cx25821_sram_channels[SRAM_CH00];
struct sram_channel *channel1 = &cx25821_sram_channels[SRAM_CH01];
struct sram_channel *channel2 = &cx25821_sram_channels[SRAM_CH02];
struct sram_channel *channel3 = &cx25821_sram_channels[SRAM_CH03];
struct sram_channel *channel4 = &cx25821_sram_channels[SRAM_CH04];
struct sram_channel *channel5 = &cx25821_sram_channels[SRAM_CH05];
struct sram_channel *channel6 = &cx25821_sram_channels[SRAM_CH06];
struct sram_channel *channel7 = &cx25821_sram_channels[SRAM_CH07];
struct sram_channel *channel9 = &cx25821_sram_channels[SRAM_CH09];
struct sram_channel *channel10 = &cx25821_sram_channels[SRAM_CH10];
struct sram_channel *channel11 = &cx25821_sram_channels[SRAM_CH11];
struct cx25821_dmaqueue mpegq;
static int cx25821_risc_decode(u32 risc) static int cx25821_risc_decode(u32 risc)
{ {
static const char * const instr[16] = { static const char * const instr[16] = {
...@@ -457,7 +436,7 @@ static void cx25821_registers_init(struct cx25821_dev *dev) ...@@ -457,7 +436,7 @@ static void cx25821_registers_init(struct cx25821_dev *dev)
} }
int cx25821_sram_channel_setup(struct cx25821_dev *dev, int cx25821_sram_channel_setup(struct cx25821_dev *dev,
struct sram_channel *ch, const struct sram_channel *ch,
unsigned int bpl, u32 risc) unsigned int bpl, u32 risc)
{ {
unsigned int i, lines; unsigned int i, lines;
...@@ -523,10 +502,9 @@ int cx25821_sram_channel_setup(struct cx25821_dev *dev, ...@@ -523,10 +502,9 @@ int cx25821_sram_channel_setup(struct cx25821_dev *dev,
return 0; return 0;
} }
EXPORT_SYMBOL(cx25821_sram_channel_setup);
int cx25821_sram_channel_setup_audio(struct cx25821_dev *dev, int cx25821_sram_channel_setup_audio(struct cx25821_dev *dev,
struct sram_channel *ch, const struct sram_channel *ch,
unsigned int bpl, u32 risc) unsigned int bpl, u32 risc)
{ {
unsigned int i, lines; unsigned int i, lines;
...@@ -592,7 +570,7 @@ int cx25821_sram_channel_setup_audio(struct cx25821_dev *dev, ...@@ -592,7 +570,7 @@ int cx25821_sram_channel_setup_audio(struct cx25821_dev *dev,
} }
EXPORT_SYMBOL(cx25821_sram_channel_setup_audio); EXPORT_SYMBOL(cx25821_sram_channel_setup_audio);
void cx25821_sram_channel_dump(struct cx25821_dev *dev, struct sram_channel *ch) void cx25821_sram_channel_dump(struct cx25821_dev *dev, const struct sram_channel *ch)
{ {
static char *name[] = { static char *name[] = {
"init risc lo", "init risc lo",
...@@ -652,10 +630,9 @@ void cx25821_sram_channel_dump(struct cx25821_dev *dev, struct sram_channel *ch) ...@@ -652,10 +630,9 @@ void cx25821_sram_channel_dump(struct cx25821_dev *dev, struct sram_channel *ch)
pr_warn(" : cnt2_reg: 0x%08x\n", pr_warn(" : cnt2_reg: 0x%08x\n",
cx_read(ch->cnt2_reg)); cx_read(ch->cnt2_reg));
} }
EXPORT_SYMBOL(cx25821_sram_channel_dump);
void cx25821_sram_channel_dump_audio(struct cx25821_dev *dev, void cx25821_sram_channel_dump_audio(struct cx25821_dev *dev,
struct sram_channel *ch) const struct sram_channel *ch)
{ {
static const char * const name[] = { static const char * const name[] = {
"init risc lo", "init risc lo",
...@@ -798,12 +775,12 @@ void cx25821_set_pixel_format(struct cx25821_dev *dev, int channel_select, ...@@ -798,12 +775,12 @@ void cx25821_set_pixel_format(struct cx25821_dev *dev, int channel_select,
if (channel_select <= 7 && channel_select >= 0) { if (channel_select <= 7 && channel_select >= 0) {
cx_write(dev->channels[channel_select].sram_channels->pix_frmt, cx_write(dev->channels[channel_select].sram_channels->pix_frmt,
format); format);
dev->channels[channel_select].pixel_formats = format;
} }
dev->channels[channel_select].pixel_formats = format;
} }
static void cx25821_set_vip_mode(struct cx25821_dev *dev, static void cx25821_set_vip_mode(struct cx25821_dev *dev,
struct sram_channel *ch) const struct sram_channel *ch)
{ {
cx_write(ch->pix_frmt, PIXEL_FRMT_422); cx_write(ch->pix_frmt, PIXEL_FRMT_422);
cx_write(ch->vip_ctl, PIXEL_ENGINE_VIP1); cx_write(ch->vip_ctl, PIXEL_ENGINE_VIP1);
...@@ -837,12 +814,13 @@ static void cx25821_initialize(struct cx25821_dev *dev) ...@@ -837,12 +814,13 @@ static void cx25821_initialize(struct cx25821_dev *dev)
cx25821_sram_channel_setup(dev, dev->channels[i].sram_channels, cx25821_sram_channel_setup(dev, dev->channels[i].sram_channels,
1440, 0); 1440, 0);
dev->channels[i].pixel_formats = PIXEL_FRMT_422; dev->channels[i].pixel_formats = PIXEL_FRMT_422;
dev->channels[i].use_cif_resolution = FALSE; dev->channels[i].use_cif_resolution = 0;
} }
/* Probably only affect Downstream */ /* Probably only affect Downstream */
for (i = VID_UPSTREAM_SRAM_CHANNEL_I; for (i = VID_UPSTREAM_SRAM_CHANNEL_I;
i <= VID_UPSTREAM_SRAM_CHANNEL_J; i++) { i <= VID_UPSTREAM_SRAM_CHANNEL_J; i++) {
dev->channels[i].pixel_formats = PIXEL_FRMT_422;
cx25821_set_vip_mode(dev, dev->channels[i].sram_channels); cx25821_set_vip_mode(dev, dev->channels[i].sram_channels);
} }
...@@ -868,8 +846,7 @@ static void cx25821_dev_checkrevision(struct cx25821_dev *dev) ...@@ -868,8 +846,7 @@ static void cx25821_dev_checkrevision(struct cx25821_dev *dev)
{ {
dev->hwrevision = cx_read(RDR_CFG2) & 0xff; dev->hwrevision = cx_read(RDR_CFG2) & 0xff;
pr_info("%s(): Hardware revision = 0x%02x\n", pr_info("Hardware revision = 0x%02x\n", dev->hwrevision);
__func__, dev->hwrevision);
} }
static void cx25821_iounmap(struct cx25821_dev *dev) static void cx25821_iounmap(struct cx25821_dev *dev)
...@@ -879,7 +856,6 @@ static void cx25821_iounmap(struct cx25821_dev *dev) ...@@ -879,7 +856,6 @@ static void cx25821_iounmap(struct cx25821_dev *dev)
/* Releasing IO memory */ /* Releasing IO memory */
if (dev->lmmio != NULL) { if (dev->lmmio != NULL) {
CX25821_INFO("Releasing lmmio.\n");
iounmap(dev->lmmio); iounmap(dev->lmmio);
dev->lmmio = NULL; dev->lmmio = NULL;
} }
...@@ -887,23 +863,14 @@ static void cx25821_iounmap(struct cx25821_dev *dev) ...@@ -887,23 +863,14 @@ static void cx25821_iounmap(struct cx25821_dev *dev)
static int cx25821_dev_setup(struct cx25821_dev *dev) static int cx25821_dev_setup(struct cx25821_dev *dev)
{ {
static unsigned int cx25821_devcount;
int i; int i;
pr_info("\n***********************************\n");
pr_info("cx25821 set up\n");
pr_info("***********************************\n\n");
mutex_init(&dev->lock); mutex_init(&dev->lock);
atomic_inc(&dev->refcount);
dev->nr = ++cx25821_devcount; dev->nr = ++cx25821_devcount;
sprintf(dev->name, "cx25821[%d]", dev->nr); sprintf(dev->name, "cx25821[%d]", dev->nr);
mutex_lock(&cx25821_devlist_mutex);
list_add_tail(&dev->devlist, &cx25821_devlist);
mutex_unlock(&cx25821_devlist_mutex);
if (dev->pci->device != 0x8210) { if (dev->pci->device != 0x8210) {
pr_info("%s(): Exiting. Incorrect Hardware device = 0x%02x\n", pr_info("%s(): Exiting. Incorrect Hardware device = 0x%02x\n",
__func__, dev->pci->device); __func__, dev->pci->device);
...@@ -914,8 +881,11 @@ static int cx25821_dev_setup(struct cx25821_dev *dev) ...@@ -914,8 +881,11 @@ static int cx25821_dev_setup(struct cx25821_dev *dev)
/* Apply a sensible clock frequency for the PCIe bridge */ /* Apply a sensible clock frequency for the PCIe bridge */
dev->clk_freq = 28000000; dev->clk_freq = 28000000;
for (i = 0; i < MAX_VID_CHANNEL_NUM; i++) for (i = 0; i < MAX_VID_CHANNEL_NUM; i++) {
dev->channels[i].dev = dev;
dev->channels[i].id = i;
dev->channels[i].sram_channels = &cx25821_sram_channels[i]; dev->channels[i].sram_channels = &cx25821_sram_channels[i];
}
if (dev->nr > 1) if (dev->nr > 1)
CX25821_INFO("dev->nr > 1!"); CX25821_INFO("dev->nr > 1!");
...@@ -978,63 +948,15 @@ static int cx25821_dev_setup(struct cx25821_dev *dev) ...@@ -978,63 +948,15 @@ static int cx25821_dev_setup(struct cx25821_dev *dev)
/* cx25821_i2c_register(&dev->i2c_bus[1]); /* cx25821_i2c_register(&dev->i2c_bus[1]);
* cx25821_i2c_register(&dev->i2c_bus[2]); */ * cx25821_i2c_register(&dev->i2c_bus[2]); */
CX25821_INFO("i2c register! bus->i2c_rc = %d\n",
dev->i2c_bus[0].i2c_rc);
cx25821_card_setup(dev);
if (medusa_video_init(dev) < 0) if (medusa_video_init(dev) < 0)
CX25821_ERR("%s(): Failed to initialize medusa!\n", __func__); CX25821_ERR("%s(): Failed to initialize medusa!\n", __func__);
cx25821_video_register(dev); cx25821_video_register(dev);
/* register IOCTL device */
dev->ioctl_dev = cx25821_vdev_init(dev, dev->pci,
&cx25821_videoioctl_template, "video");
if (video_register_device
(dev->ioctl_dev, VFL_TYPE_GRABBER, VIDEO_IOCTL_CH) < 0) {
cx25821_videoioctl_unregister(dev);
pr_err("%s(): Failed to register video adapter for IOCTL, so unregistering videoioctl device\n",
__func__);
}
cx25821_dev_checkrevision(dev); cx25821_dev_checkrevision(dev);
CX25821_INFO("setup done!\n");
return 0; return 0;
} }
void cx25821_start_upstream_video_ch1(struct cx25821_dev *dev,
struct upstream_user_struct *up_data)
{
dev->_isNTSC = !strcmp(dev->vid_stdname, "NTSC") ? 1 : 0;
dev->tvnorm = !dev->_isNTSC ? V4L2_STD_PAL_BG : V4L2_STD_NTSC_M;
medusa_set_videostandard(dev);
cx25821_vidupstream_init_ch1(dev, dev->channel_select,
dev->pixel_format);
}
void cx25821_start_upstream_video_ch2(struct cx25821_dev *dev,
struct upstream_user_struct *up_data)
{
dev->_isNTSC_ch2 = !strcmp(dev->vid_stdname_ch2, "NTSC") ? 1 : 0;
dev->tvnorm = !dev->_isNTSC_ch2 ? V4L2_STD_PAL_BG : V4L2_STD_NTSC_M;
medusa_set_videostandard(dev);
cx25821_vidupstream_init_ch2(dev, dev->channel_select_ch2,
dev->pixel_format_ch2);
}
void cx25821_start_upstream_audio(struct cx25821_dev *dev,
struct upstream_user_struct *up_data)
{
cx25821_audio_upstream_init(dev, AUDIO_UPSTREAM_SRAM_CHANNEL_B);
}
void cx25821_dev_unregister(struct cx25821_dev *dev) void cx25821_dev_unregister(struct cx25821_dev *dev)
{ {
int i; int i;
...@@ -1042,25 +964,16 @@ void cx25821_dev_unregister(struct cx25821_dev *dev) ...@@ -1042,25 +964,16 @@ void cx25821_dev_unregister(struct cx25821_dev *dev)
if (!dev->base_io_addr) if (!dev->base_io_addr)
return; return;
cx25821_free_mem_upstream_ch1(dev);
cx25821_free_mem_upstream_ch2(dev);
cx25821_free_mem_upstream_audio(dev);
release_mem_region(dev->base_io_addr, pci_resource_len(dev->pci, 0)); release_mem_region(dev->base_io_addr, pci_resource_len(dev->pci, 0));
if (!atomic_dec_and_test(&dev->refcount)) for (i = 0; i < MAX_VID_CHANNEL_NUM - 1; i++) {
return; if (i == SRAM_CH08) /* audio channel */
continue;
for (i = 0; i < VID_CHANNEL_NUM; i++) if (i == SRAM_CH09 || i == SRAM_CH10)
cx25821_video_unregister(dev, i); cx25821_free_mem_upstream(&dev->channels[i]);
for (i = VID_UPSTREAM_SRAM_CHANNEL_I;
i <= AUDIO_UPSTREAM_SRAM_CHANNEL_B; i++) {
cx25821_video_unregister(dev, i); cx25821_video_unregister(dev, i);
} }
cx25821_videoioctl_unregister(dev);
cx25821_i2c_unregister(&dev->i2c_bus[0]); cx25821_i2c_unregister(&dev->i2c_bus[0]);
cx25821_iounmap(dev); cx25821_iounmap(dev);
} }
...@@ -1385,8 +1298,6 @@ static int cx25821_initdev(struct pci_dev *pci_dev, ...@@ -1385,8 +1298,6 @@ static int cx25821_initdev(struct pci_dev *pci_dev,
goto fail_unregister_device; goto fail_unregister_device;
} }
pr_info("Athena pci enable !\n");
err = cx25821_dev_setup(dev); err = cx25821_dev_setup(dev);
if (err) { if (err) {
if (err == -EBUSY) if (err == -EBUSY)
...@@ -1445,10 +1356,6 @@ static void cx25821_finidev(struct pci_dev *pci_dev) ...@@ -1445,10 +1356,6 @@ static void cx25821_finidev(struct pci_dev *pci_dev)
if (pci_dev->irq) if (pci_dev->irq)
free_irq(pci_dev->irq, dev); free_irq(pci_dev->irq, dev);
mutex_lock(&cx25821_devlist_mutex);
list_del(&dev->devlist);
mutex_unlock(&cx25821_devlist_mutex);
cx25821_dev_unregister(dev); cx25821_dev_unregister(dev);
v4l2_device_unregister(v4l2_dev); v4l2_device_unregister(v4l2_dev);
kfree(dev); kfree(dev);
......
drivers/media/pci/cx25821/cx25821-gpio.c
View file @ a5d0568e
...@@ -20,6 +20,7 @@ ...@@ -20,6 +20,7 @@
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/ */
#include <linux/module.h>
#include "cx25821.h" #include "cx25821.h"
/********************* GPIO stuffs *********************/ /********************* GPIO stuffs *********************/
......
drivers/media/pci/cx25821/cx25821-i2c.c
View file @ a5d0568e
...@@ -23,8 +23,9 @@ ...@@ -23,8 +23,9 @@
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include "cx25821.h" #include <linux/module.h>
#include <linux/i2c.h> #include <linux/i2c.h>
#include "cx25821.h"
static unsigned int i2c_debug; static unsigned int i2c_debug;
module_param(i2c_debug, int, 0644); module_param(i2c_debug, int, 0644);
......
drivers/media/pci/cx25821/cx25821-medusa-video.c
View file @ a5d0568e
...@@ -94,8 +94,6 @@ static int medusa_initialize_ntsc(struct cx25821_dev *dev) ...@@ -94,8 +94,6 @@ static int medusa_initialize_ntsc(struct cx25821_dev *dev)
u32 value = 0; u32 value = 0;
u32 tmp = 0; u32 tmp = 0;
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], value = cx25821_i2c_read(&dev->i2c_bus[0],
...@@ -222,8 +220,6 @@ static int medusa_initialize_ntsc(struct cx25821_dev *dev) ...@@ -222,8 +220,6 @@ static int medusa_initialize_ntsc(struct cx25821_dev *dev)
value |= 0x00080200; value |= 0x00080200;
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);
return ret_val; return ret_val;
} }
...@@ -265,8 +261,6 @@ static int medusa_initialize_pal(struct cx25821_dev *dev) ...@@ -265,8 +261,6 @@ static int medusa_initialize_pal(struct cx25821_dev *dev)
u32 value = 0; u32 value = 0;
u32 tmp = 0; u32 tmp = 0;
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], value = cx25821_i2c_read(&dev->i2c_bus[0],
...@@ -397,14 +391,12 @@ static int medusa_initialize_pal(struct cx25821_dev *dev) ...@@ -397,14 +391,12 @@ static int medusa_initialize_pal(struct cx25821_dev *dev)
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);
return ret_val; return ret_val;
} }
int medusa_set_videostandard(struct cx25821_dev *dev) int medusa_set_videostandard(struct cx25821_dev *dev)
{ {
int status = STATUS_SUCCESS; int status = 0;
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)
...@@ -434,8 +426,6 @@ void medusa_set_resolution(struct cx25821_dev *dev, int width, ...@@ -434,8 +426,6 @@ void medusa_set_resolution(struct cx25821_dev *dev, int width,
u32 vscale = 0x0; u32 vscale = 0x0;
const int MAX_WIDTH = 720; const int MAX_WIDTH = 720;
mutex_lock(&dev->lock);
/* validate the width */ /* validate the width */
if (width > MAX_WIDTH) { if (width > MAX_WIDTH) {
pr_info("%s(): width %d > MAX_WIDTH %d ! resetting to MAX_WIDTH\n", pr_info("%s(): width %d > MAX_WIDTH %d ! resetting to MAX_WIDTH\n",
...@@ -485,8 +475,6 @@ void medusa_set_resolution(struct cx25821_dev *dev, int width, ...@@ -485,8 +475,6 @@ void medusa_set_resolution(struct cx25821_dev *dev, int width,
cx25821_i2c_write(&dev->i2c_bus[0], cx25821_i2c_write(&dev->i2c_bus[0],
VSCALE_CTRL + (0x200 * decoder), vscale); VSCALE_CTRL + (0x200 * decoder), vscale);
} }
mutex_unlock(&dev->lock);
} }
static void medusa_set_decoderduration(struct cx25821_dev *dev, int decoder, static void medusa_set_decoderduration(struct cx25821_dev *dev, int decoder,
...@@ -496,11 +484,8 @@ static void medusa_set_decoderduration(struct cx25821_dev *dev, int decoder, ...@@ -496,11 +484,8 @@ static void medusa_set_decoderduration(struct cx25821_dev *dev, int decoder,
u32 tmp = 0; u32 tmp = 0;
u32 disp_cnt_reg = DISP_AB_CNT; u32 disp_cnt_reg = DISP_AB_CNT;
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);
return; return;
} }
...@@ -535,8 +520,6 @@ static void medusa_set_decoderduration(struct cx25821_dev *dev, int decoder, ...@@ -535,8 +520,6 @@ static void medusa_set_decoderduration(struct cx25821_dev *dev, int decoder,
} }
cx25821_i2c_write(&dev->i2c_bus[0], disp_cnt_reg, fld_cnt); cx25821_i2c_write(&dev->i2c_bus[0], disp_cnt_reg, fld_cnt);
mutex_unlock(&dev->lock);
} }
/* Map to Medusa register setting */ /* Map to Medusa register setting */
...@@ -587,10 +570,8 @@ int medusa_set_brightness(struct cx25821_dev *dev, int brightness, int decoder) ...@@ -587,10 +570,8 @@ int medusa_set_brightness(struct cx25821_dev *dev, int brightness, int decoder)
int value = 0; int value = 0;
u32 val = 0, tmp = 0; u32 val = 0, tmp = 0;
mutex_lock(&dev->lock);
if ((brightness > VIDEO_PROCAMP_MAX) || if ((brightness > VIDEO_PROCAMP_MAX) ||
(brightness < VIDEO_PROCAMP_MIN)) { (brightness < VIDEO_PROCAMP_MIN)) {
mutex_unlock(&dev->lock);
return -1; return -1;
} }
ret_val = mapM(VIDEO_PROCAMP_MIN, VIDEO_PROCAMP_MAX, brightness, ret_val = mapM(VIDEO_PROCAMP_MIN, VIDEO_PROCAMP_MAX, brightness,
...@@ -601,7 +582,6 @@ int medusa_set_brightness(struct cx25821_dev *dev, int brightness, int decoder) ...@@ -601,7 +582,6 @@ int medusa_set_brightness(struct cx25821_dev *dev, int brightness, int decoder)
val &= 0xFFFFFF00; val &= 0xFFFFFF00;
ret_val |= cx25821_i2c_write(&dev->i2c_bus[0], ret_val |= cx25821_i2c_write(&dev->i2c_bus[0],
VDEC_A_BRITE_CTRL + (0x200 * decoder), val | value); VDEC_A_BRITE_CTRL + (0x200 * decoder), val | value);
mutex_unlock(&dev->lock);
return ret_val; return ret_val;
} }
...@@ -611,10 +591,7 @@ int medusa_set_contrast(struct cx25821_dev *dev, int contrast, int decoder) ...@@ -611,10 +591,7 @@ int medusa_set_contrast(struct cx25821_dev *dev, int contrast, int decoder)
int value = 0; int value = 0;
u32 val = 0, tmp = 0; u32 val = 0, tmp = 0;
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);
return -1; return -1;
} }
...@@ -626,7 +603,6 @@ int medusa_set_contrast(struct cx25821_dev *dev, int contrast, int decoder) ...@@ -626,7 +603,6 @@ int medusa_set_contrast(struct cx25821_dev *dev, int contrast, int decoder)
ret_val |= cx25821_i2c_write(&dev->i2c_bus[0], ret_val |= cx25821_i2c_write(&dev->i2c_bus[0],
VDEC_A_CNTRST_CTRL + (0x200 * decoder), val | value); VDEC_A_CNTRST_CTRL + (0x200 * decoder), val | value);
mutex_unlock(&dev->lock);
return ret_val; return ret_val;
} }
...@@ -636,10 +612,7 @@ int medusa_set_hue(struct cx25821_dev *dev, int hue, int decoder) ...@@ -636,10 +612,7 @@ int medusa_set_hue(struct cx25821_dev *dev, int hue, int decoder)
int value = 0; int value = 0;
u32 val = 0, tmp = 0; u32 val = 0, tmp = 0;
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);
return -1; return -1;
} }
...@@ -654,7 +627,6 @@ int medusa_set_hue(struct cx25821_dev *dev, int hue, int decoder) ...@@ -654,7 +627,6 @@ int medusa_set_hue(struct cx25821_dev *dev, int hue, int decoder)
ret_val |= cx25821_i2c_write(&dev->i2c_bus[0], ret_val |= cx25821_i2c_write(&dev->i2c_bus[0],
VDEC_A_HUE_CTRL + (0x200 * decoder), val | value); VDEC_A_HUE_CTRL + (0x200 * decoder), val | value);
mutex_unlock(&dev->lock);
return ret_val; return ret_val;
} }
...@@ -664,11 +636,8 @@ int medusa_set_saturation(struct cx25821_dev *dev, int saturation, int decoder) ...@@ -664,11 +636,8 @@ int medusa_set_saturation(struct cx25821_dev *dev, int saturation, int decoder)
int value = 0; int value = 0;
u32 val = 0, tmp = 0; u32 val = 0, tmp = 0;
mutex_lock(&dev->lock);
if ((saturation > VIDEO_PROCAMP_MAX) || if ((saturation > VIDEO_PROCAMP_MAX) ||
(saturation < VIDEO_PROCAMP_MIN)) { (saturation < VIDEO_PROCAMP_MIN)) {
mutex_unlock(&dev->lock);
return -1; return -1;
} }
...@@ -687,7 +656,6 @@ int medusa_set_saturation(struct cx25821_dev *dev, int saturation, int decoder) ...@@ -687,7 +656,6 @@ int medusa_set_saturation(struct cx25821_dev *dev, int saturation, int decoder)
ret_val |= cx25821_i2c_write(&dev->i2c_bus[0], ret_val |= cx25821_i2c_write(&dev->i2c_bus[0],
VDEC_A_VSAT_CTRL + (0x200 * decoder), val | value); VDEC_A_VSAT_CTRL + (0x200 * decoder), val | value);
mutex_unlock(&dev->lock);
return ret_val; return ret_val;
} }
...@@ -699,8 +667,6 @@ int medusa_video_init(struct cx25821_dev *dev) ...@@ -699,8 +667,6 @@ int medusa_video_init(struct cx25821_dev *dev)
int ret_val = 0; int ret_val = 0;
int i = 0; int i = 0;
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 */
...@@ -719,13 +685,9 @@ int medusa_video_init(struct cx25821_dev *dev) ...@@ -719,13 +685,9 @@ int medusa_video_init(struct cx25821_dev *dev)
if (ret_val < 0) if (ret_val < 0)
goto error; goto error;
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);
/* 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;
...@@ -774,14 +736,8 @@ int medusa_video_init(struct cx25821_dev *dev) ...@@ -774,14 +736,8 @@ int medusa_video_init(struct cx25821_dev *dev)
if (ret_val < 0) if (ret_val < 0)
goto error; goto error;
mutex_unlock(&dev->lock);
ret_val = medusa_set_videostandard(dev); ret_val = medusa_set_videostandard(dev);
return ret_val;
error: error:
mutex_unlock(&dev->lock);
return ret_val; return ret_val;
} }
drivers/media/pci/cx25821/cx25821-video-upstream-ch2.c deleted 100644 → 0
View file @ 966a1601
/*
* Driver for the Conexant CX25821 PCIe bridge
*
* Copyright (C) 2009 Conexant Systems Inc.
* Authors <hiep.huynh@conexant.com>, <shu.lin@conexant.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
*
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include "cx25821-video.h"
#include "cx25821-video-upstream-ch2.h"
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/syscalls.h>
#include <linux/file.h>
#include <linux/fcntl.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
MODULE_DESCRIPTION("v4l2 driver module for cx25821 based TV cards");
MODULE_AUTHOR("Hiep Huynh <hiep.huynh@conexant.com>");
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 __le32 *cx25821_update_riscprogram_ch2(struct cx25821_dev *dev,
__le32 *rp, unsigned int offset,
unsigned int bpl, u32 sync_line,
unsigned int lines,
int fifo_enable, int field_type)
{
unsigned int line, i;
int dist_betwn_starts = bpl * 2;
*(rp++) = cpu_to_le32(RISC_RESYNC | sync_line);
if (USE_RISC_NOOP_VIDEO) {
for (i = 0; i < NUM_NO_OPS; i++)
*(rp++) = cpu_to_le32(RISC_NOOP);
}
/* scan lines */
for (line = 0; line < lines; line++) {
*(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(0); /* bits 63-32 */
if ((lines <= NTSC_FIELD_HEIGHT) ||
(line < (NTSC_FIELD_HEIGHT - 1)) || !(dev->_isNTSC_ch2)) {
offset += dist_betwn_starts;
}
}
return rp;
}
static __le32 *cx25821_risc_field_upstream_ch2(struct cx25821_dev *dev,
__le32 *rp,
dma_addr_t databuf_phys_addr,
unsigned int offset,
u32 sync_line, unsigned int bpl,
unsigned int lines,
int fifo_enable, int field_type)
{
unsigned int line, i;
struct sram_channel *sram_ch =
dev->channels[dev->_channel2_upstream_select].sram_channels;
int dist_betwn_starts = bpl * 2;
/* sync instruction */
if (sync_line != NO_SYNC_LINE)
*(rp++) = cpu_to_le32(RISC_RESYNC | sync_line);
if (USE_RISC_NOOP_VIDEO) {
for (i = 0; i < NUM_NO_OPS; i++)
*(rp++) = cpu_to_le32(RISC_NOOP);
}
/* scan lines */
for (line = 0; line < lines; line++) {
*(rp++) = cpu_to_le32(RISC_READ | RISC_SOL | RISC_EOL | bpl);
*(rp++) = cpu_to_le32(databuf_phys_addr + offset);
*(rp++) = cpu_to_le32(0); /* bits 63-32 */
if ((lines <= NTSC_FIELD_HEIGHT) ||
(line < (NTSC_FIELD_HEIGHT - 1)) || !(dev->_isNTSC_ch2)) {
offset += dist_betwn_starts;
}
/*
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.
*/
if (fifo_enable && line == 3) {
*(rp++) = RISC_WRITECR;
*(rp++) = sram_ch->dma_ctl;
*(rp++) = FLD_VID_FIFO_EN;
*(rp++) = 0x00000001;
}
}
return rp;
}
static int cx25821_risc_buffer_upstream_ch2(struct cx25821_dev *dev,
struct pci_dev *pci,
unsigned int top_offset,
unsigned int bpl,
unsigned int lines)
{
__le32 *rp;
int fifo_enable = 0;
int singlefield_lines = lines >> 1; /*get line count for single field */
int odd_num_lines = singlefield_lines;
int frame = 0;
int frame_size = 0;
int databuf_offset = 0;
int risc_program_size = 0;
int risc_flag = RISC_CNT_RESET;
unsigned int bottom_offset = bpl;
dma_addr_t risc_phys_jump_addr;
if (dev->_isNTSC_ch2) {
odd_num_lines = singlefield_lines + 1;
risc_program_size = FRAME1_VID_PROG_SIZE;
if (bpl == Y411_LINE_SZ)
frame_size = FRAME_SIZE_NTSC_Y411;
else
frame_size = FRAME_SIZE_NTSC_Y422;
} else {
risc_program_size = PAL_VID_PROG_SIZE;
if (bpl == Y411_LINE_SZ)
frame_size = FRAME_SIZE_PAL_Y411;
else
frame_size = FRAME_SIZE_PAL_Y422;
}
/* Virtual address of Risc buffer program */
rp = dev->_dma_virt_addr_ch2;
for (frame = 0; frame < NUM_FRAMES; frame++) {
databuf_offset = frame_size * frame;
if (UNSET != top_offset) {
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);
}
fifo_enable = FIFO_DISABLE;
/* 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) {
risc_flag = RISC_CNT_RESET;
risc_phys_jump_addr = dev->_dma_phys_start_addr_ch2 +
risc_program_size;
} else {
risc_flag = RISC_CNT_INC;
risc_phys_jump_addr = dev->_dma_phys_start_addr_ch2;
}
/*
* 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_phys_jump_addr);
*(rp++) = cpu_to_le32(0);
}
return 0;
}
void cx25821_stop_upstream_video_ch2(struct cx25821_dev *dev)
{
struct sram_channel *sram_ch =
dev->channels[VID_UPSTREAM_SRAM_CHANNEL_J].sram_channels;
u32 tmp = 0;
if (!dev->_is_running_ch2) {
pr_info("No video file is currently running so return!\n");
return;
}
/* Disable RISC interrupts */
tmp = cx_read(sram_ch->int_msk);
cx_write(sram_ch->int_msk, tmp & ~_intr_msk);
/* Turn OFF risc and fifo */
tmp = cx_read(sram_ch->dma_ctl);
cx_write(sram_ch->dma_ctl, tmp & ~(FLD_VID_FIFO_EN | FLD_VID_RISC_EN));
/* Clear data buffer memory */
if (dev->_data_buf_virt_addr_ch2)
memset(dev->_data_buf_virt_addr_ch2, 0,
dev->_data_buf_size_ch2);
dev->_is_running_ch2 = 0;
dev->_is_first_frame_ch2 = 0;
dev->_frame_count_ch2 = 0;
dev->_file_status_ch2 = END_OF_FILE;
kfree(dev->_irq_queues_ch2);
dev->_irq_queues_ch2 = NULL;
kfree(dev->_filename_ch2);
tmp = cx_read(VID_CH_MODE_SEL);
cx_write(VID_CH_MODE_SEL, tmp & 0xFFFFFE00);
}
void cx25821_free_mem_upstream_ch2(struct cx25821_dev *dev)
{
if (dev->_is_running_ch2)
cx25821_stop_upstream_video_ch2(dev);
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);
dev->_dma_virt_addr_ch2 = NULL;
}
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);
dev->_data_buf_virt_addr_ch2 = NULL;
}
}
static int cx25821_get_frame_ch2(struct cx25821_dev *dev,
struct sram_channel *sram_ch)
{
struct file *myfile;
int frame_index_temp = dev->_frame_index_ch2;
int i = 0;
int line_size = (dev->_pixel_format_ch2 == PIXEL_FRMT_411) ?
Y411_LINE_SZ : Y422_LINE_SZ;
int frame_size = 0;
int frame_offset = 0;
ssize_t vfs_read_retval = 0;
char mybuf[line_size];
loff_t file_offset;
loff_t pos;
mm_segment_t old_fs;
if (dev->_file_status_ch2 == END_OF_FILE)
return 0;
if (dev->_isNTSC_ch2) {
frame_size = (line_size == Y411_LINE_SZ) ?
FRAME_SIZE_NTSC_Y411 : FRAME_SIZE_NTSC_Y422;
} else {
frame_size = (line_size == Y411_LINE_SZ) ?
FRAME_SIZE_PAL_Y411 : FRAME_SIZE_PAL_Y422;
}
frame_offset = (frame_index_temp > 0) ? frame_size : 0;
file_offset = dev->_frame_count_ch2 * frame_size;
myfile = filp_open(dev->_filename_ch2, O_RDONLY | O_LARGEFILE, 0);
if (IS_ERR(myfile)) {
const int open_errno = -PTR_ERR(myfile);
pr_err("%s(): ERROR opening file(%s) with errno = %d!\n",
__func__, dev->_filename_ch2, open_errno);
return PTR_ERR(myfile);
} else {
if (!(myfile->f_op)) {
pr_err("%s(): File has no file operations registered!\n",
__func__);
filp_close(myfile, NULL);
return -EIO;
}
if (!myfile->f_op->read) {
pr_err("%s(): File has no READ operations registered!\n",
__func__);
filp_close(myfile, NULL);
return -EIO;
}
pos = myfile->f_pos;
old_fs = get_fs();
set_fs(KERNEL_DS);
for (i = 0; i < dev->_lines_count_ch2; i++) {
pos = file_offset;
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) {
memcpy((void *)(dev->_data_buf_virt_addr_ch2 +
frame_offset / 4), mybuf,
vfs_read_retval);
}
file_offset += vfs_read_retval;
frame_offset += vfs_read_retval;
if (vfs_read_retval < line_size) {
pr_info("Done: exit %s() since no more bytes to read from Video file\n",
__func__);
break;
}
}
if (i > 0)
dev->_frame_count_ch2++;
dev->_file_status_ch2 = (vfs_read_retval == line_size) ?
IN_PROGRESS : END_OF_FILE;
set_fs(old_fs);
filp_close(myfile, NULL);
}
return 0;
}
static void cx25821_vidups_handler_ch2(struct work_struct *work)
{
struct cx25821_dev *dev = container_of(work, struct cx25821_dev,
_irq_work_entry_ch2);
if (!dev) {
pr_err("ERROR %s(): since container_of(work_struct) FAILED!\n",
__func__);
return;
}
cx25821_get_frame_ch2(dev, dev->channels[dev->
_channel2_upstream_select].sram_channels);
}
static int cx25821_openfile_ch2(struct cx25821_dev *dev,
struct sram_channel *sram_ch)
{
struct file *myfile;
int i = 0, j = 0;
int line_size = (dev->_pixel_format_ch2 == PIXEL_FRMT_411) ?
Y411_LINE_SZ : Y422_LINE_SZ;
ssize_t vfs_read_retval = 0;
char mybuf[line_size];
loff_t pos;
loff_t offset = (unsigned long)0;
mm_segment_t old_fs;
myfile = filp_open(dev->_filename_ch2, O_RDONLY | O_LARGEFILE, 0);
if (IS_ERR(myfile)) {
const int open_errno = -PTR_ERR(myfile);
pr_err("%s(): ERROR opening file(%s) with errno = %d!\n",
__func__, dev->_filename_ch2, open_errno);
return PTR_ERR(myfile);
} else {
if (!(myfile->f_op)) {
pr_err("%s(): File has no file operations registered!\n",
__func__);
filp_close(myfile, NULL);
return -EIO;
}
if (!myfile->f_op->read) {
pr_err("%s(): File has no READ operations registered! Returning\n",
__func__);
filp_close(myfile, NULL);
return -EIO;
}
pos = myfile->f_pos;
old_fs = get_fs();
set_fs(KERNEL_DS);
for (j = 0; j < NUM_FRAMES; j++) {
for (i = 0; i < dev->_lines_count_ch2; i++) {
pos = offset;
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) {
memcpy((void *)(dev->
_data_buf_virt_addr_ch2
+ offset / 4), mybuf,
vfs_read_retval);
}
offset += vfs_read_retval;
if (vfs_read_retval < line_size) {
pr_info("Done: exit %s() since no more bytes to read from Video file\n",
__func__);
break;
}
}
if (i > 0)
dev->_frame_count_ch2++;
if (vfs_read_retval < line_size)
break;
}
dev->_file_status_ch2 = (vfs_read_retval == line_size) ?
IN_PROGRESS : END_OF_FILE;
set_fs(old_fs);
myfile->f_pos = 0;
filp_close(myfile, NULL);
}
return 0;
}
static int cx25821_upstream_buffer_prepare_ch2(struct cx25821_dev *dev,
struct sram_channel *sram_ch,
int bpl)
{
int ret = 0;
dma_addr_t dma_addr;
dma_addr_t data_dma_addr;
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);
}
dev->_dma_virt_addr_ch2 = pci_alloc_consistent(dev->pci,
dev->upstream_riscbuf_size_ch2, &dma_addr);
dev->_dma_virt_start_addr_ch2 = dev->_dma_virt_addr_ch2;
dev->_dma_phys_start_addr_ch2 = dma_addr;
dev->_dma_phys_addr_ch2 = dma_addr;
dev->_risc_size_ch2 = dev->upstream_riscbuf_size_ch2;
if (!dev->_dma_virt_addr_ch2) {
pr_err("FAILED to allocate memory for Risc buffer! Returning\n");
return -ENOMEM;
}
/* Iniitize at this address until n bytes to 0 */
memset(dev->_dma_virt_addr_ch2, 0, dev->_risc_size_ch2);
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);
}
/* For Video Data buffer allocation */
dev->_data_buf_virt_addr_ch2 = pci_alloc_consistent(dev->pci,
dev->upstream_databuf_size_ch2, &data_dma_addr);
dev->_data_buf_phys_addr_ch2 = data_dma_addr;
dev->_data_buf_size_ch2 = dev->upstream_databuf_size_ch2;
if (!dev->_data_buf_virt_addr_ch2) {
pr_err("FAILED to allocate memory for data buffer! Returning\n");
return -ENOMEM;
}
/* Initialize at this address until n bytes to 0 */
memset(dev->_data_buf_virt_addr_ch2, 0, dev->_data_buf_size_ch2);
ret = cx25821_openfile_ch2(dev, sram_ch);
if (ret < 0)
return ret;
/* Creating RISC programs */
ret = cx25821_risc_buffer_upstream_ch2(dev, dev->pci, 0, bpl,
dev->_lines_count_ch2);
if (ret < 0) {
pr_info("Failed creating Video Upstream Risc programs!\n");
goto error;
}
return 0;
error:
return ret;
}
static int cx25821_video_upstream_irq_ch2(struct cx25821_dev *dev,
int chan_num,
u32 status)
{
u32 int_msk_tmp;
struct sram_channel *channel = dev->channels[chan_num].sram_channels;
int singlefield_lines = NTSC_FIELD_HEIGHT;
int line_size_in_bytes = Y422_LINE_SZ;
int odd_risc_prog_size = 0;
dma_addr_t risc_phys_jump_addr;
__le32 *rp;
if (status & FLD_VID_SRC_RISC1) {
/* We should only process one program per call */
u32 prog_cnt = cx_read(channel->gpcnt);
/*
* 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);
cx_write(channel->int_msk, int_msk_tmp & ~_intr_msk);
cx_write(channel->int_stat, _intr_msk);
spin_lock(&dev->slock);
dev->_frame_index_ch2 = prog_cnt;
queue_work(dev->_irq_queues_ch2, &dev->_irq_work_entry_ch2);
if (dev->_is_first_frame_ch2) {
dev->_is_first_frame_ch2 = 0;
if (dev->_isNTSC_ch2) {
singlefield_lines += 1;
odd_risc_prog_size = ODD_FLD_NTSC_PROG_SIZE;
} else {
singlefield_lines = PAL_FIELD_HEIGHT;
odd_risc_prog_size = ODD_FLD_PAL_PROG_SIZE;
}
if (dev->_dma_virt_start_addr_ch2 != NULL) {
if (dev->_pixel_format_ch2 == PIXEL_FRMT_411)
line_size_in_bytes = Y411_LINE_SZ;
else
line_size_in_bytes = Y422_LINE_SZ;
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);
/* Jump to Even Risc program of 1st Frame */
*(rp++) = cpu_to_le32(RISC_JUMP);
*(rp++) = cpu_to_le32(risc_phys_jump_addr);
*(rp++) = cpu_to_le32(0);
}
}
spin_unlock(&dev->slock);
}
if (dev->_file_status_ch2 == END_OF_FILE) {
pr_info("EOF Channel 2 Framecount = %d\n",
dev->_frame_count_ch2);
return -1;
}
/* ElSE, set the interrupt mask register, re-enable irq. */
int_msk_tmp = cx_read(channel->int_msk);
cx_write(channel->int_msk, int_msk_tmp |= _intr_msk);
return 0;
}
static irqreturn_t cx25821_upstream_irq_ch2(int irq, void *dev_id)
{
struct cx25821_dev *dev = dev_id;
u32 vid_status;
int handled = 0;
int channel_num = 0;
struct sram_channel *sram_ch;
if (!dev)
return -1;
channel_num = VID_UPSTREAM_SRAM_CHANNEL_J;
sram_ch = dev->channels[channel_num].sram_channels;
vid_status = cx_read(sram_ch->int_stat);
/* Only deal with our interrupt */
if (vid_status)
handled = cx25821_video_upstream_irq_ch2(dev, channel_num,
vid_status);
if (handled < 0)
cx25821_stop_upstream_video_ch2(dev);
else
handled += handled;
return IRQ_RETVAL(handled);
}
static void cx25821_set_pixelengine_ch2(struct cx25821_dev *dev,
struct sram_channel *ch, int pix_format)
{
int width = WIDTH_D1;
int height = dev->_lines_count_ch2;
int num_lines, odd_num_lines;
u32 value;
int vip_mode = PIXEL_ENGINE_VIP1;
value = ((pix_format & 0x3) << 12) | (vip_mode & 0x7);
value &= 0xFFFFFFEF;
value |= dev->_isNTSC_ch2 ? 0 : 0x10;
cx_write(ch->vid_fmt_ctl, value);
/*
* set number of active pixels in each line. Default is 720
* pixels in both NTSC and PAL format
*/
cx_write(ch->vid_active_ctl1, width);
num_lines = (height / 2) & 0x3FF;
odd_num_lines = num_lines;
if (dev->_isNTSC_ch2)
odd_num_lines += 1;
value = (num_lines << 16) | odd_num_lines;
/* set number of active lines in field 0 (top) and field 1 (bottom) */
cx_write(ch->vid_active_ctl2, value);
cx_write(ch->vid_cdt_size, VID_CDT_SIZE >> 3);
}
static int cx25821_start_video_dma_upstream_ch2(struct cx25821_dev *dev,
struct sram_channel *sram_ch)
{
u32 tmp = 0;
int err = 0;
/*
* 656/VIP SRC Upstream Channel I & J and 7 - Host Bus Interface
* for channel A-C
*/
tmp = cx_read(VID_CH_MODE_SEL);
cx_write(VID_CH_MODE_SEL, tmp | 0x1B0001FF);
/*
* Set the physical start address of the RISC program in the initial
* program counter(IPC) member of the cmds.
*/
cx_write(sram_ch->cmds_start + 0, dev->_dma_phys_addr_ch2);
cx_write(sram_ch->cmds_start + 4, 0); /* Risc IPC High 64 bits 63-32 */
/* reset counter */
cx_write(sram_ch->gpcnt_ctl, 3);
/* Clear our bits from the interrupt status register. */
cx_write(sram_ch->int_stat, _intr_msk);
/* Set the interrupt mask register, enable irq. */
cx_set(PCI_INT_MSK, cx_read(PCI_INT_MSK) | (1 << sram_ch->irq_bit));
tmp = cx_read(sram_ch->int_msk);
cx_write(sram_ch->int_msk, tmp |= _intr_msk);
err = request_irq(dev->pci->irq, cx25821_upstream_irq_ch2,
IRQF_SHARED, dev->name, dev);
if (err < 0) {
pr_err("%s: can't get upstream IRQ %d\n",
dev->name, dev->pci->irq);
goto fail_irq;
}
/* Start the DMA engine */
tmp = cx_read(sram_ch->dma_ctl);
cx_set(sram_ch->dma_ctl, tmp | FLD_VID_RISC_EN);
dev->_is_running_ch2 = 1;
dev->_is_first_frame_ch2 = 1;
return 0;
fail_irq:
cx25821_dev_unregister(dev);
return err;
}
int cx25821_vidupstream_init_ch2(struct cx25821_dev *dev, int channel_select,
int pixel_format)
{
struct sram_channel *sram_ch;
u32 tmp;
int err = 0;
int data_frame_size = 0;
int risc_buffer_size = 0;
if (dev->_is_running_ch2) {
pr_info("Video Channel is still running so return!\n");
return 0;
}
dev->_channel2_upstream_select = channel_select;
sram_ch = dev->channels[channel_select].sram_channels;
INIT_WORK(&dev->_irq_work_entry_ch2, cx25821_vidups_handler_ch2);
dev->_irq_queues_ch2 =
create_singlethread_workqueue("cx25821_workqueue2");
if (!dev->_irq_queues_ch2) {
pr_err("create_singlethread_workqueue() for Video FAILED!\n");
return -ENOMEM;
}
/*
* 656/VIP SRC Upstream Channel I & J and 7 -
* Host Bus Interface for channel A-C
*/
tmp = cx_read(VID_CH_MODE_SEL);
cx_write(VID_CH_MODE_SEL, tmp | 0x1B0001FF);
dev->_is_running_ch2 = 0;
dev->_frame_count_ch2 = 0;
dev->_file_status_ch2 = RESET_STATUS;
dev->_lines_count_ch2 = dev->_isNTSC_ch2 ? 480 : 576;
dev->_pixel_format_ch2 = pixel_format;
dev->_line_size_ch2 = (dev->_pixel_format_ch2 == PIXEL_FRMT_422) ?
(WIDTH_D1 * 2) : (WIDTH_D1 * 3) / 2;
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;
if (dev->input_filename_ch2)
dev->_filename_ch2 = kstrdup(dev->input_filename_ch2,
GFP_KERNEL);
else
dev->_filename_ch2 = kstrdup(dev->_defaultname_ch2,
GFP_KERNEL);
if (!dev->_filename_ch2) {
err = -ENOENT;
goto error;
}
/* Default if filename is empty string */
if (strcmp(dev->_filename_ch2, "") == 0) {
if (dev->_isNTSC_ch2) {
dev->_filename_ch2 = (dev->_pixel_format_ch2 ==
PIXEL_FRMT_411) ? "/root/vid411.yuv" :
"/root/vidtest.yuv";
} else {
dev->_filename_ch2 = (dev->_pixel_format_ch2 ==
PIXEL_FRMT_411) ? "/root/pal411.yuv" :
"/root/pal422.yuv";
}
}
err = cx25821_sram_channel_setup_upstream(dev, sram_ch,
dev->_line_size_ch2, 0);
/* setup fifo + format */
cx25821_set_pixelengine_ch2(dev, sram_ch, dev->_pixel_format_ch2);
dev->upstream_riscbuf_size_ch2 = risc_buffer_size * 2;
dev->upstream_databuf_size_ch2 = data_frame_size * 2;
/* Allocating buffers and prepare RISC program */
err = cx25821_upstream_buffer_prepare_ch2(dev, sram_ch,
dev->_line_size_ch2);
if (err < 0) {
pr_err("%s: Failed to set up Video upstream buffers!\n",
dev->name);
goto error;
}
cx25821_start_video_dma_upstream_ch2(dev, sram_ch);
return 0;
error:
cx25821_dev_unregister(dev);
return err;
}
drivers/media/pci/cx25821/cx25821-video-upstream-ch2.h deleted 100644 → 0
View file @ 966a1601
/*
* Driver for the Conexant CX25821 PCIe bridge
*
* Copyright (C) 2009 Conexant Systems Inc.
* Authors <hiep.huynh@conexant.com>, <shu.lin@conexant.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
*
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <linux/mutex.h>
#include <linux/workqueue.h>
#define OPEN_FILE_1 0
#define NUM_PROGS 8
#define NUM_FRAMES 2
#define ODD_FIELD 0
#define EVEN_FIELD 1
#define TOP_OFFSET 0
#define FIFO_DISABLE 0
#define FIFO_ENABLE 1
#define TEST_FRAMES 5
#define END_OF_FILE 0
#define IN_PROGRESS 1
#define RESET_STATUS -1
#define NUM_NO_OPS 5
/* PAL and NTSC line sizes and number of lines. */
#define WIDTH_D1 720
#define NTSC_LINES_PER_FRAME 480
#define PAL_LINES_PER_FRAME 576
#define PAL_LINE_SZ 1440
#define Y422_LINE_SZ 1440
#define Y411_LINE_SZ 1080
#define NTSC_FIELD_HEIGHT 240
#define NTSC_ODD_FLD_LINES 241
#define PAL_FIELD_HEIGHT 288
#define FRAME_SIZE_NTSC_Y422 (NTSC_LINES_PER_FRAME * Y422_LINE_SZ)
#define FRAME_SIZE_NTSC_Y411 (NTSC_LINES_PER_FRAME * Y411_LINE_SZ)
#define FRAME_SIZE_PAL_Y422 (PAL_LINES_PER_FRAME * Y422_LINE_SZ)
#define FRAME_SIZE_PAL_Y411 (PAL_LINES_PER_FRAME * Y411_LINE_SZ)
#define NTSC_DATA_BUF_SZ (Y422_LINE_SZ * NTSC_LINES_PER_FRAME)
#define PAL_DATA_BUF_SZ (Y422_LINE_SZ * PAL_LINES_PER_FRAME)
#define RISC_WRITECR_INSTRUCTION_SIZE 16
#define RISC_SYNC_INSTRUCTION_SIZE 4
#define JUMP_INSTRUCTION_SIZE 12
#define MAXSIZE_NO_OPS 36
#define DWORD_SIZE 4
#define USE_RISC_NOOP_VIDEO 1
#ifdef USE_RISC_NOOP_VIDEO
#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)
#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 + 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 + 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 + JUMP_INSTRUCTION_SIZE + \
NUM_NO_OPS * DWORD_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 + \
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 + RISC_WRITECR_INSTRUCTION_SIZE + \
NUM_NO_OPS * DWORD_SIZE)
#endif
#ifndef USE_RISC_NOOP_VIDEO
#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_VID_PROG_SIZE \
((PAL_FIELD_HEIGHT * 2) * 3 * DWORD_SIZE + \
2 * RISC_SYNC_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_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_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 + \
RISC_WRITECR_INSTRUCTION_SIZE + JUMP_INSTRUCTION_SIZE)
#endif
drivers/media/pci/cx25821/cx25821-video-upstream.c
View file @ a5d0568e
...@@ -25,16 +25,11 @@ ...@@ -25,16 +25,11 @@
#include "cx25821-video.h" #include "cx25821-video.h"
#include "cx25821-video-upstream.h" #include "cx25821-video-upstream.h"
#include <linux/fs.h>
#include <linux/errno.h> #include <linux/errno.h>
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/syscalls.h>
#include <linux/file.h>
#include <linux/fcntl.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/uaccess.h>
MODULE_DESCRIPTION("v4l2 driver module for cx25821 based TV cards"); MODULE_DESCRIPTION("v4l2 driver module for cx25821 based TV cards");
MODULE_AUTHOR("Hiep Huynh <hiep.huynh@conexant.com>"); MODULE_AUTHOR("Hiep Huynh <hiep.huynh@conexant.com>");
...@@ -44,7 +39,7 @@ static int _intr_msk = FLD_VID_SRC_RISC1 | FLD_VID_SRC_UF | FLD_VID_SRC_SYNC | ...@@ -44,7 +39,7 @@ static int _intr_msk = FLD_VID_SRC_RISC1 | FLD_VID_SRC_UF | FLD_VID_SRC_SYNC |
FLD_VID_SRC_OPC_ERR; 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, const struct sram_channel *ch,
unsigned int bpl, u32 risc) unsigned int bpl, u32 risc)
{ {
unsigned int i, lines; unsigned int i, lines;
...@@ -97,12 +92,13 @@ int cx25821_sram_channel_setup_upstream(struct cx25821_dev *dev, ...@@ -97,12 +92,13 @@ int cx25821_sram_channel_setup_upstream(struct cx25821_dev *dev,
return 0; return 0;
} }
static __le32 *cx25821_update_riscprogram(struct cx25821_dev *dev, static __le32 *cx25821_update_riscprogram(struct cx25821_channel *chan,
__le32 *rp, unsigned int offset, __le32 *rp, unsigned int offset,
unsigned int bpl, u32 sync_line, unsigned int bpl, u32 sync_line,
unsigned int lines, int fifo_enable, unsigned int lines, int fifo_enable,
int field_type) int field_type)
{ {
struct cx25821_video_out_data *out = chan->out;
unsigned int line, i; unsigned int line, i;
int dist_betwn_starts = bpl * 2; int dist_betwn_starts = bpl * 2;
...@@ -116,11 +112,11 @@ static __le32 *cx25821_update_riscprogram(struct cx25821_dev *dev, ...@@ -116,11 +112,11 @@ static __le32 *cx25821_update_riscprogram(struct cx25821_dev *dev,
/* 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(out->_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) if ((lines <= NTSC_FIELD_HEIGHT)
|| (line < (NTSC_FIELD_HEIGHT - 1)) || !(dev->_isNTSC)) { || (line < (NTSC_FIELD_HEIGHT - 1)) || !(out->is_60hz)) {
offset += dist_betwn_starts; offset += dist_betwn_starts;
} }
} }
...@@ -128,15 +124,15 @@ static __le32 *cx25821_update_riscprogram(struct cx25821_dev *dev, ...@@ -128,15 +124,15 @@ static __le32 *cx25821_update_riscprogram(struct cx25821_dev *dev,
return rp; return rp;
} }
static __le32 *cx25821_risc_field_upstream(struct cx25821_dev *dev, __le32 * rp, static __le32 *cx25821_risc_field_upstream(struct cx25821_channel *chan, __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, unsigned int bpl, unsigned int lines,
int fifo_enable, int field_type) int fifo_enable, int field_type)
{ {
struct cx25821_video_out_data *out = chan->out;
unsigned int line, i; unsigned int line, i;
struct sram_channel *sram_ch = const struct sram_channel *sram_ch = chan->sram_channels;
dev->channels[dev->_channel_upstream_select].sram_channels;
int dist_betwn_starts = bpl * 2; int dist_betwn_starts = bpl * 2;
/* sync instruction */ /* sync instruction */
...@@ -155,7 +151,7 @@ static __le32 *cx25821_risc_field_upstream(struct cx25821_dev *dev, __le32 * rp, ...@@ -155,7 +151,7 @@ static __le32 *cx25821_risc_field_upstream(struct cx25821_dev *dev, __le32 * rp,
*(rp++) = cpu_to_le32(0); /* bits 63-32 */ *(rp++) = cpu_to_le32(0); /* bits 63-32 */
if ((lines <= NTSC_FIELD_HEIGHT) if ((lines <= NTSC_FIELD_HEIGHT)
|| (line < (NTSC_FIELD_HEIGHT - 1)) || !(dev->_isNTSC)) || (line < (NTSC_FIELD_HEIGHT - 1)) || !(out->is_60hz))
/* to skip the other field line */ /* to skip the other field line */
offset += dist_betwn_starts; offset += dist_betwn_starts;
...@@ -173,11 +169,12 @@ static __le32 *cx25821_risc_field_upstream(struct cx25821_dev *dev, __le32 * rp, ...@@ -173,11 +169,12 @@ static __le32 *cx25821_risc_field_upstream(struct cx25821_dev *dev, __le32 * rp,
return rp; return rp;
} }
static int cx25821_risc_buffer_upstream(struct cx25821_dev *dev, static int cx25821_risc_buffer_upstream(struct cx25821_channel *chan,
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)
{ {
struct cx25821_video_out_data *out = chan->out;
__le32 *rp; __le32 *rp;
int fifo_enable = 0; int fifo_enable = 0;
/* get line count for single field */ /* get line count for single field */
...@@ -191,7 +188,7 @@ static int cx25821_risc_buffer_upstream(struct cx25821_dev *dev, ...@@ -191,7 +188,7 @@ static int cx25821_risc_buffer_upstream(struct cx25821_dev *dev,
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 (out->is_60hz) {
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 = (bpl == Y411_LINE_SZ) ?
...@@ -203,15 +200,15 @@ static int cx25821_risc_buffer_upstream(struct cx25821_dev *dev, ...@@ -203,15 +200,15 @@ static int cx25821_risc_buffer_upstream(struct cx25821_dev *dev,
} }
/* Virtual address of Risc buffer program */ /* Virtual address of Risc buffer program */
rp = dev->_dma_virt_addr; rp = out->_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, rp = cx25821_risc_field_upstream(chan, rp,
dev->_data_buf_phys_addr + out->_data_buf_phys_addr +
databuf_offset, top_offset, 0, bpl, databuf_offset, top_offset, 0, bpl,
odd_num_lines, fifo_enable, ODD_FIELD); odd_num_lines, fifo_enable, ODD_FIELD);
} }
...@@ -219,18 +216,18 @@ static int cx25821_risc_buffer_upstream(struct cx25821_dev *dev, ...@@ -219,18 +216,18 @@ static int cx25821_risc_buffer_upstream(struct cx25821_dev *dev,
fifo_enable = FIFO_DISABLE; fifo_enable = FIFO_DISABLE;
/* Even Field */ /* Even Field */
rp = cx25821_risc_field_upstream(dev, rp, rp = cx25821_risc_field_upstream(chan, rp,
dev->_data_buf_phys_addr + out->_data_buf_phys_addr +
databuf_offset, bottom_offset, databuf_offset, bottom_offset,
0x200, bpl, singlefield_lines, 0x200, bpl, singlefield_lines,
fifo_enable, EVEN_FIELD); 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_phys_jump_addr = out->_dma_phys_start_addr +
risc_program_size; risc_program_size;
} else { } else {
risc_phys_jump_addr = dev->_dma_phys_start_addr; risc_phys_jump_addr = out->_dma_phys_start_addr;
risc_flag = RISC_CNT_INC; risc_flag = RISC_CNT_INC;
} }
...@@ -245,16 +242,21 @@ static int cx25821_risc_buffer_upstream(struct cx25821_dev *dev, ...@@ -245,16 +242,21 @@ static int cx25821_risc_buffer_upstream(struct cx25821_dev *dev,
return 0; return 0;
} }
void cx25821_stop_upstream_video_ch1(struct cx25821_dev *dev) void cx25821_stop_upstream_video(struct cx25821_channel *chan)
{ {
struct sram_channel *sram_ch = struct cx25821_video_out_data *out = chan->out;
dev->channels[VID_UPSTREAM_SRAM_CHANNEL_I].sram_channels; struct cx25821_dev *dev = chan->dev;
const struct sram_channel *sram_ch = chan->sram_channels;
u32 tmp = 0; u32 tmp = 0;
if (!dev->_is_running) { if (!out->_is_running) {
pr_info("No video file is currently running so return!\n"); pr_info("No video file is currently running so return!\n");
return; return;
} }
/* Set the interrupt mask register, disable irq. */
cx_set(PCI_INT_MSK, cx_read(PCI_INT_MSK) & ~(1 << sram_ch->irq_bit));
/* 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);
...@@ -263,283 +265,133 @@ void cx25821_stop_upstream_video_ch1(struct cx25821_dev *dev) ...@@ -263,283 +265,133 @@ void cx25821_stop_upstream_video_ch1(struct cx25821_dev *dev)
tmp = cx_read(sram_ch->dma_ctl); tmp = cx_read(sram_ch->dma_ctl);
cx_write(sram_ch->dma_ctl, tmp & ~(FLD_VID_FIFO_EN | FLD_VID_RISC_EN)); cx_write(sram_ch->dma_ctl, tmp & ~(FLD_VID_FIFO_EN | FLD_VID_RISC_EN));
/* Clear data buffer memory */ free_irq(dev->pci->irq, chan);
if (dev->_data_buf_virt_addr)
memset(dev->_data_buf_virt_addr, 0, dev->_data_buf_size);
dev->_is_running = 0;
dev->_is_first_frame = 0;
dev->_frame_count = 0;
dev->_file_status = END_OF_FILE;
kfree(dev->_irq_queues); /* Clear data buffer memory */
dev->_irq_queues = NULL; if (out->_data_buf_virt_addr)
memset(out->_data_buf_virt_addr, 0, out->_data_buf_size);
kfree(dev->_filename); out->_is_running = 0;
out->_is_first_frame = 0;
out->_frame_count = 0;
out->_file_status = END_OF_FILE;
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);
} }
void cx25821_free_mem_upstream_ch1(struct cx25821_dev *dev) void cx25821_free_mem_upstream(struct cx25821_channel *chan)
{ {
if (dev->_is_running) struct cx25821_video_out_data *out = chan->out;
cx25821_stop_upstream_video_ch1(dev); struct cx25821_dev *dev = chan->dev;
if (out->_is_running)
cx25821_stop_upstream_video(chan);
if (dev->_dma_virt_addr) { if (out->_dma_virt_addr) {
pci_free_consistent(dev->pci, dev->_risc_size, pci_free_consistent(dev->pci, out->_risc_size,
dev->_dma_virt_addr, dev->_dma_phys_addr); out->_dma_virt_addr, out->_dma_phys_addr);
dev->_dma_virt_addr = NULL; out->_dma_virt_addr = NULL;
} }
if (dev->_data_buf_virt_addr) { if (out->_data_buf_virt_addr) {
pci_free_consistent(dev->pci, dev->_data_buf_size, pci_free_consistent(dev->pci, out->_data_buf_size,
dev->_data_buf_virt_addr, out->_data_buf_virt_addr,
dev->_data_buf_phys_addr); out->_data_buf_phys_addr);
dev->_data_buf_virt_addr = NULL; out->_data_buf_virt_addr = NULL;
} }
} }
static int cx25821_get_frame(struct cx25821_dev *dev, int cx25821_write_frame(struct cx25821_channel *chan,
struct sram_channel *sram_ch) const char __user *data, size_t count)
{ {
struct file *myfile; struct cx25821_video_out_data *out = chan->out;
int frame_index_temp = dev->_frame_index; int line_size = (out->_pixel_format == PIXEL_FRMT_411) ?
int i = 0;
int line_size = (dev->_pixel_format == PIXEL_FRMT_411) ?
Y411_LINE_SZ : Y422_LINE_SZ; Y411_LINE_SZ : Y422_LINE_SZ;
int frame_size = 0; int frame_size = 0;
int frame_offset = 0; int frame_offset = 0;
ssize_t vfs_read_retval = 0; int curpos = out->curpos;
char mybuf[line_size];
loff_t file_offset;
loff_t pos;
mm_segment_t old_fs;
if (dev->_file_status == END_OF_FILE) if (out->is_60hz)
return 0;
if (dev->_isNTSC)
frame_size = (line_size == Y411_LINE_SZ) ? frame_size = (line_size == Y411_LINE_SZ) ?
FRAME_SIZE_NTSC_Y411 : FRAME_SIZE_NTSC_Y422; FRAME_SIZE_NTSC_Y411 : FRAME_SIZE_NTSC_Y422;
else else
frame_size = (line_size == Y411_LINE_SZ) ? frame_size = (line_size == Y411_LINE_SZ) ?
FRAME_SIZE_PAL_Y411 : FRAME_SIZE_PAL_Y422; FRAME_SIZE_PAL_Y411 : FRAME_SIZE_PAL_Y422;
frame_offset = (frame_index_temp > 0) ? frame_size : 0; if (curpos == 0) {
file_offset = dev->_frame_count * frame_size; out->cur_frame_index = out->_frame_index;
if (wait_event_interruptible(out->waitq, out->cur_frame_index != out->_frame_index))
myfile = filp_open(dev->_filename, O_RDONLY | O_LARGEFILE, 0); return -EINTR;
out->cur_frame_index = out->_frame_index;
if (IS_ERR(myfile)) {
const int open_errno = -PTR_ERR(myfile);
pr_err("%s(): ERROR opening file(%s) with errno = %d!\n",
__func__, dev->_filename, open_errno);
return PTR_ERR(myfile);
} else {
if (!(myfile->f_op)) {
pr_err("%s(): File has no file operations registered!\n",
__func__);
filp_close(myfile, NULL);
return -EIO;
}
if (!myfile->f_op->read) {
pr_err("%s(): File has no READ operations registered!\n",
__func__);
filp_close(myfile, NULL);
return -EIO;
} }
pos = myfile->f_pos; frame_offset = out->cur_frame_index ? frame_size : 0;
old_fs = get_fs();
set_fs(KERNEL_DS);
for (i = 0; i < dev->_lines_count; i++) {
pos = file_offset;
vfs_read_retval = vfs_read(myfile, mybuf, line_size,
&pos);
if (vfs_read_retval > 0 && vfs_read_retval == line_size if (frame_size - curpos < count)
&& dev->_data_buf_virt_addr != NULL) { count = frame_size - curpos;
memcpy((void *)(dev->_data_buf_virt_addr + memcpy((char *)out->_data_buf_virt_addr + frame_offset + curpos,
frame_offset / 4), mybuf, data, count);
vfs_read_retval); curpos += count;
} if (curpos == frame_size) {
out->_frame_count++;
file_offset += vfs_read_retval; curpos = 0;
frame_offset += vfs_read_retval;
if (vfs_read_retval < line_size) {
pr_info("Done: exit %s() since no more bytes to read from Video file\n",
__func__);
break;
}
} }
out->curpos = curpos;
if (i > 0) return count;
dev->_frame_count++;
dev->_file_status = (vfs_read_retval == line_size) ?
IN_PROGRESS : END_OF_FILE;
set_fs(old_fs);
filp_close(myfile, NULL);
}
return 0;
} }
static void cx25821_vidups_handler(struct work_struct *work) static int cx25821_upstream_buffer_prepare(struct cx25821_channel *chan,
{ const struct sram_channel *sram_ch,
struct cx25821_dev *dev = container_of(work, struct cx25821_dev,
_irq_work_entry);
if (!dev) {
pr_err("ERROR %s(): since container_of(work_struct) FAILED!\n",
__func__);
return;
}
cx25821_get_frame(dev, dev->channels[dev->_channel_upstream_select].
sram_channels);
}
static int cx25821_openfile(struct cx25821_dev *dev,
struct sram_channel *sram_ch)
{
struct file *myfile;
int i = 0, j = 0;
int line_size = (dev->_pixel_format == PIXEL_FRMT_411) ?
Y411_LINE_SZ : Y422_LINE_SZ;
ssize_t vfs_read_retval = 0;
char mybuf[line_size];
loff_t pos;
loff_t offset = (unsigned long)0;
mm_segment_t old_fs;
myfile = filp_open(dev->_filename, O_RDONLY | O_LARGEFILE, 0);
if (IS_ERR(myfile)) {
const int open_errno = -PTR_ERR(myfile);
pr_err("%s(): ERROR opening file(%s) with errno = %d!\n",
__func__, dev->_filename, open_errno);
return PTR_ERR(myfile);
} else {
if (!(myfile->f_op)) {
pr_err("%s(): File has no file operations registered!\n",
__func__);
filp_close(myfile, NULL);
return -EIO;
}
if (!myfile->f_op->read) {
pr_err("%s(): File has no READ operations registered! Returning\n",
__func__);
filp_close(myfile, NULL);
return -EIO;
}
pos = myfile->f_pos;
old_fs = get_fs();
set_fs(KERNEL_DS);
for (j = 0; j < NUM_FRAMES; j++) {
for (i = 0; i < dev->_lines_count; i++) {
pos = offset;
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) {
memcpy((void *)(dev->
_data_buf_virt_addr +
offset / 4), mybuf,
vfs_read_retval);
}
offset += vfs_read_retval;
if (vfs_read_retval < line_size) {
pr_info("Done: exit %s() since no more bytes to read from Video file\n",
__func__);
break;
}
}
if (i > 0)
dev->_frame_count++;
if (vfs_read_retval < line_size)
break;
}
dev->_file_status = (vfs_read_retval == line_size) ?
IN_PROGRESS : END_OF_FILE;
set_fs(old_fs);
myfile->f_pos = 0;
filp_close(myfile, NULL);
}
return 0;
}
static int cx25821_upstream_buffer_prepare(struct cx25821_dev *dev,
struct sram_channel *sram_ch,
int bpl) int bpl)
{ {
struct cx25821_video_out_data *out = chan->out;
struct cx25821_dev *dev = chan->dev;
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 != NULL) if (out->_dma_virt_addr != NULL)
pci_free_consistent(dev->pci, dev->upstream_riscbuf_size, pci_free_consistent(dev->pci, out->upstream_riscbuf_size,
dev->_dma_virt_addr, dev->_dma_phys_addr); out->_dma_virt_addr, out->_dma_phys_addr);
dev->_dma_virt_addr = pci_alloc_consistent(dev->pci, out->_dma_virt_addr = pci_alloc_consistent(dev->pci,
dev->upstream_riscbuf_size, &dma_addr); out->upstream_riscbuf_size, &dma_addr);
dev->_dma_virt_start_addr = dev->_dma_virt_addr; out->_dma_virt_start_addr = out->_dma_virt_addr;
dev->_dma_phys_start_addr = dma_addr; out->_dma_phys_start_addr = dma_addr;
dev->_dma_phys_addr = dma_addr; out->_dma_phys_addr = dma_addr;
dev->_risc_size = dev->upstream_riscbuf_size; out->_risc_size = out->upstream_riscbuf_size;
if (!dev->_dma_virt_addr) { if (!out->_dma_virt_addr) {
pr_err("FAILED to allocate memory for Risc buffer! Returning\n"); pr_err("FAILED to allocate memory for Risc buffer! Returning\n");
return -ENOMEM; return -ENOMEM;
} }
/* Clear memory at address */ /* Clear memory at address */
memset(dev->_dma_virt_addr, 0, dev->_risc_size); memset(out->_dma_virt_addr, 0, out->_risc_size);
if (dev->_data_buf_virt_addr != NULL) if (out->_data_buf_virt_addr != NULL)
pci_free_consistent(dev->pci, dev->upstream_databuf_size, pci_free_consistent(dev->pci, out->upstream_databuf_size,
dev->_data_buf_virt_addr, out->_data_buf_virt_addr,
dev->_data_buf_phys_addr); out->_data_buf_phys_addr);
/* For Video Data buffer allocation */ /* For Video Data buffer allocation */
dev->_data_buf_virt_addr = pci_alloc_consistent(dev->pci, out->_data_buf_virt_addr = pci_alloc_consistent(dev->pci,
dev->upstream_databuf_size, &data_dma_addr); out->upstream_databuf_size, &data_dma_addr);
dev->_data_buf_phys_addr = data_dma_addr; out->_data_buf_phys_addr = data_dma_addr;
dev->_data_buf_size = dev->upstream_databuf_size; out->_data_buf_size = out->upstream_databuf_size;
if (!dev->_data_buf_virt_addr) { if (!out->_data_buf_virt_addr) {
pr_err("FAILED to allocate memory for data buffer! Returning\n"); pr_err("FAILED to allocate memory for data buffer! Returning\n");
return -ENOMEM; return -ENOMEM;
} }
/* Clear memory at address */ /* Clear memory at address */
memset(dev->_data_buf_virt_addr, 0, dev->_data_buf_size); memset(out->_data_buf_virt_addr, 0, out->_data_buf_size);
ret = cx25821_openfile(dev, sram_ch);
if (ret < 0)
return ret;
/* Create RISC programs */ /* Create RISC programs */
ret = cx25821_risc_buffer_upstream(dev, dev->pci, 0, bpl, ret = cx25821_risc_buffer_upstream(chan, dev->pci, 0, bpl,
dev->_lines_count); out->_lines_count);
if (ret < 0) { if (ret < 0) {
pr_info("Failed creating Video Upstream Risc programs!\n"); pr_info("Failed creating Video Upstream Risc programs!\n");
goto error; goto error;
...@@ -551,11 +403,12 @@ static int cx25821_upstream_buffer_prepare(struct cx25821_dev *dev, ...@@ -551,11 +403,12 @@ static int cx25821_upstream_buffer_prepare(struct cx25821_dev *dev,
return ret; return ret;
} }
static int cx25821_video_upstream_irq(struct cx25821_dev *dev, int chan_num, static int cx25821_video_upstream_irq(struct cx25821_channel *chan, u32 status)
u32 status)
{ {
struct cx25821_video_out_data *out = chan->out;
struct cx25821_dev *dev = chan->dev;
u32 int_msk_tmp; u32 int_msk_tmp;
struct sram_channel *channel = dev->channels[chan_num].sram_channels; const struct sram_channel *channel = chan->sram_channels;
int singlefield_lines = NTSC_FIELD_HEIGHT; int singlefield_lines = NTSC_FIELD_HEIGHT;
int line_size_in_bytes = Y422_LINE_SZ; int line_size_in_bytes = Y422_LINE_SZ;
int odd_risc_prog_size = 0; int odd_risc_prog_size = 0;
...@@ -572,16 +425,16 @@ static int cx25821_video_upstream_irq(struct cx25821_dev *dev, int chan_num, ...@@ -572,16 +425,16 @@ static int cx25821_video_upstream_irq(struct cx25821_dev *dev, int chan_num,
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); wake_up(&out->waitq);
dev->_frame_index = prog_cnt; spin_lock(&dev->slock);
queue_work(dev->_irq_queues, &dev->_irq_work_entry); out->_frame_index = prog_cnt;
if (dev->_is_first_frame) { if (out->_is_first_frame) {
dev->_is_first_frame = 0; out->_is_first_frame = 0;
if (dev->_isNTSC) { if (out->is_60hz) {
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 {
...@@ -589,17 +442,17 @@ static int cx25821_video_upstream_irq(struct cx25821_dev *dev, int chan_num, ...@@ -589,17 +442,17 @@ static int cx25821_video_upstream_irq(struct cx25821_dev *dev, int chan_num,
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 (out->_dma_virt_start_addr != NULL) {
line_size_in_bytes = line_size_in_bytes =
(dev->_pixel_format == (out->_pixel_format ==
PIXEL_FRMT_411) ? Y411_LINE_SZ : PIXEL_FRMT_411) ? Y411_LINE_SZ :
Y422_LINE_SZ; Y422_LINE_SZ;
risc_phys_jump_addr = risc_phys_jump_addr =
dev->_dma_phys_start_addr + out->_dma_phys_start_addr +
odd_risc_prog_size; odd_risc_prog_size;
rp = cx25821_update_riscprogram(dev, rp = cx25821_update_riscprogram(chan,
dev->_dma_virt_start_addr, TOP_OFFSET, out->_dma_virt_start_addr, TOP_OFFSET,
line_size_in_bytes, 0x0, line_size_in_bytes, 0x0,
singlefield_lines, FIFO_DISABLE, singlefield_lines, FIFO_DISABLE,
ODD_FIELD); ODD_FIELD);
...@@ -626,8 +479,8 @@ static int cx25821_video_upstream_irq(struct cx25821_dev *dev, int chan_num, ...@@ -626,8 +479,8 @@ static int cx25821_video_upstream_irq(struct cx25821_dev *dev, int chan_num,
__func__); __func__);
} }
if (dev->_file_status == END_OF_FILE) { if (out->_file_status == END_OF_FILE) {
pr_err("EOF Channel 1 Framecount = %d\n", dev->_frame_count); pr_err("EOF Channel 1 Framecount = %d\n", out->_frame_count);
return -1; return -1;
} }
/* ElSE, set the interrupt mask register, re-enable irq. */ /* ElSE, set the interrupt mask register, re-enable irq. */
...@@ -639,47 +492,41 @@ static int cx25821_video_upstream_irq(struct cx25821_dev *dev, int chan_num, ...@@ -639,47 +492,41 @@ static int cx25821_video_upstream_irq(struct cx25821_dev *dev, int chan_num,
static irqreturn_t cx25821_upstream_irq(int irq, void *dev_id) static irqreturn_t cx25821_upstream_irq(int irq, void *dev_id)
{ {
struct cx25821_dev *dev = dev_id; struct cx25821_channel *chan = dev_id;
struct cx25821_dev *dev = chan->dev;
u32 vid_status; u32 vid_status;
int handled = 0; int handled = 0;
int channel_num = 0; const struct sram_channel *sram_ch;
struct sram_channel *sram_ch;
if (!dev) if (!dev)
return -1; return -1;
channel_num = VID_UPSTREAM_SRAM_CHANNEL_I; sram_ch = chan->sram_channels;
sram_ch = dev->channels[channel_num].sram_channels;
vid_status = cx_read(sram_ch->int_stat); vid_status = cx_read(sram_ch->int_stat);
/* Only deal with our interrupt */ /* Only deal with our interrupt */
if (vid_status) if (vid_status)
handled = cx25821_video_upstream_irq(dev, channel_num, handled = cx25821_video_upstream_irq(chan, vid_status);
vid_status);
if (handled < 0)
cx25821_stop_upstream_video_ch1(dev);
else
handled += handled;
return IRQ_RETVAL(handled); return IRQ_RETVAL(handled);
} }
static void cx25821_set_pixelengine(struct cx25821_dev *dev, static void cx25821_set_pixelengine(struct cx25821_channel *chan,
struct sram_channel *ch, const struct sram_channel *ch,
int pix_format) int pix_format)
{ {
struct cx25821_video_out_data *out = chan->out;
struct cx25821_dev *dev = chan->dev;
int width = WIDTH_D1; int width = WIDTH_D1;
int height = dev->_lines_count; int height = out->_lines_count;
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;
value |= dev->_isNTSC ? 0 : 0x10; value |= out->is_60hz ? 0 : 0x10;
cx_write(ch->vid_fmt_ctl, value); cx_write(ch->vid_fmt_ctl, value);
/* set number of active pixels in each line. /* set number of active pixels in each line.
...@@ -689,7 +536,7 @@ static void cx25821_set_pixelengine(struct cx25821_dev *dev, ...@@ -689,7 +536,7 @@ static void cx25821_set_pixelengine(struct cx25821_dev *dev,
num_lines = (height / 2) & 0x3FF; num_lines = (height / 2) & 0x3FF;
odd_num_lines = num_lines; odd_num_lines = num_lines;
if (dev->_isNTSC) if (out->is_60hz)
odd_num_lines += 1; odd_num_lines += 1;
value = (num_lines << 16) | odd_num_lines; value = (num_lines << 16) | odd_num_lines;
...@@ -700,9 +547,11 @@ static void cx25821_set_pixelengine(struct cx25821_dev *dev, ...@@ -700,9 +547,11 @@ static void cx25821_set_pixelengine(struct cx25821_dev *dev,
cx_write(ch->vid_cdt_size, VID_CDT_SIZE >> 3); cx_write(ch->vid_cdt_size, VID_CDT_SIZE >> 3);
} }
static int cx25821_start_video_dma_upstream(struct cx25821_dev *dev, static int cx25821_start_video_dma_upstream(struct cx25821_channel *chan,
struct sram_channel *sram_ch) const struct sram_channel *sram_ch)
{ {
struct cx25821_video_out_data *out = chan->out;
struct cx25821_dev *dev = chan->dev;
u32 tmp = 0; u32 tmp = 0;
int err = 0; int err = 0;
...@@ -715,7 +564,7 @@ static int cx25821_start_video_dma_upstream(struct cx25821_dev *dev, ...@@ -715,7 +564,7 @@ static int cx25821_start_video_dma_upstream(struct cx25821_dev *dev,
/* Set the physical start address of the RISC program in the initial /* Set the physical start address of the RISC program in the initial
* program counter(IPC) member of the cmds. * program counter(IPC) member of the cmds.
*/ */
cx_write(sram_ch->cmds_start + 0, dev->_dma_phys_addr); cx_write(sram_ch->cmds_start + 0, out->_dma_phys_addr);
/* Risc IPC High 64 bits 63-32 */ /* Risc IPC High 64 bits 63-32 */
cx_write(sram_ch->cmds_start + 4, 0); cx_write(sram_ch->cmds_start + 4, 0);
...@@ -731,7 +580,7 @@ static int cx25821_start_video_dma_upstream(struct cx25821_dev *dev, ...@@ -731,7 +580,7 @@ static int cx25821_start_video_dma_upstream(struct cx25821_dev *dev,
cx_write(sram_ch->int_msk, tmp |= _intr_msk); cx_write(sram_ch->int_msk, tmp |= _intr_msk);
err = request_irq(dev->pci->irq, cx25821_upstream_irq, err = request_irq(dev->pci->irq, cx25821_upstream_irq,
IRQF_SHARED, dev->name, dev); IRQF_SHARED, dev->name, chan);
if (err < 0) { if (err < 0) {
pr_err("%s: can't get upstream IRQ %d\n", pr_err("%s: can't get upstream IRQ %d\n",
dev->name, dev->pci->irq); dev->name, dev->pci->irq);
...@@ -742,8 +591,8 @@ static int cx25821_start_video_dma_upstream(struct cx25821_dev *dev, ...@@ -742,8 +591,8 @@ static int cx25821_start_video_dma_upstream(struct cx25821_dev *dev,
tmp = cx_read(sram_ch->dma_ctl); tmp = cx_read(sram_ch->dma_ctl);
cx_set(sram_ch->dma_ctl, tmp | FLD_VID_RISC_EN); cx_set(sram_ch->dma_ctl, tmp | FLD_VID_RISC_EN);
dev->_is_running = 1; out->_is_running = 1;
dev->_is_first_frame = 1; out->_is_first_frame = 1;
return 0; return 0;
...@@ -752,107 +601,71 @@ static int cx25821_start_video_dma_upstream(struct cx25821_dev *dev, ...@@ -752,107 +601,71 @@ static int cx25821_start_video_dma_upstream(struct cx25821_dev *dev,
return err; return err;
} }
int cx25821_vidupstream_init_ch1(struct cx25821_dev *dev, int channel_select, int cx25821_vidupstream_init(struct cx25821_channel *chan,
int pixel_format) int pixel_format)
{ {
struct sram_channel *sram_ch; struct cx25821_video_out_data *out = chan->out;
struct cx25821_dev *dev = chan->dev;
const struct sram_channel *sram_ch;
u32 tmp; u32 tmp;
int err = 0; int err = 0;
int data_frame_size = 0; int data_frame_size = 0;
int risc_buffer_size = 0; int risc_buffer_size = 0;
int str_length = 0;
if (dev->_is_running) { if (out->_is_running) {
pr_info("Video Channel is still running so return!\n"); pr_info("Video Channel is still running so return!\n");
return 0; return 0;
} }
dev->_channel_upstream_select = channel_select; sram_ch = chan->sram_channels;
sram_ch = dev->channels[channel_select].sram_channels;
INIT_WORK(&dev->_irq_work_entry, cx25821_vidups_handler); out->is_60hz = dev->tvnorm & V4L2_STD_525_60;
dev->_irq_queues = create_singlethread_workqueue("cx25821_workqueue");
if (!dev->_irq_queues) {
pr_err("create_singlethread_workqueue() for Video FAILED!\n");
return -ENOMEM;
}
/* 656/VIP SRC Upstream Channel I & J and 7 - Host Bus Interface for /* 656/VIP SRC Upstream Channel I & J and 7 - Host Bus Interface for
* channel A-C * 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; out->_is_running = 0;
dev->_frame_count = 0; out->_frame_count = 0;
dev->_file_status = RESET_STATUS; out->_file_status = RESET_STATUS;
dev->_lines_count = dev->_isNTSC ? 480 : 576; out->_lines_count = out->is_60hz ? 480 : 576;
dev->_pixel_format = pixel_format; out->_pixel_format = pixel_format;
dev->_line_size = (dev->_pixel_format == PIXEL_FRMT_422) ? out->_line_size = (out->_pixel_format == PIXEL_FRMT_422) ?
(WIDTH_D1 * 2) : (WIDTH_D1 * 3) / 2; (WIDTH_D1 * 2) : (WIDTH_D1 * 3) / 2;
data_frame_size = dev->_isNTSC ? NTSC_DATA_BUF_SZ : PAL_DATA_BUF_SZ; data_frame_size = out->is_60hz ? NTSC_DATA_BUF_SZ : PAL_DATA_BUF_SZ;
risc_buffer_size = dev->_isNTSC ? risc_buffer_size = out->is_60hz ?
NTSC_RISC_BUF_SIZE : PAL_RISC_BUF_SIZE; NTSC_RISC_BUF_SIZE : PAL_RISC_BUF_SIZE;
if (dev->input_filename) { out->_is_running = 0;
str_length = strlen(dev->input_filename); out->_frame_count = 0;
dev->_filename = kmemdup(dev->input_filename, str_length + 1, out->_file_status = RESET_STATUS;
GFP_KERNEL); out->_lines_count = out->is_60hz ? 480 : 576;
out->_pixel_format = pixel_format;
if (!dev->_filename) { out->_line_size = (out->_pixel_format == PIXEL_FRMT_422) ?
err = -ENOENT;
goto error;
}
} else {
str_length = strlen(dev->_defaultname);
dev->_filename = kmemdup(dev->_defaultname, str_length + 1,
GFP_KERNEL);
if (!dev->_filename) {
err = -ENOENT;
goto error;
}
}
/* Default if filename is empty string */
if (strcmp(dev->_filename, "") == 0) {
if (dev->_isNTSC) {
dev->_filename =
(dev->_pixel_format == PIXEL_FRMT_411) ?
"/root/vid411.yuv" : "/root/vidtest.yuv";
} else {
dev->_filename =
(dev->_pixel_format == PIXEL_FRMT_411) ?
"/root/pal411.yuv" : "/root/pal422.yuv";
}
}
dev->_is_running = 0;
dev->_frame_count = 0;
dev->_file_status = RESET_STATUS;
dev->_lines_count = dev->_isNTSC ? 480 : 576;
dev->_pixel_format = pixel_format;
dev->_line_size = (dev->_pixel_format == PIXEL_FRMT_422) ?
(WIDTH_D1 * 2) : (WIDTH_D1 * 3) / 2; (WIDTH_D1 * 2) : (WIDTH_D1 * 3) / 2;
out->curpos = 0;
init_waitqueue_head(&out->waitq);
err = cx25821_sram_channel_setup_upstream(dev, sram_ch, err = cx25821_sram_channel_setup_upstream(dev, sram_ch,
dev->_line_size, 0); out->_line_size, 0);
/* setup fifo + format */ /* setup fifo + format */
cx25821_set_pixelengine(dev, sram_ch, dev->_pixel_format); cx25821_set_pixelengine(chan, sram_ch, out->_pixel_format);
dev->upstream_riscbuf_size = risc_buffer_size * 2; out->upstream_riscbuf_size = risc_buffer_size * 2;
dev->upstream_databuf_size = data_frame_size * 2; out->upstream_databuf_size = data_frame_size * 2;
/* Allocating buffers and prepare RISC program */ /* Allocating buffers and prepare RISC program */
err = cx25821_upstream_buffer_prepare(dev, sram_ch, dev->_line_size); err = cx25821_upstream_buffer_prepare(chan, sram_ch, out->_line_size);
if (err < 0) { if (err < 0) {
pr_err("%s: Failed to set up Video upstream buffers!\n", pr_err("%s: Failed to set up Video upstream buffers!\n",
dev->name); dev->name);
goto error; goto error;
} }
cx25821_start_video_dma_upstream(dev, sram_ch); cx25821_start_video_dma_upstream(chan, sram_ch);
return 0; return 0;
......
drivers/media/pci/cx25821/cx25821-video.c
View file @ a5d0568e
...@@ -33,13 +33,10 @@ MODULE_AUTHOR("Hiep Huynh <hiep.huynh@conexant.com>"); ...@@ -33,13 +33,10 @@ MODULE_AUTHOR("Hiep Huynh <hiep.huynh@conexant.com>");
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
static unsigned int video_nr[] = {[0 ... (CX25821_MAXBOARDS - 1)] = UNSET }; static unsigned int video_nr[] = {[0 ... (CX25821_MAXBOARDS - 1)] = UNSET };
static unsigned int radio_nr[] = {[0 ... (CX25821_MAXBOARDS - 1)] = UNSET };
module_param_array(video_nr, int, NULL, 0444); module_param_array(video_nr, int, NULL, 0444);
module_param_array(radio_nr, int, NULL, 0444);
MODULE_PARM_DESC(video_nr, "video device numbers"); MODULE_PARM_DESC(video_nr, "video device numbers");
MODULE_PARM_DESC(radio_nr, "radio device numbers");
static unsigned int video_debug = VIDEO_DEBUG; static unsigned int video_debug = VIDEO_DEBUG;
module_param(video_debug, int, 0644); module_param(video_debug, int, 0644);
...@@ -49,24 +46,14 @@ static unsigned int irq_debug; ...@@ -49,24 +46,14 @@ static unsigned int irq_debug;
module_param(irq_debug, int, 0644); module_param(irq_debug, int, 0644);
MODULE_PARM_DESC(irq_debug, "enable debug messages [IRQ handler]"); MODULE_PARM_DESC(irq_debug, "enable debug messages [IRQ handler]");
unsigned int vid_limit = 16; static unsigned int vid_limit = 16;
module_param(vid_limit, int, 0644); module_param(vid_limit, int, 0644);
MODULE_PARM_DESC(vid_limit, "capture memory limit in megabytes"); MODULE_PARM_DESC(vid_limit, "capture memory limit in megabytes");
static void cx25821_init_controls(struct cx25821_dev *dev, int chan_num);
static const struct v4l2_file_operations video_fops;
static const struct v4l2_ioctl_ops video_ioctl_ops;
#define FORMAT_FLAGS_PACKED 0x01 #define FORMAT_FLAGS_PACKED 0x01
struct cx25821_fmt formats[] = { static const struct cx25821_fmt formats[] = {
{ {
.name = "8 bpp, gray",
.fourcc = V4L2_PIX_FMT_GREY,
.depth = 8,
.flags = FORMAT_FLAGS_PACKED,
}, {
.name = "4:1:1, packed, Y41P", .name = "4:1:1, packed, Y41P",
.fourcc = V4L2_PIX_FMT_Y41P, .fourcc = V4L2_PIX_FMT_Y41P,
.depth = 12, .depth = 12,
...@@ -76,36 +63,16 @@ struct cx25821_fmt formats[] = { ...@@ -76,36 +63,16 @@ struct cx25821_fmt formats[] = {
.fourcc = V4L2_PIX_FMT_YUYV, .fourcc = V4L2_PIX_FMT_YUYV,
.depth = 16, .depth = 16,
.flags = FORMAT_FLAGS_PACKED, .flags = FORMAT_FLAGS_PACKED,
}, {
.name = "4:2:2, packed, UYVY",
.fourcc = V4L2_PIX_FMT_UYVY,
.depth = 16,
.flags = FORMAT_FLAGS_PACKED,
}, {
.name = "4:2:0, YUV",
.fourcc = V4L2_PIX_FMT_YUV420,
.depth = 12,
.flags = FORMAT_FLAGS_PACKED,
}, },
}; };
int cx25821_get_format_size(void) static const struct cx25821_fmt *cx25821_format_by_fourcc(unsigned int fourcc)
{
return ARRAY_SIZE(formats);
}
struct cx25821_fmt *cx25821_format_by_fourcc(unsigned int fourcc)
{ {
unsigned int i; unsigned int i;
if (fourcc == V4L2_PIX_FMT_Y41P || fourcc == V4L2_PIX_FMT_YUV411P)
return formats + 1;
for (i = 0; i < ARRAY_SIZE(formats); i++) for (i = 0; i < ARRAY_SIZE(formats); i++)
if (formats[i].fourcc == fourcc) if (formats[i].fourcc == fourcc)
return formats + i; return formats + i;
pr_err("%s(0x%08x) NOT FOUND\n", __func__, fourcc);
return NULL; return NULL;
} }
...@@ -144,129 +111,10 @@ void cx25821_video_wakeup(struct cx25821_dev *dev, struct cx25821_dmaqueue *q, ...@@ -144,129 +111,10 @@ void cx25821_video_wakeup(struct cx25821_dev *dev, struct cx25821_dmaqueue *q,
pr_err("%s: %d buffers handled (should be 1)\n", __func__, bc); pr_err("%s: %d buffers handled (should be 1)\n", __func__, bc);
} }
#ifdef TUNER_FLAG
int cx25821_set_tvnorm(struct cx25821_dev *dev, v4l2_std_id norm)
{
dprintk(1, "%s(norm = 0x%08x) name: [%s]\n",
__func__, (unsigned int)norm, v4l2_norm_to_name(norm));
dev->tvnorm = norm;
/* Tell the internal A/V decoder */
cx25821_call_all(dev, core, s_std, norm);
return 0;
}
#endif
struct video_device *cx25821_vdev_init(struct cx25821_dev *dev,
struct pci_dev *pci,
struct video_device *template,
char *type)
{
struct video_device *vfd;
dprintk(1, "%s()\n", __func__);
vfd = video_device_alloc();
if (NULL == vfd)
return NULL;
*vfd = *template;
vfd->v4l2_dev = &dev->v4l2_dev;
vfd->release = video_device_release;
snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)", dev->name, type,
cx25821_boards[dev->board].name);
video_set_drvdata(vfd, dev);
return vfd;
}
/*
static int cx25821_ctrl_query(struct v4l2_queryctrl *qctrl)
{
int i;
if (qctrl->id < V4L2_CID_BASE || qctrl->id >= V4L2_CID_LASTP1)
return -EINVAL;
for (i = 0; i < CX25821_CTLS; i++)
if (cx25821_ctls[i].v.id == qctrl->id)
break;
if (i == CX25821_CTLS) {
*qctrl = no_ctl;
return 0;
}
*qctrl = cx25821_ctls[i].v;
return 0;
}
*/
/* resource management */
int cx25821_res_get(struct cx25821_dev *dev, struct cx25821_fh *fh,
unsigned int bit)
{
dprintk(1, "%s()\n", __func__);
if (fh->resources & bit)
/* have it already allocated */
return 1;
/* is it free? */
mutex_lock(&dev->lock);
if (dev->channels[fh->channel_id].resources & bit) {
/* no, someone else uses it */
mutex_unlock(&dev->lock);
return 0;
}
/* it's free, grab it */
fh->resources |= bit;
dev->channels[fh->channel_id].resources |= bit;
dprintk(1, "res: get %d\n", bit);
mutex_unlock(&dev->lock);
return 1;
}
int cx25821_res_check(struct cx25821_fh *fh, unsigned int bit)
{
return fh->resources & bit;
}
int cx25821_res_locked(struct cx25821_fh *fh, unsigned int bit)
{
return fh->dev->channels[fh->channel_id].resources & bit;
}
void cx25821_res_free(struct cx25821_dev *dev, struct cx25821_fh *fh,
unsigned int bits)
{
BUG_ON((fh->resources & bits) != bits);
dprintk(1, "%s()\n", __func__);
mutex_lock(&dev->lock);
fh->resources &= ~bits;
dev->channels[fh->channel_id].resources &= ~bits;
dprintk(1, "res: put %d\n", bits);
mutex_unlock(&dev->lock);
}
int cx25821_video_mux(struct cx25821_dev *dev, unsigned int input)
{
struct v4l2_routing route;
memset(&route, 0, sizeof(route));
dprintk(1, "%s(): video_mux: %d [vmux=%d, gpio=0x%x,0x%x,0x%x,0x%x]\n",
__func__, input, INPUT(input)->vmux, INPUT(input)->gpio0,
INPUT(input)->gpio1, INPUT(input)->gpio2, INPUT(input)->gpio3);
dev->input = input;
route.input = INPUT(input)->vmux;
/* Tell the internal A/V decoder */
cx25821_call_all(dev, video, s_routing, INPUT(input)->vmux, 0, 0);
return 0;
}
int cx25821_start_video_dma(struct cx25821_dev *dev, 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) const struct sram_channel *channel)
{ {
int tmp = 0; int tmp = 0;
...@@ -293,7 +141,7 @@ int cx25821_start_video_dma(struct cx25821_dev *dev, ...@@ -293,7 +141,7 @@ int cx25821_start_video_dma(struct cx25821_dev *dev,
static int cx25821_restart_video_queue(struct cx25821_dev *dev, static int cx25821_restart_video_queue(struct cx25821_dev *dev,
struct cx25821_dmaqueue *q, struct cx25821_dmaqueue *q,
struct sram_channel *channel) const struct sram_channel *channel)
{ {
struct cx25821_buffer *buf, *prev; struct cx25821_buffer *buf, *prev;
struct list_head *item; struct list_head *item;
...@@ -346,8 +194,8 @@ static void cx25821_vid_timeout(unsigned long data) ...@@ -346,8 +194,8 @@ static void cx25821_vid_timeout(unsigned long data)
{ {
struct cx25821_data *timeout_data = (struct cx25821_data *)data; struct cx25821_data *timeout_data = (struct cx25821_data *)data;
struct cx25821_dev *dev = timeout_data->dev; struct cx25821_dev *dev = timeout_data->dev;
struct sram_channel *channel = timeout_data->channel; const struct sram_channel *channel = timeout_data->channel;
struct cx25821_dmaqueue *q = &dev->channels[channel->i].vidq; struct cx25821_dmaqueue *q = &dev->channels[channel->i].dma_vidq;
struct cx25821_buffer *buf; struct cx25821_buffer *buf;
unsigned long flags; unsigned long flags;
...@@ -373,7 +221,7 @@ int cx25821_video_irq(struct cx25821_dev *dev, int chan_num, u32 status) ...@@ -373,7 +221,7 @@ int cx25821_video_irq(struct cx25821_dev *dev, int chan_num, u32 status)
u32 count = 0; u32 count = 0;
int handled = 0; int handled = 0;
u32 mask; u32 mask;
struct sram_channel *channel = dev->channels[chan_num].sram_channels; const struct sram_channel *channel = dev->channels[chan_num].sram_channels;
mask = cx_read(channel->int_msk); mask = cx_read(channel->int_msk);
if (0 == (status & mask)) if (0 == (status & mask))
...@@ -393,7 +241,7 @@ int cx25821_video_irq(struct cx25821_dev *dev, int chan_num, u32 status) ...@@ -393,7 +241,7 @@ int cx25821_video_irq(struct cx25821_dev *dev, int chan_num, u32 status)
if (status & FLD_VID_DST_RISC1) { if (status & FLD_VID_DST_RISC1) {
spin_lock(&dev->slock); spin_lock(&dev->slock);
count = cx_read(channel->gpcnt); count = cx_read(channel->gpcnt);
cx25821_video_wakeup(dev, &dev->channels[channel->i].vidq, cx25821_video_wakeup(dev, &dev->channels[channel->i].dma_vidq,
count); count);
spin_unlock(&dev->slock); spin_unlock(&dev->slock);
handled++; handled++;
...@@ -404,122 +252,19 @@ int cx25821_video_irq(struct cx25821_dev *dev, int chan_num, u32 status) ...@@ -404,122 +252,19 @@ int cx25821_video_irq(struct cx25821_dev *dev, int chan_num, u32 status)
dprintk(2, "stopper video\n"); dprintk(2, "stopper video\n");
spin_lock(&dev->slock); spin_lock(&dev->slock);
cx25821_restart_video_queue(dev, cx25821_restart_video_queue(dev,
&dev->channels[channel->i].vidq, channel); &dev->channels[channel->i].dma_vidq, channel);
spin_unlock(&dev->slock); spin_unlock(&dev->slock);
handled++; handled++;
} }
return handled; return handled;
} }
void cx25821_videoioctl_unregister(struct cx25821_dev *dev) static int cx25821_buffer_setup(struct videobuf_queue *q, unsigned int *count,
{
if (dev->ioctl_dev) {
if (video_is_registered(dev->ioctl_dev))
video_unregister_device(dev->ioctl_dev);
else
video_device_release(dev->ioctl_dev);
dev->ioctl_dev = NULL;
}
}
void cx25821_video_unregister(struct cx25821_dev *dev, int chan_num)
{
cx_clear(PCI_INT_MSK, 1);
if (dev->channels[chan_num].video_dev) {
if (video_is_registered(dev->channels[chan_num].video_dev))
video_unregister_device(
dev->channels[chan_num].video_dev);
else
video_device_release(
dev->channels[chan_num].video_dev);
dev->channels[chan_num].video_dev = NULL;
btcx_riscmem_free(dev->pci,
&dev->channels[chan_num].vidq.stopper);
pr_warn("device %d released!\n", chan_num);
}
}
int cx25821_video_register(struct cx25821_dev *dev)
{
int err;
int i;
struct video_device cx25821_video_device = {
.name = "cx25821-video",
.fops = &video_fops,
.minor = -1,
.ioctl_ops = &video_ioctl_ops,
.tvnorms = CX25821_NORMS,
.current_norm = V4L2_STD_NTSC_M,
};
spin_lock_init(&dev->slock);
for (i = 0; i < MAX_VID_CHANNEL_NUM - 1; ++i) {
cx25821_init_controls(dev, i);
cx25821_risc_stopper(dev->pci, &dev->channels[i].vidq.stopper,
dev->channels[i].sram_channels->dma_ctl, 0x11, 0);
dev->channels[i].sram_channels = &cx25821_sram_channels[i];
dev->channels[i].video_dev = NULL;
dev->channels[i].resources = 0;
cx_write(dev->channels[i].sram_channels->int_stat, 0xffffffff);
INIT_LIST_HEAD(&dev->channels[i].vidq.active);
INIT_LIST_HEAD(&dev->channels[i].vidq.queued);
dev->channels[i].timeout_data.dev = dev;
dev->channels[i].timeout_data.channel =
&cx25821_sram_channels[i];
dev->channels[i].vidq.timeout.function = cx25821_vid_timeout;
dev->channels[i].vidq.timeout.data =
(unsigned long)&dev->channels[i].timeout_data;
init_timer(&dev->channels[i].vidq.timeout);
/* register v4l devices */
dev->channels[i].video_dev = cx25821_vdev_init(dev, dev->pci,
&cx25821_video_device, "video");
err = video_register_device(dev->channels[i].video_dev,
VFL_TYPE_GRABBER, video_nr[dev->nr]);
if (err < 0)
goto fail_unreg;
}
/* set PCI interrupt */
cx_set(PCI_INT_MSK, 0xff);
/* initial device configuration */
mutex_lock(&dev->lock);
#ifdef TUNER_FLAG
dev->tvnorm = cx25821_video_device.current_norm;
cx25821_set_tvnorm(dev, dev->tvnorm);
#endif
mutex_unlock(&dev->lock);
return 0;
fail_unreg:
cx25821_video_unregister(dev, i);
return err;
}
int cx25821_buffer_setup(struct videobuf_queue *q, unsigned int *count,
unsigned int *size) unsigned int *size)
{ {
struct cx25821_fh *fh = q->priv_data; struct cx25821_channel *chan = q->priv_data;
*size = fh->fmt->depth * fh->width * fh->height >> 3; *size = chan->fmt->depth * chan->width * chan->height >> 3;
if (0 == *count) if (0 == *count)
*count = 32; *count = 32;
...@@ -530,35 +275,34 @@ int cx25821_buffer_setup(struct videobuf_queue *q, unsigned int *count, ...@@ -530,35 +275,34 @@ int cx25821_buffer_setup(struct videobuf_queue *q, unsigned int *count,
return 0; return 0;
} }
int cx25821_buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb, static int cx25821_buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
enum v4l2_field field) enum v4l2_field field)
{ {
struct cx25821_fh *fh = q->priv_data; struct cx25821_channel *chan = q->priv_data;
struct cx25821_dev *dev = fh->dev; struct cx25821_dev *dev = chan->dev;
struct cx25821_buffer *buf = struct cx25821_buffer *buf =
container_of(vb, struct cx25821_buffer, vb); container_of(vb, struct cx25821_buffer, vb);
int rc, init_buffer = 0; int rc, init_buffer = 0;
u32 line0_offset; u32 line0_offset;
struct videobuf_dmabuf *dma = videobuf_to_dma(&buf->vb); struct videobuf_dmabuf *dma = videobuf_to_dma(&buf->vb);
int bpl_local = LINE_SIZE_D1; int bpl_local = LINE_SIZE_D1;
int channel_opened = fh->channel_id;
BUG_ON(NULL == fh->fmt); BUG_ON(NULL == chan->fmt);
if (fh->width < 48 || fh->width > 720 || if (chan->width < 48 || chan->width > 720 ||
fh->height < 32 || fh->height > 576) chan->height < 32 || chan->height > 576)
return -EINVAL; return -EINVAL;
buf->vb.size = (fh->width * fh->height * fh->fmt->depth) >> 3; buf->vb.size = (chan->width * chan->height * chan->fmt->depth) >> 3;
if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size) if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
return -EINVAL; return -EINVAL;
if (buf->fmt != fh->fmt || if (buf->fmt != chan->fmt ||
buf->vb.width != fh->width || buf->vb.width != chan->width ||
buf->vb.height != fh->height || buf->vb.field != field) { buf->vb.height != chan->height || buf->vb.field != field) {
buf->fmt = fh->fmt; buf->fmt = chan->fmt;
buf->vb.width = fh->width; buf->vb.width = chan->width;
buf->vb.height = fh->height; buf->vb.height = chan->height;
buf->vb.field = field; buf->vb.field = field;
init_buffer = 1; init_buffer = 1;
} }
...@@ -575,34 +319,21 @@ int cx25821_buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb, ...@@ -575,34 +319,21 @@ int cx25821_buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
dprintk(1, "init_buffer=%d\n", init_buffer); dprintk(1, "init_buffer=%d\n", init_buffer);
if (init_buffer) { if (init_buffer) {
if (chan->pixel_formats == PIXEL_FRMT_411)
channel_opened = dev->channel_opened;
if (channel_opened < 0 || channel_opened > 7)
channel_opened = 7;
if (dev->channels[channel_opened].pixel_formats ==
PIXEL_FRMT_411)
buf->bpl = (buf->fmt->depth * buf->vb.width) >> 3; buf->bpl = (buf->fmt->depth * buf->vb.width) >> 3;
else else
buf->bpl = (buf->fmt->depth >> 3) * (buf->vb.width); buf->bpl = (buf->fmt->depth >> 3) * (buf->vb.width);
if (dev->channels[channel_opened].pixel_formats == if (chan->pixel_formats == PIXEL_FRMT_411) {
PIXEL_FRMT_411) {
bpl_local = buf->bpl; bpl_local = buf->bpl;
} else { } else {
bpl_local = buf->bpl; /* Default */ bpl_local = buf->bpl; /* Default */
if (channel_opened >= 0 && channel_opened <= 7) { if (chan->use_cif_resolution) {
if (dev->channels[channel_opened] if (dev->tvnorm & V4L2_STD_625_50)
.use_cif_resolution) {
if (dev->tvnorm & V4L2_STD_PAL_BG ||
dev->tvnorm & V4L2_STD_PAL_DK)
bpl_local = 352 << 1; bpl_local = 352 << 1;
else else
bpl_local = dev->channels[ bpl_local = chan->cif_width << 1;
channel_opened].
cif_width << 1;
}
} }
} }
...@@ -645,8 +376,8 @@ int cx25821_buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb, ...@@ -645,8 +376,8 @@ int cx25821_buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
} }
dprintk(2, "[%p/%d] buffer_prep - %dx%d %dbpp \"%s\" - dma=0x%08lx\n", dprintk(2, "[%p/%d] buffer_prep - %dx%d %dbpp \"%s\" - dma=0x%08lx\n",
buf, buf->vb.i, fh->width, fh->height, fh->fmt->depth, buf, buf->vb.i, chan->width, chan->height, chan->fmt->depth,
fh->fmt->name, (unsigned long)buf->risc.dma); chan->fmt->name, (unsigned long)buf->risc.dma);
buf->vb.state = VIDEOBUF_PREPARED; buf->vb.state = VIDEOBUF_PREPARED;
...@@ -657,7 +388,7 @@ int cx25821_buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb, ...@@ -657,7 +388,7 @@ int cx25821_buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
return rc; return rc;
} }
void cx25821_buffer_release(struct videobuf_queue *q, static void cx25821_buffer_release(struct videobuf_queue *q,
struct videobuf_buffer *vb) struct videobuf_buffer *vb)
{ {
struct cx25821_buffer *buf = struct cx25821_buffer *buf =
...@@ -666,33 +397,11 @@ void cx25821_buffer_release(struct videobuf_queue *q, ...@@ -666,33 +397,11 @@ void cx25821_buffer_release(struct videobuf_queue *q,
cx25821_free_buffer(q, buf); cx25821_free_buffer(q, buf);
} }
struct videobuf_queue *get_queue(struct cx25821_fh *fh) static int cx25821_video_mmap(struct file *file, struct vm_area_struct *vma)
{
switch (fh->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE:
return &fh->vidq;
default:
BUG();
return NULL;
}
}
int cx25821_get_resource(struct cx25821_fh *fh, int resource)
{
switch (fh->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE:
return resource;
default:
BUG();
return 0;
}
}
int cx25821_video_mmap(struct file *file, struct vm_area_struct *vma)
{ {
struct cx25821_fh *fh = file->private_data; struct cx25821_channel *chan = video_drvdata(file);
return videobuf_mmap_mapper(get_queue(fh), vma); return videobuf_mmap_mapper(&chan->vidq, vma);
} }
...@@ -701,9 +410,9 @@ static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb) ...@@ -701,9 +410,9 @@ static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
struct cx25821_buffer *buf = struct cx25821_buffer *buf =
container_of(vb, struct cx25821_buffer, vb); container_of(vb, struct cx25821_buffer, vb);
struct cx25821_buffer *prev; struct cx25821_buffer *prev;
struct cx25821_fh *fh = vq->priv_data; struct cx25821_channel *chan = vq->priv_data;
struct cx25821_dev *dev = fh->dev; struct cx25821_dev *dev = chan->dev;
struct cx25821_dmaqueue *q = &dev->channels[fh->channel_id].vidq; struct cx25821_dmaqueue *q = &dev->channels[chan->id].dma_vidq;
/* add jump to stopper */ /* add jump to stopper */
buf->risc.jmp[0] = cpu_to_le32(RISC_JUMP | RISC_IRQ1 | RISC_CNT_INC); buf->risc.jmp[0] = cpu_to_le32(RISC_JUMP | RISC_IRQ1 | RISC_CNT_INC);
...@@ -720,8 +429,7 @@ static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb) ...@@ -720,8 +429,7 @@ static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
} 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, cx25821_start_video_dma(dev, q, buf, chan->sram_channels);
dev->channels[fh->channel_id].sram_channels);
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);
...@@ -762,1183 +470,487 @@ static struct videobuf_queue_ops cx25821_video_qops = { ...@@ -762,1183 +470,487 @@ static struct videobuf_queue_ops cx25821_video_qops = {
.buf_release = cx25821_buffer_release, .buf_release = cx25821_buffer_release,
}; };
static int video_open(struct file *file)
{
struct video_device *vdev = video_devdata(file);
struct cx25821_dev *h, *dev = video_drvdata(file);
struct cx25821_fh *fh;
struct list_head *list;
int minor = video_devdata(file)->minor;
enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
u32 pix_format;
int ch_id = 0;
int i;
dprintk(1, "open dev=%s type=%s\n", video_device_node_name(vdev),
v4l2_type_names[type]);
/* allocate + initialize per filehandle data */
fh = kzalloc(sizeof(*fh), GFP_KERNEL);
if (NULL == fh)
return -ENOMEM;
mutex_lock(&cx25821_devlist_mutex);
list_for_each(list, &cx25821_devlist)
{
h = list_entry(list, struct cx25821_dev, devlist);
for (i = 0; i < MAX_VID_CHANNEL_NUM; i++) {
if (h->channels[i].video_dev &&
h->channels[i].video_dev->minor == minor) {
dev = h;
ch_id = i;
type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
}
}
}
if (NULL == dev) {
mutex_unlock(&cx25821_devlist_mutex);
kfree(fh);
return -ENODEV;
}
file->private_data = fh;
fh->dev = dev;
fh->type = type;
fh->width = 720;
fh->channel_id = ch_id;
if (dev->tvnorm & V4L2_STD_PAL_BG || dev->tvnorm & V4L2_STD_PAL_DK)
fh->height = 576;
else
fh->height = 480;
dev->channel_opened = fh->channel_id;
if (dev->channels[ch_id].pixel_formats == PIXEL_FRMT_411)
pix_format = V4L2_PIX_FMT_Y41P;
else
pix_format = V4L2_PIX_FMT_YUYV;
fh->fmt = cx25821_format_by_fourcc(pix_format);
v4l2_prio_open(&dev->channels[ch_id].prio, &fh->prio);
videobuf_queue_sg_init(&fh->vidq, &cx25821_video_qops, &dev->pci->dev,
&dev->slock, V4L2_BUF_TYPE_VIDEO_CAPTURE,
V4L2_FIELD_INTERLACED, sizeof(struct cx25821_buffer),
fh, NULL);
dprintk(1, "post videobuf_queue_init()\n");
mutex_unlock(&cx25821_devlist_mutex);
return 0;
}
static ssize_t video_read(struct file *file, char __user * data, size_t count, static ssize_t video_read(struct file *file, char __user * data, size_t count,
loff_t *ppos) loff_t *ppos)
{ {
struct cx25821_fh *fh = file->private_data; struct v4l2_fh *fh = file->private_data;
struct cx25821_channel *chan = video_drvdata(file);
struct cx25821_dev *dev = chan->dev;
int err = 0;
switch (fh->type) { if (mutex_lock_interruptible(&dev->lock))
case V4L2_BUF_TYPE_VIDEO_CAPTURE: return -ERESTARTSYS;
if (cx25821_res_locked(fh, RESOURCE_VIDEO0)) if (chan->streaming_fh && chan->streaming_fh != fh) {
return -EBUSY; err = -EBUSY;
goto unlock;
}
chan->streaming_fh = fh;
return videobuf_read_one(&fh->vidq, data, count, ppos, err = videobuf_read_one(&chan->vidq, data, count, ppos,
file->f_flags & O_NONBLOCK); file->f_flags & O_NONBLOCK);
unlock:
default: mutex_unlock(&dev->lock);
BUG(); return err;
return 0;
}
} }
static unsigned int video_poll(struct file *file, static unsigned int video_poll(struct file *file,
struct poll_table_struct *wait) struct poll_table_struct *wait)
{ {
struct cx25821_fh *fh = file->private_data; struct cx25821_channel *chan = video_drvdata(file);
struct cx25821_buffer *buf; unsigned long req_events = poll_requested_events(wait);
unsigned int res = v4l2_ctrl_poll(file, wait);
if (cx25821_res_check(fh, RESOURCE_VIDEO0)) { if (req_events & (POLLIN | POLLRDNORM))
/* streaming capture */ res |= videobuf_poll_stream(file, &chan->vidq, wait);
if (list_empty(&fh->vidq.stream)) return res;
return POLLERR;
buf = list_entry(fh->vidq.stream.next,
struct cx25821_buffer, vb.stream);
} else {
/* read() capture */
buf = (struct cx25821_buffer *)fh->vidq.read_buf;
if (NULL == buf)
return POLLERR;
}
poll_wait(file, &buf->vb.done, wait); /* This doesn't belong in poll(). This can be done
if (buf->vb.state == VIDEOBUF_DONE || buf->vb.state == VIDEOBUF_ERROR) { * much better with vb2. We keep this code here as a
if (buf->vb.state == VIDEOBUF_DONE) { * reminder.
struct cx25821_dev *dev = fh->dev; if ((res & POLLIN) && buf->vb.state == VIDEOBUF_DONE) {
struct cx25821_dev *dev = chan->dev;
if (dev && dev->channels[fh->channel_id] if (dev && chan->use_cif_resolution) {
.use_cif_resolution) {
u8 cam_id = *((char *)buf->vb.baddr + 3); u8 cam_id = *((char *)buf->vb.baddr + 3);
memcpy((char *)buf->vb.baddr, memcpy((char *)buf->vb.baddr,
(char *)buf->vb.baddr + (fh->width * 2), (char *)buf->vb.baddr + (chan->width * 2),
(fh->width * 2)); (chan->width * 2));
*((char *)buf->vb.baddr + 3) = cam_id; *((char *)buf->vb.baddr + 3) = cam_id;
} }
} }
*/
return POLLIN | POLLRDNORM;
}
return 0;
} }
static int video_release(struct file *file) static int video_release(struct file *file)
{ {
struct cx25821_fh *fh = file->private_data; struct cx25821_channel *chan = video_drvdata(file);
struct cx25821_dev *dev = fh->dev; struct v4l2_fh *fh = file->private_data;
struct cx25821_dev *dev = chan->dev;
const struct sram_channel *sram_ch =
dev->channels[0].sram_channels;
mutex_lock(&dev->lock);
/* stop the risc engine and fifo */ /* stop the risc engine and fifo */
cx_write(channel0->dma_ctl, 0); /* FIFO and RISC disable */ cx_write(sram_ch->dma_ctl, 0); /* FIFO and RISC disable */
/* stop video capture */ /* stop video capture */
if (cx25821_res_check(fh, RESOURCE_VIDEO0)) { if (chan->streaming_fh == fh) {
videobuf_queue_cancel(&fh->vidq); videobuf_queue_cancel(&chan->vidq);
cx25821_res_free(dev, fh, RESOURCE_VIDEO0); chan->streaming_fh = NULL;
} }
if (fh->vidq.read_buf) { if (chan->vidq.read_buf) {
cx25821_buffer_release(&fh->vidq, fh->vidq.read_buf); cx25821_buffer_release(&chan->vidq, chan->vidq.read_buf);
kfree(fh->vidq.read_buf); kfree(chan->vidq.read_buf);
} }
videobuf_mmap_free(&fh->vidq); videobuf_mmap_free(&chan->vidq);
mutex_unlock(&dev->lock);
v4l2_prio_close(&dev->channels[fh->channel_id].prio, fh->prio);
file->private_data = NULL;
kfree(fh);
return 0; return v4l2_fh_release(file);
} }
static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i) /* VIDEO IOCTLS */
{
struct cx25821_fh *fh = priv;
struct cx25821_dev *dev = fh->dev;
if (unlikely(fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)) static int cx25821_vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
struct v4l2_fmtdesc *f)
{
if (unlikely(f->index >= ARRAY_SIZE(formats)))
return -EINVAL; return -EINVAL;
if (unlikely(i != fh->type)) strlcpy(f->description, formats[f->index].name, sizeof(f->description));
return -EINVAL; f->pixelformat = formats[f->index].fourcc;
if (unlikely(!cx25821_res_get(dev, fh, cx25821_get_resource(fh, return 0;
RESOURCE_VIDEO0)))) }
return -EBUSY;
static int cx25821_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
struct v4l2_format *f)
{
struct cx25821_channel *chan = video_drvdata(file);
return videobuf_streamon(get_queue(fh)); f->fmt.pix.width = chan->width;
f->fmt.pix.height = chan->height;
f->fmt.pix.field = chan->vidq.field;
f->fmt.pix.pixelformat = chan->fmt->fourcc;
f->fmt.pix.bytesperline = (chan->width * chan->fmt->depth) >> 3;
f->fmt.pix.sizeimage = chan->height * f->fmt.pix.bytesperline;
f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
f->fmt.pix.priv = 0;
return 0;
} }
static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i) static int cx25821_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
struct v4l2_format *f)
{ {
struct cx25821_fh *fh = priv; struct cx25821_channel *chan = video_drvdata(file);
struct cx25821_dev *dev = fh->dev; struct cx25821_dev *dev = chan->dev;
int err, res; const struct cx25821_fmt *fmt;
enum v4l2_field field = f->fmt.pix.field;
unsigned int maxw, maxh;
unsigned w;
if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) fmt = cx25821_format_by_fourcc(f->fmt.pix.pixelformat);
return -EINVAL; if (NULL == fmt)
if (i != fh->type)
return -EINVAL; return -EINVAL;
maxw = 720;
maxh = (dev->tvnorm & V4L2_STD_625_50) ? 576 : 480;
w = f->fmt.pix.width;
if (field != V4L2_FIELD_BOTTOM)
field = V4L2_FIELD_TOP;
if (w < 352) {
w = 176;
f->fmt.pix.height = maxh / 4;
} else if (w < 720) {
w = 352;
f->fmt.pix.height = maxh / 2;
} else {
w = 720;
f->fmt.pix.height = maxh;
field = V4L2_FIELD_INTERLACED;
}
f->fmt.pix.field = field;
f->fmt.pix.width = w;
f->fmt.pix.bytesperline = (f->fmt.pix.width * fmt->depth) >> 3;
f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
f->fmt.pix.priv = 0;
res = cx25821_get_resource(fh, RESOURCE_VIDEO0);
err = videobuf_streamoff(get_queue(fh));
if (err < 0)
return err;
cx25821_res_free(dev, fh, res);
return 0; return 0;
} }
static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
struct v4l2_format *f) struct v4l2_format *f)
{ {
struct cx25821_fh *fh = priv; struct cx25821_channel *chan = video_drvdata(file);
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = chan->dev;
struct v4l2_mbus_framefmt mbus_fmt;
int err;
int pix_format = PIXEL_FRMT_422; int pix_format = PIXEL_FRMT_422;
int err;
if (fh) {
err = v4l2_prio_check(&dev->channels[fh->channel_id].prio,
fh->prio);
if (0 != err)
return err;
}
dprintk(2, "%s()\n", __func__);
err = cx25821_vidioc_try_fmt_vid_cap(file, priv, f); err = cx25821_vidioc_try_fmt_vid_cap(file, priv, f);
if (0 != err) if (0 != err)
return err; return err;
fh->fmt = cx25821_format_by_fourcc(f->fmt.pix.pixelformat); chan->fmt = cx25821_format_by_fourcc(f->fmt.pix.pixelformat);
fh->vidq.field = f->fmt.pix.field; chan->vidq.field = f->fmt.pix.field;
chan->width = f->fmt.pix.width;
/* check if width and height is valid based on set standard */ chan->height = f->fmt.pix.height;
if (cx25821_is_valid_width(f->fmt.pix.width, dev->tvnorm))
fh->width = f->fmt.pix.width;
if (cx25821_is_valid_height(f->fmt.pix.height, dev->tvnorm))
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)
pix_format = PIXEL_FRMT_422;
else else
return -EINVAL; pix_format = PIXEL_FRMT_422;
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 (chan->width == 320 || chan->width == 352)
dev->channels[fh->channel_id].use_cif_resolution = 1; chan->use_cif_resolution = 1;
else else
dev->channels[fh->channel_id].use_cif_resolution = 0; chan->use_cif_resolution = 0;
chan->cif_width = chan->width;
medusa_set_resolution(dev, chan->width, SRAM_CH00);
return 0;
}
dev->channels[fh->channel_id].cif_width = fh->width; static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
medusa_set_resolution(dev, fh->width, SRAM_CH00); {
struct cx25821_channel *chan = video_drvdata(file);
if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
return -EINVAL;
if (chan->streaming_fh && chan->streaming_fh != priv)
return -EBUSY;
chan->streaming_fh = priv;
return videobuf_streamon(&chan->vidq);
}
dprintk(2, "%s(): width=%d height=%d field=%d\n", __func__, fh->width, static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
fh->height, fh->vidq.field); {
v4l2_fill_mbus_format(&mbus_fmt, &f->fmt.pix, V4L2_MBUS_FMT_FIXED); struct cx25821_channel *chan = video_drvdata(file);
cx25821_call_all(dev, video, s_mbus_fmt, &mbus_fmt);
if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
return -EINVAL;
if (chan->streaming_fh && chan->streaming_fh != priv)
return -EBUSY;
if (chan->streaming_fh == NULL)
return 0; return 0;
chan->streaming_fh = NULL;
return videobuf_streamoff(&chan->vidq);
} }
static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p) static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
{ {
int ret_val = 0; int ret_val = 0;
struct cx25821_fh *fh = priv; struct cx25821_channel *chan = video_drvdata(file);
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(&chan->vidq, p, file->f_flags & O_NONBLOCK);
p->sequence = chan->dma_vidq.count;
p->sequence = dev->channels[fh->channel_id].vidq.count;
return ret_val; return ret_val;
} }
static int vidioc_log_status(struct file *file, void *priv) static int vidioc_log_status(struct file *file, void *priv)
{ {
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_channel *chan = video_drvdata(file);
struct cx25821_fh *fh = priv; struct cx25821_dev *dev = chan->dev;
char name[32 + 2]; const struct sram_channel *sram_ch = chan->sram_channels;
struct sram_channel *sram_ch = dev->channels[fh->channel_id]
.sram_channels;
u32 tmp = 0; u32 tmp = 0;
snprintf(name, sizeof(name), "%s/2", dev->name);
pr_info("%s/2: ============ START LOG STATUS ============\n",
dev->name);
cx25821_call_all(dev, core, log_status);
tmp = cx_read(sram_ch->dma_ctl); tmp = cx_read(sram_ch->dma_ctl);
pr_info("Video input 0 is %s\n", pr_info("Video input 0 is %s\n",
(tmp & 0x11) ? "streaming" : "stopped"); (tmp & 0x11) ? "streaming" : "stopped");
pr_info("%s/2: ============= END LOG STATUS =============\n",
dev->name);
return 0; return 0;
} }
static int vidioc_s_ctrl(struct file *file, void *priv,
struct v4l2_control *ctl)
{
struct cx25821_fh *fh = priv;
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
int err;
if (fh) {
err = v4l2_prio_check(&dev->channels[fh->channel_id].prio,
fh->prio);
if (0 != err)
return err;
}
return cx25821_set_control(dev, ctl, fh->channel_id);
}
/* VIDEO IOCTLS */
int cx25821_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
struct v4l2_format *f)
{
struct cx25821_fh *fh = priv;
f->fmt.pix.width = fh->width;
f->fmt.pix.height = fh->height;
f->fmt.pix.field = fh->vidq.field;
f->fmt.pix.pixelformat = fh->fmt->fourcc;
f->fmt.pix.bytesperline = (f->fmt.pix.width * fh->fmt->depth) >> 3;
f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
return 0;
}
int cx25821_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
struct v4l2_format *f)
{
struct cx25821_fmt *fmt;
enum v4l2_field field;
unsigned int maxw, maxh;
fmt = cx25821_format_by_fourcc(f->fmt.pix.pixelformat);
if (NULL == fmt)
return -EINVAL;
field = f->fmt.pix.field;
maxw = 720;
maxh = 576;
if (V4L2_FIELD_ANY == field) { static int cx25821_vidioc_querycap(struct file *file, void *priv,
if (f->fmt.pix.height > maxh / 2)
field = V4L2_FIELD_INTERLACED;
else
field = V4L2_FIELD_TOP;
}
switch (field) {
case V4L2_FIELD_TOP:
case V4L2_FIELD_BOTTOM:
maxh = maxh / 2;
break;
case V4L2_FIELD_INTERLACED:
break;
default:
return -EINVAL;
}
f->fmt.pix.field = field;
if (f->fmt.pix.height < 32)
f->fmt.pix.height = 32;
if (f->fmt.pix.height > maxh)
f->fmt.pix.height = maxh;
if (f->fmt.pix.width < 48)
f->fmt.pix.width = 48;
if (f->fmt.pix.width > maxw)
f->fmt.pix.width = maxw;
f->fmt.pix.width &= ~0x03;
f->fmt.pix.bytesperline = (f->fmt.pix.width * fmt->depth) >> 3;
f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
return 0;
}
int cx25821_vidioc_querycap(struct file *file, void *priv,
struct v4l2_capability *cap) struct v4l2_capability *cap)
{ {
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_channel *chan = video_drvdata(file);
struct cx25821_dev *dev = chan->dev;
const u32 cap_input = V4L2_CAP_VIDEO_CAPTURE |
V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
const u32 cap_output = V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_READWRITE;
strcpy(cap->driver, "cx25821"); strcpy(cap->driver, "cx25821");
strlcpy(cap->card, cx25821_boards[dev->board].name, sizeof(cap->card)); strlcpy(cap->card, cx25821_boards[dev->board].name, sizeof(cap->card));
sprintf(cap->bus_info, "PCIe:%s", pci_name(dev->pci)); sprintf(cap->bus_info, "PCIe:%s", pci_name(dev->pci));
cap->version = CX25821_VERSION_CODE; if (chan->id >= VID_CHANNEL_NUM)
cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE | cap->device_caps = cap_output;
V4L2_CAP_STREAMING; else
if (UNSET != dev->tuner_type) cap->device_caps = cap_input;
cap->capabilities |= V4L2_CAP_TUNER; cap->capabilities = cap_input | cap_output | V4L2_CAP_DEVICE_CAPS;
return 0;
}
int cx25821_vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
struct v4l2_fmtdesc *f)
{
if (unlikely(f->index >= ARRAY_SIZE(formats)))
return -EINVAL;
strlcpy(f->description, formats[f->index].name, sizeof(f->description));
f->pixelformat = formats[f->index].fourcc;
return 0; return 0;
} }
int cx25821_vidioc_reqbufs(struct file *file, void *priv, static int cx25821_vidioc_reqbufs(struct file *file, void *priv,
struct v4l2_requestbuffers *p) struct v4l2_requestbuffers *p)
{ {
struct cx25821_fh *fh = priv; struct cx25821_channel *chan = video_drvdata(file);
return videobuf_reqbufs(get_queue(fh), p);
return videobuf_reqbufs(&chan->vidq, p);
} }
int cx25821_vidioc_querybuf(struct file *file, void *priv, static int cx25821_vidioc_querybuf(struct file *file, void *priv,
struct v4l2_buffer *p) struct v4l2_buffer *p)
{ {
struct cx25821_fh *fh = priv; struct cx25821_channel *chan = video_drvdata(file);
return videobuf_querybuf(get_queue(fh), p);
}
int cx25821_vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p) return videobuf_querybuf(&chan->vidq, p);
{
struct cx25821_fh *fh = priv;
return videobuf_qbuf(get_queue(fh), p);
} }
int cx25821_vidioc_g_priority(struct file *file, void *f, enum v4l2_priority *p) static int cx25821_vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
{ {
struct cx25821_dev *dev = ((struct cx25821_fh *)f)->dev; struct cx25821_channel *chan = video_drvdata(file);
struct cx25821_fh *fh = f;
*p = v4l2_prio_max(&dev->channels[fh->channel_id].prio); return videobuf_qbuf(&chan->vidq, p);
return 0;
} }
int cx25821_vidioc_s_priority(struct file *file, void *f, static int cx25821_vidioc_g_std(struct file *file, void *priv, v4l2_std_id *tvnorms)
enum v4l2_priority prio)
{ {
struct cx25821_fh *fh = f; struct cx25821_channel *chan = video_drvdata(file);
struct cx25821_dev *dev = ((struct cx25821_fh *)f)->dev;
return v4l2_prio_change(&dev->channels[fh->channel_id].prio, &fh->prio, *tvnorms = chan->dev->tvnorm;
prio); return 0;
} }
#ifdef TUNER_FLAG
int cx25821_vidioc_s_std(struct file *file, void *priv, v4l2_std_id tvnorms) int cx25821_vidioc_s_std(struct file *file, void *priv, v4l2_std_id tvnorms)
{ {
struct cx25821_fh *fh = priv; struct cx25821_channel *chan = video_drvdata(file);
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; struct cx25821_dev *dev = chan->dev;
int err;
dprintk(1, "%s()\n", __func__);
if (fh) {
err = v4l2_prio_check(&dev->channels[fh->channel_id].prio,
fh->prio);
if (0 != err)
return err;
}
if (dev->tvnorm == tvnorms) if (dev->tvnorm == tvnorms)
return 0; return 0;
mutex_lock(&dev->lock); dev->tvnorm = tvnorms;
cx25821_set_tvnorm(dev, tvnorms); chan->width = 720;
mutex_unlock(&dev->lock); chan->height = (dev->tvnorm & V4L2_STD_625_50) ? 576 : 480;
medusa_set_videostandard(dev); medusa_set_videostandard(dev);
return 0; return 0;
} }
#endif
int cx25821_enum_input(struct cx25821_dev *dev, struct v4l2_input *i) static int cx25821_vidioc_enum_input(struct file *file, void *priv,
struct v4l2_input *i)
{ {
static const char * const iname[] = { if (i->index)
[CX25821_VMUX_COMPOSITE] = "Composite",
[CX25821_VMUX_SVIDEO] = "S-Video",
[CX25821_VMUX_DEBUG] = "for debug only",
};
unsigned int n;
dprintk(1, "%s()\n", __func__);
n = i->index;
if (n >= 2)
return -EINVAL;
if (0 == INPUT(n)->type)
return -EINVAL; return -EINVAL;
i->type = V4L2_INPUT_TYPE_CAMERA; i->type = V4L2_INPUT_TYPE_CAMERA;
strcpy(i->name, iname[INPUT(n)->type]);
i->std = CX25821_NORMS; i->std = CX25821_NORMS;
strcpy(i->name, "Composite");
return 0; return 0;
} }
int cx25821_vidioc_enum_input(struct file *file, void *priv, static int cx25821_vidioc_g_input(struct file *file, void *priv, unsigned int *i)
struct v4l2_input *i)
{ {
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev; *i = 0;
dprintk(1, "%s()\n", __func__);
return cx25821_enum_input(dev, i);
}
int cx25821_vidioc_g_input(struct file *file, void *priv, unsigned int *i)
{
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
*i = dev->input;
dprintk(1, "%s(): returns %d\n", __func__, *i);
return 0;
}
int cx25821_vidioc_s_input(struct file *file, void *priv, unsigned int i)
{
struct cx25821_fh *fh = priv;
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
int err;
dprintk(1, "%s(%d)\n", __func__, i);
if (fh) {
err = v4l2_prio_check(&dev->channels[fh->channel_id].prio,
fh->prio);
if (0 != err)
return err;
}
if (i >= CX25821_NR_INPUT) {
dprintk(1, "%s(): -EINVAL\n", __func__);
return -EINVAL;
}
mutex_lock(&dev->lock);
cx25821_video_mux(dev, i);
mutex_unlock(&dev->lock);
return 0; return 0;
} }
#ifdef TUNER_FLAG static int cx25821_vidioc_s_input(struct file *file, void *priv, unsigned int i)
int cx25821_vidioc_g_frequency(struct file *file, void *priv,
struct v4l2_frequency *f)
{ {
struct cx25821_fh *fh = priv; return i ? -EINVAL : 0;
struct cx25821_dev *dev = fh->dev;
f->frequency = dev->freq;
cx25821_call_all(dev, tuner, g_frequency, f);
return 0;
} }
int cx25821_set_freq(struct cx25821_dev *dev, const struct v4l2_frequency *f) static int cx25821_s_ctrl(struct v4l2_ctrl *ctrl)
{ {
mutex_lock(&dev->lock); struct cx25821_channel *chan =
dev->freq = f->frequency; container_of(ctrl->handler, struct cx25821_channel, hdl);
struct cx25821_dev *dev = chan->dev;
cx25821_call_all(dev, tuner, s_frequency, f);
/* When changing channels it is required to reset TVAUDIO */ switch (ctrl->id) {
msleep(10);
mutex_unlock(&dev->lock);
return 0;
}
int cx25821_vidioc_s_frequency(struct file *file, void *priv,
const struct v4l2_frequency *f)
{
struct cx25821_fh *fh = priv;
struct cx25821_dev *dev;
int err;
if (fh) {
dev = fh->dev;
err = v4l2_prio_check(&dev->channels[fh->channel_id].prio,
fh->prio);
if (0 != err)
return err;
} else {
pr_err("Invalid fh pointer!\n");
return -EINVAL;
}
return cx25821_set_freq(dev, f);
}
#endif
#ifdef CONFIG_VIDEO_ADV_DEBUG
int cx25821_vidioc_g_register(struct file *file, void *fh,
struct v4l2_dbg_register *reg)
{
struct cx25821_dev *dev = ((struct cx25821_fh *)fh)->dev;
if (!v4l2_chip_match_host(&reg->match))
return -EINVAL;
cx25821_call_all(dev, core, g_register, reg);
return 0;
}
int cx25821_vidioc_s_register(struct file *file, void *fh,
const struct v4l2_dbg_register *reg)
{
struct cx25821_dev *dev = ((struct cx25821_fh *)fh)->dev;
if (!v4l2_chip_match_host(&reg->match))
return -EINVAL;
cx25821_call_all(dev, core, s_register, reg);
return 0;
}
#endif
#ifdef TUNER_FLAG
int cx25821_vidioc_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
{
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
if (unlikely(UNSET == dev->tuner_type))
return -EINVAL;
if (0 != t->index)
return -EINVAL;
strcpy(t->name, "Television");
t->type = V4L2_TUNER_ANALOG_TV;
t->capability = V4L2_TUNER_CAP_NORM;
t->rangehigh = 0xffffffffUL;
t->signal = 0xffff; /* LOCKED */
return 0;
}
int cx25821_vidioc_s_tuner(struct file *file, void *priv, const struct v4l2_tuner *t)
{
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
struct cx25821_fh *fh = priv;
int err;
if (fh) {
err = v4l2_prio_check(&dev->channels[fh->channel_id].prio,
fh->prio);
if (0 != err)
return err;
}
dprintk(1, "%s()\n", __func__);
if (UNSET == dev->tuner_type)
return -EINVAL;
if (0 != t->index)
return -EINVAL;
return 0;
}
#endif
/*****************************************************************************/
static const struct v4l2_queryctrl no_ctl = {
.name = "42",
.flags = V4L2_CTRL_FLAG_DISABLED,
};
static struct v4l2_queryctrl cx25821_ctls[] = {
/* --- video --- */
{
.id = V4L2_CID_BRIGHTNESS,
.name = "Brightness",
.minimum = 0,
.maximum = 10000,
.step = 1,
.default_value = 6200,
.type = V4L2_CTRL_TYPE_INTEGER,
}, {
.id = V4L2_CID_CONTRAST,
.name = "Contrast",
.minimum = 0,
.maximum = 10000,
.step = 1,
.default_value = 5000,
.type = V4L2_CTRL_TYPE_INTEGER,
}, {
.id = V4L2_CID_SATURATION,
.name = "Saturation",
.minimum = 0,
.maximum = 10000,
.step = 1,
.default_value = 5000,
.type = V4L2_CTRL_TYPE_INTEGER,
}, {
.id = V4L2_CID_HUE,
.name = "Hue",
.minimum = 0,
.maximum = 10000,
.step = 1,
.default_value = 5000,
.type = V4L2_CTRL_TYPE_INTEGER,
}
};
static const int CX25821_CTLS = ARRAY_SIZE(cx25821_ctls);
static int cx25821_ctrl_query(struct v4l2_queryctrl *qctrl)
{
int i;
if (qctrl->id < V4L2_CID_BASE || qctrl->id >= V4L2_CID_LASTP1)
return -EINVAL;
for (i = 0; i < CX25821_CTLS; i++)
if (cx25821_ctls[i].id == qctrl->id)
break;
if (i == CX25821_CTLS) {
*qctrl = no_ctl;
return 0;
}
*qctrl = cx25821_ctls[i];
return 0;
}
int cx25821_vidioc_queryctrl(struct file *file, void *priv,
struct v4l2_queryctrl *qctrl)
{
return cx25821_ctrl_query(qctrl);
}
/* ------------------------------------------------------------------ */
/* VIDEO CTRL IOCTLS */
static const struct v4l2_queryctrl *ctrl_by_id(unsigned int id)
{
unsigned int i;
for (i = 0; i < CX25821_CTLS; i++)
if (cx25821_ctls[i].id == id)
return cx25821_ctls + i;
return NULL;
}
int cx25821_vidioc_g_ctrl(struct file *file, void *priv,
struct v4l2_control *ctl)
{
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
struct cx25821_fh *fh = priv;
const struct v4l2_queryctrl *ctrl;
ctrl = ctrl_by_id(ctl->id);
if (NULL == ctrl)
return -EINVAL;
switch (ctl->id) {
case V4L2_CID_BRIGHTNESS: case V4L2_CID_BRIGHTNESS:
ctl->value = dev->channels[fh->channel_id].ctl_bright; medusa_set_brightness(dev, ctrl->val, chan->id);
break; break;
case V4L2_CID_HUE: case V4L2_CID_HUE:
ctl->value = dev->channels[fh->channel_id].ctl_hue; medusa_set_hue(dev, ctrl->val, chan->id);
break; break;
case V4L2_CID_CONTRAST: case V4L2_CID_CONTRAST:
ctl->value = dev->channels[fh->channel_id].ctl_contrast; medusa_set_contrast(dev, ctrl->val, chan->id);
break; break;
case V4L2_CID_SATURATION: case V4L2_CID_SATURATION:
ctl->value = dev->channels[fh->channel_id].ctl_saturation; medusa_set_saturation(dev, ctrl->val, chan->id);
break;
}
return 0;
}
int cx25821_set_control(struct cx25821_dev *dev,
struct v4l2_control *ctl, int chan_num)
{
int err;
const struct v4l2_queryctrl *ctrl;
err = -EINVAL;
ctrl = ctrl_by_id(ctl->id);
if (NULL == ctrl)
return err;
switch (ctrl->type) {
case V4L2_CTRL_TYPE_BOOLEAN:
case V4L2_CTRL_TYPE_MENU:
case V4L2_CTRL_TYPE_INTEGER:
if (ctl->value < ctrl->minimum)
ctl->value = ctrl->minimum;
if (ctl->value > ctrl->maximum)
ctl->value = ctrl->maximum;
break; break;
default: default:
/* nothing */ ;
}
switch (ctl->id) {
case V4L2_CID_BRIGHTNESS:
dev->channels[chan_num].ctl_bright = ctl->value;
medusa_set_brightness(dev, ctl->value, chan_num);
break;
case V4L2_CID_HUE:
dev->channels[chan_num].ctl_hue = ctl->value;
medusa_set_hue(dev, ctl->value, chan_num);
break;
case V4L2_CID_CONTRAST:
dev->channels[chan_num].ctl_contrast = ctl->value;
medusa_set_contrast(dev, ctl->value, chan_num);
break;
case V4L2_CID_SATURATION:
dev->channels[chan_num].ctl_saturation = ctl->value;
medusa_set_saturation(dev, ctl->value, chan_num);
break;
}
err = 0;
return err;
}
static void cx25821_init_controls(struct cx25821_dev *dev, int chan_num)
{
struct v4l2_control ctrl;
int i;
for (i = 0; i < CX25821_CTLS; i++) {
ctrl.id = cx25821_ctls[i].id;
ctrl.value = cx25821_ctls[i].default_value;
cx25821_set_control(dev, &ctrl, chan_num);
}
}
int cx25821_vidioc_cropcap(struct file *file, void *priv,
struct v4l2_cropcap *cropcap)
{
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
if (cropcap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
return -EINVAL; return -EINVAL;
cropcap->bounds.top = 0;
cropcap->bounds.left = 0;
cropcap->bounds.width = 720;
cropcap->bounds.height = dev->tvnorm == V4L2_STD_PAL_BG ? 576 : 480;
cropcap->pixelaspect.numerator =
dev->tvnorm == V4L2_STD_PAL_BG ? 59 : 10;
cropcap->pixelaspect.denominator =
dev->tvnorm == V4L2_STD_PAL_BG ? 54 : 11;
cropcap->defrect = cropcap->bounds;
return 0;
}
int cx25821_vidioc_s_crop(struct file *file, void *priv, const struct v4l2_crop *crop)
{
struct cx25821_dev *dev = ((struct cx25821_fh *)priv)->dev;
struct cx25821_fh *fh = priv;
int err;
if (fh) {
err = v4l2_prio_check(&dev->channels[fh->channel_id].prio,
fh->prio);
if (0 != err)
return err;
} }
/* cx25821_vidioc_s_crop not supported */ return 0;
return -EINVAL;
} }
int cx25821_vidioc_g_crop(struct file *file, void *priv, struct v4l2_crop *crop) static int cx25821_vidioc_enum_output(struct file *file, void *priv,
struct v4l2_output *o)
{ {
/* cx25821_vidioc_g_crop not supported */ if (o->index)
return -EINVAL; return -EINVAL;
}
int cx25821_vidioc_querystd(struct file *file, void *priv, v4l2_std_id * norm)
{
/* medusa does not support video standard sensing of current input */
*norm = CX25821_NORMS;
o->type = V4L2_INPUT_TYPE_CAMERA;
o->std = CX25821_NORMS;
strcpy(o->name, "Composite");
return 0; return 0;
} }
int cx25821_is_valid_width(u32 width, v4l2_std_id tvnorm) static int cx25821_vidioc_g_output(struct file *file, void *priv, unsigned int *o)
{ {
if (tvnorm == V4L2_STD_PAL_BG) { *o = 0;
if (width == 352 || width == 720)
return 1;
else
return 0;
}
if (tvnorm == V4L2_STD_NTSC_M) {
if (width == 320 || width == 352 || width == 720)
return 1;
else
return 0;
}
return 0; return 0;
} }
int cx25821_is_valid_height(u32 height, v4l2_std_id tvnorm) static int cx25821_vidioc_s_output(struct file *file, void *priv, unsigned int o)
{ {
if (tvnorm == V4L2_STD_PAL_BG) { return o ? -EINVAL : 0;
if (height == 576 || height == 288)
return 1;
else
return 0;
}
if (tvnorm == V4L2_STD_NTSC_M) {
if (height == 480 || height == 240)
return 1;
else
return 0;
}
return 0;
} }
static long video_ioctl_upstream9(struct file *file, unsigned int cmd, static int cx25821_vidioc_try_fmt_vid_out(struct file *file, void *priv,
unsigned long arg) struct v4l2_format *f)
{ {
struct cx25821_fh *fh = file->private_data; struct cx25821_channel *chan = video_drvdata(file);
struct cx25821_dev *dev = fh->dev; struct cx25821_dev *dev = chan->dev;
int command = 0; const struct cx25821_fmt *fmt;
struct upstream_user_struct *data_from_user;
data_from_user = (struct upstream_user_struct *)arg;
if (!data_from_user) {
pr_err("%s(): Upstream data is INVALID. Returning\n", __func__);
return 0;
}
command = data_from_user->command;
if (command != UPSTREAM_START_VIDEO && command != UPSTREAM_STOP_VIDEO)
return 0;
dev->input_filename = data_from_user->input_filename;
dev->input_audiofilename = data_from_user->input_filename;
dev->vid_stdname = data_from_user->vid_stdname;
dev->pixel_format = data_from_user->pixel_format;
dev->channel_select = data_from_user->channel_select;
dev->command = data_from_user->command;
switch (command) {
case UPSTREAM_START_VIDEO:
cx25821_start_upstream_video_ch1(dev, data_from_user);
break;
case UPSTREAM_STOP_VIDEO:
cx25821_stop_upstream_video_ch1(dev);
break;
}
fmt = cx25821_format_by_fourcc(f->fmt.pix.pixelformat);
if (NULL == fmt)
return -EINVAL;
f->fmt.pix.width = 720;
f->fmt.pix.height = (dev->tvnorm & V4L2_STD_625_50) ? 576 : 480;
f->fmt.pix.field = V4L2_FIELD_INTERLACED;
f->fmt.pix.bytesperline = (f->fmt.pix.width * fmt->depth) >> 3;
f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
f->fmt.pix.priv = 0;
return 0; return 0;
} }
static long video_ioctl_upstream10(struct file *file, unsigned int cmd, static int vidioc_s_fmt_vid_out(struct file *file, void *priv,
unsigned long arg) struct v4l2_format *f)
{ {
struct cx25821_fh *fh = file->private_data; struct cx25821_channel *chan = video_drvdata(file);
struct cx25821_dev *dev = fh->dev; int err;
int command = 0;
struct upstream_user_struct *data_from_user;
data_from_user = (struct upstream_user_struct *)arg;
if (!data_from_user) {
pr_err("%s(): Upstream data is INVALID. Returning\n", __func__);
return 0;
}
command = data_from_user->command;
if (command != UPSTREAM_START_VIDEO && command != UPSTREAM_STOP_VIDEO)
return 0;
dev->input_filename_ch2 = data_from_user->input_filename;
dev->input_audiofilename = data_from_user->input_filename;
dev->vid_stdname_ch2 = data_from_user->vid_stdname;
dev->pixel_format_ch2 = data_from_user->pixel_format;
dev->channel_select_ch2 = data_from_user->channel_select;
dev->command_ch2 = data_from_user->command;
switch (command) { err = cx25821_vidioc_try_fmt_vid_out(file, priv, f);
case UPSTREAM_START_VIDEO:
cx25821_start_upstream_video_ch2(dev, data_from_user);
break;
case UPSTREAM_STOP_VIDEO: if (0 != err)
cx25821_stop_upstream_video_ch2(dev); return err;
break;
}
chan->fmt = cx25821_format_by_fourcc(f->fmt.pix.pixelformat);
chan->vidq.field = f->fmt.pix.field;
chan->width = f->fmt.pix.width;
chan->height = f->fmt.pix.height;
if (f->fmt.pix.pixelformat == V4L2_PIX_FMT_Y41P)
chan->pixel_formats = PIXEL_FRMT_411;
else
chan->pixel_formats = PIXEL_FRMT_422;
return 0; return 0;
} }
static long video_ioctl_upstream11(struct file *file, unsigned int cmd, static ssize_t video_write(struct file *file, const char __user *data, size_t count,
unsigned long arg) loff_t *ppos)
{ {
struct cx25821_fh *fh = file->private_data; struct cx25821_channel *chan = video_drvdata(file);
struct cx25821_dev *dev = fh->dev; struct cx25821_dev *dev = chan->dev;
int command = 0; struct v4l2_fh *fh = file->private_data;
struct upstream_user_struct *data_from_user; int err = 0;
data_from_user = (struct upstream_user_struct *)arg; if (mutex_lock_interruptible(&dev->lock))
return -ERESTARTSYS;
if (!data_from_user) { if (chan->streaming_fh && chan->streaming_fh != fh) {
pr_err("%s(): Upstream data is INVALID. Returning\n", __func__); err = -EBUSY;
return 0; goto unlock;
} }
if (!chan->streaming_fh) {
command = data_from_user->command; err = cx25821_vidupstream_init(chan, chan->pixel_formats);
if (err)
if (command != UPSTREAM_START_AUDIO && command != UPSTREAM_STOP_AUDIO) goto unlock;
return 0; chan->streaming_fh = fh;
dev->input_filename = data_from_user->input_filename;
dev->input_audiofilename = data_from_user->input_filename;
dev->vid_stdname = data_from_user->vid_stdname;
dev->pixel_format = data_from_user->pixel_format;
dev->channel_select = data_from_user->channel_select;
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:
cx25821_stop_upstream_audio(dev);
break;
} }
return 0; err = cx25821_write_frame(chan, data, count);
count -= err;
*ppos += err;
unlock:
mutex_unlock(&dev->lock);
return err;
} }
static long video_ioctl_set(struct file *file, unsigned int cmd, static int video_out_release(struct file *file)
unsigned long arg)
{ {
struct cx25821_fh *fh = file->private_data; struct cx25821_channel *chan = video_drvdata(file);
struct cx25821_dev *dev = fh->dev; struct cx25821_dev *dev = chan->dev;
struct downstream_user_struct *data_from_user; struct v4l2_fh *fh = file->private_data;
int command;
int width = 720;
int selected_channel = 0;
int pix_format = 0;
int i = 0;
int cif_enable = 0;
int cif_width = 0;
data_from_user = (struct downstream_user_struct *)arg;
if (!data_from_user) {
pr_err("%s(): User data is INVALID. Returning\n", __func__);
return 0;
}
command = data_from_user->command; mutex_lock(&dev->lock);
if (chan->streaming_fh == fh) {
if (command != SET_VIDEO_STD && command != SET_PIXEL_FORMAT cx25821_stop_upstream_video(chan);
&& command != ENABLE_CIF_RESOLUTION && command != REG_READ chan->streaming_fh = NULL;
&& command != REG_WRITE && command != MEDUSA_READ
&& command != MEDUSA_WRITE) {
return 0;
}
switch (command) {
case SET_VIDEO_STD:
if (!strcmp(data_from_user->vid_stdname, "PAL"))
dev->tvnorm = V4L2_STD_PAL_BG;
else
dev->tvnorm = V4L2_STD_NTSC_M;
medusa_set_videostandard(dev);
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)) {
selected_channel -= 4;
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;
if (cif_width != 320 && cif_width != 352)
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->channels[selected_channel].use_cif_resolution =
cif_enable;
dev->channels[selected_channel].cif_width = width;
} else {
for (i = 0; i < VID_CHANNEL_NUM; i++) {
dev->channels[i].use_cif_resolution =
cif_enable;
dev->channels[i].cif_width = 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:
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;
} }
mutex_unlock(&dev->lock);
return 0; return v4l2_fh_release(file);
} }
static long cx25821_video_ioctl(struct file *file, static const struct v4l2_ctrl_ops cx25821_ctrl_ops = {
unsigned int cmd, unsigned long arg) .s_ctrl = cx25821_s_ctrl,
{ };
int ret = 0;
struct cx25821_fh *fh = file->private_data;
/* check to see if it's the video upstream */
if (fh->channel_id == SRAM_CH09) {
ret = video_ioctl_upstream9(file, cmd, arg);
return ret;
} else if (fh->channel_id == SRAM_CH10) {
ret = video_ioctl_upstream10(file, cmd, arg);
return ret;
} else if (fh->channel_id == SRAM_CH11) {
ret = video_ioctl_upstream11(file, cmd, arg);
ret = video_ioctl_set(file, cmd, arg);
return ret;
}
return video_ioctl2(file, cmd, arg);
}
/* exported stuff */
static const struct v4l2_file_operations video_fops = { static const struct v4l2_file_operations video_fops = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
.open = video_open, .open = v4l2_fh_open,
.release = video_release, .release = video_release,
.read = video_read, .read = video_read,
.poll = video_poll, .poll = video_poll,
.mmap = cx25821_video_mmap, .mmap = cx25821_video_mmap,
.ioctl = cx25821_video_ioctl, .unlocked_ioctl = video_ioctl2,
}; };
static const struct v4l2_ioctl_ops video_ioctl_ops = { static const struct v4l2_ioctl_ops video_ioctl_ops = {
...@@ -1951,40 +963,170 @@ static const struct v4l2_ioctl_ops video_ioctl_ops = { ...@@ -1951,40 +963,170 @@ static const struct v4l2_ioctl_ops video_ioctl_ops = {
.vidioc_querybuf = cx25821_vidioc_querybuf, .vidioc_querybuf = cx25821_vidioc_querybuf,
.vidioc_qbuf = cx25821_vidioc_qbuf, .vidioc_qbuf = cx25821_vidioc_qbuf,
.vidioc_dqbuf = vidioc_dqbuf, .vidioc_dqbuf = vidioc_dqbuf,
#ifdef TUNER_FLAG .vidioc_g_std = cx25821_vidioc_g_std,
.vidioc_s_std = cx25821_vidioc_s_std, .vidioc_s_std = cx25821_vidioc_s_std,
.vidioc_querystd = cx25821_vidioc_querystd,
#endif
.vidioc_cropcap = cx25821_vidioc_cropcap,
.vidioc_s_crop = cx25821_vidioc_s_crop,
.vidioc_g_crop = cx25821_vidioc_g_crop,
.vidioc_enum_input = cx25821_vidioc_enum_input, .vidioc_enum_input = cx25821_vidioc_enum_input,
.vidioc_g_input = cx25821_vidioc_g_input, .vidioc_g_input = cx25821_vidioc_g_input,
.vidioc_s_input = cx25821_vidioc_s_input, .vidioc_s_input = cx25821_vidioc_s_input,
.vidioc_g_ctrl = cx25821_vidioc_g_ctrl,
.vidioc_s_ctrl = vidioc_s_ctrl,
.vidioc_queryctrl = cx25821_vidioc_queryctrl,
.vidioc_streamon = vidioc_streamon, .vidioc_streamon = vidioc_streamon,
.vidioc_streamoff = vidioc_streamoff, .vidioc_streamoff = vidioc_streamoff,
.vidioc_log_status = vidioc_log_status, .vidioc_log_status = vidioc_log_status,
.vidioc_g_priority = cx25821_vidioc_g_priority, .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
.vidioc_s_priority = cx25821_vidioc_s_priority, .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
#ifdef TUNER_FLAG
.vidioc_g_tuner = cx25821_vidioc_g_tuner,
.vidioc_s_tuner = cx25821_vidioc_s_tuner,
.vidioc_g_frequency = cx25821_vidioc_g_frequency,
.vidioc_s_frequency = cx25821_vidioc_s_frequency,
#endif
#ifdef CONFIG_VIDEO_ADV_DEBUG
.vidioc_g_register = cx25821_vidioc_g_register,
.vidioc_s_register = cx25821_vidioc_s_register,
#endif
}; };
struct video_device cx25821_videoioctl_template = { static const struct video_device cx25821_video_device = {
.name = "cx25821-videoioctl", .name = "cx25821-video",
.fops = &video_fops, .fops = &video_fops,
.release = video_device_release_empty,
.minor = -1,
.ioctl_ops = &video_ioctl_ops, .ioctl_ops = &video_ioctl_ops,
.tvnorms = CX25821_NORMS, .tvnorms = CX25821_NORMS,
.current_norm = V4L2_STD_NTSC_M,
}; };
static const struct v4l2_file_operations video_out_fops = {
.owner = THIS_MODULE,
.open = v4l2_fh_open,
.write = video_write,
.release = video_out_release,
.unlocked_ioctl = video_ioctl2,
};
static const struct v4l2_ioctl_ops video_out_ioctl_ops = {
.vidioc_querycap = cx25821_vidioc_querycap,
.vidioc_enum_fmt_vid_out = cx25821_vidioc_enum_fmt_vid_cap,
.vidioc_g_fmt_vid_out = cx25821_vidioc_g_fmt_vid_cap,
.vidioc_try_fmt_vid_out = cx25821_vidioc_try_fmt_vid_out,
.vidioc_s_fmt_vid_out = vidioc_s_fmt_vid_out,
.vidioc_g_std = cx25821_vidioc_g_std,
.vidioc_s_std = cx25821_vidioc_s_std,
.vidioc_enum_output = cx25821_vidioc_enum_output,
.vidioc_g_output = cx25821_vidioc_g_output,
.vidioc_s_output = cx25821_vidioc_s_output,
.vidioc_log_status = vidioc_log_status,
};
static const struct video_device cx25821_video_out_device = {
.name = "cx25821-video",
.fops = &video_out_fops,
.release = video_device_release_empty,
.minor = -1,
.ioctl_ops = &video_out_ioctl_ops,
.tvnorms = CX25821_NORMS,
};
void cx25821_video_unregister(struct cx25821_dev *dev, int chan_num)
{
cx_clear(PCI_INT_MSK, 1);
if (video_is_registered(&dev->channels[chan_num].vdev)) {
video_unregister_device(&dev->channels[chan_num].vdev);
v4l2_ctrl_handler_free(&dev->channels[chan_num].hdl);
btcx_riscmem_free(dev->pci,
&dev->channels[chan_num].dma_vidq.stopper);
}
}
int cx25821_video_register(struct cx25821_dev *dev)
{
int err;
int i;
/* initial device configuration */
dev->tvnorm = V4L2_STD_NTSC_M;
spin_lock_init(&dev->slock);
for (i = 0; i < MAX_VID_CHANNEL_NUM - 1; ++i) {
struct cx25821_channel *chan = &dev->channels[i];
struct video_device *vdev = &chan->vdev;
struct v4l2_ctrl_handler *hdl = &chan->hdl;
bool is_output = i > SRAM_CH08;
if (i == SRAM_CH08) /* audio channel */
continue;
if (!is_output) {
v4l2_ctrl_handler_init(hdl, 4);
v4l2_ctrl_new_std(hdl, &cx25821_ctrl_ops,
V4L2_CID_BRIGHTNESS, 0, 10000, 1, 6200);
v4l2_ctrl_new_std(hdl, &cx25821_ctrl_ops,
V4L2_CID_CONTRAST, 0, 10000, 1, 5000);
v4l2_ctrl_new_std(hdl, &cx25821_ctrl_ops,
V4L2_CID_SATURATION, 0, 10000, 1, 5000);
v4l2_ctrl_new_std(hdl, &cx25821_ctrl_ops,
V4L2_CID_HUE, 0, 10000, 1, 5000);
if (hdl->error) {
err = hdl->error;
goto fail_unreg;
}
err = v4l2_ctrl_handler_setup(hdl);
if (err)
goto fail_unreg;
} else {
chan->out = &dev->vid_out_data[i - SRAM_CH09];
chan->out->chan = chan;
}
cx25821_risc_stopper(dev->pci, &chan->dma_vidq.stopper,
chan->sram_channels->dma_ctl, 0x11, 0);
chan->sram_channels = &cx25821_sram_channels[i];
chan->width = 720;
if (dev->tvnorm & V4L2_STD_625_50)
chan->height = 576;
else
chan->height = 480;
if (chan->pixel_formats == PIXEL_FRMT_411)
chan->fmt = cx25821_format_by_fourcc(V4L2_PIX_FMT_Y41P);
else
chan->fmt = cx25821_format_by_fourcc(V4L2_PIX_FMT_YUYV);
cx_write(chan->sram_channels->int_stat, 0xffffffff);
INIT_LIST_HEAD(&chan->dma_vidq.active);
INIT_LIST_HEAD(&chan->dma_vidq.queued);
chan->timeout_data.dev = dev;
chan->timeout_data.channel = &cx25821_sram_channels[i];
chan->dma_vidq.timeout.function = cx25821_vid_timeout;
chan->dma_vidq.timeout.data = (unsigned long)&chan->timeout_data;
init_timer(&chan->dma_vidq.timeout);
if (!is_output)
videobuf_queue_sg_init(&chan->vidq, &cx25821_video_qops, &dev->pci->dev,
&dev->slock, V4L2_BUF_TYPE_VIDEO_CAPTURE,
V4L2_FIELD_INTERLACED, sizeof(struct cx25821_buffer),
chan, &dev->lock);
/* register v4l devices */
*vdev = is_output ? cx25821_video_out_device : cx25821_video_device;
vdev->v4l2_dev = &dev->v4l2_dev;
if (!is_output)
vdev->ctrl_handler = hdl;
else
vdev->vfl_dir = VFL_DIR_TX;
vdev->lock = &dev->lock;
set_bit(V4L2_FL_USE_FH_PRIO, &vdev->flags);
snprintf(vdev->name, sizeof(vdev->name), "%s #%d", dev->name, i);
video_set_drvdata(vdev, chan);
err = video_register_device(vdev, VFL_TYPE_GRABBER,
video_nr[dev->nr]);
if (err < 0)
goto fail_unreg;
}
/* set PCI interrupt */
cx_set(PCI_INT_MSK, 0xff);
return 0;
fail_unreg:
while (i >= 0)
cx25821_video_unregister(dev, i--);
return err;
}
drivers/media/pci/cx25821/cx25821-video.h
View file @ a5d0568e
...@@ -39,8 +39,7 @@ ...@@ -39,8 +39,7 @@
#include "cx25821.h" #include "cx25821.h"
#include <media/v4l2-common.h> #include <media/v4l2-common.h>
#include <media/v4l2-ioctl.h> #include <media/v4l2-ioctl.h>
#include <media/v4l2-event.h>
#define TUNER_FLAG
#define VIDEO_DEBUG 0 #define VIDEO_DEBUG 0
...@@ -50,137 +49,17 @@ do { \ ...@@ -50,137 +49,17 @@ do { \
printk(KERN_DEBUG "%s/0: " fmt, dev->name, ##arg); \ printk(KERN_DEBUG "%s/0: " fmt, dev->name, ##arg); \
} while (0) } while (0)
/* For IOCTL to identify running upstream */
#define UPSTREAM_START_VIDEO 700
#define UPSTREAM_STOP_VIDEO 701
#define UPSTREAM_START_AUDIO 702
#define UPSTREAM_STOP_AUDIO 703
#define UPSTREAM_DUMP_REGISTERS 702
#define SET_VIDEO_STD 800
#define SET_PIXEL_FORMAT 1000
#define ENABLE_CIF_RESOLUTION 1001
#define REG_READ 900
#define REG_WRITE 901
#define MEDUSA_READ 910
#define MEDUSA_WRITE 911
extern struct sram_channel *channel0;
extern struct sram_channel *channel1;
extern struct sram_channel *channel2;
extern struct sram_channel *channel3;
extern struct sram_channel *channel4;
extern struct sram_channel *channel5;
extern struct sram_channel *channel6;
extern struct sram_channel *channel7;
extern struct sram_channel *channel9;
extern struct sram_channel *channel10;
extern struct sram_channel *channel11;
extern struct video_device cx25821_videoioctl_template;
/* extern const u32 *ctrl_classes[]; */
extern unsigned int vid_limit;
#define FORMAT_FLAGS_PACKED 0x01 #define FORMAT_FLAGS_PACKED 0x01
extern struct cx25821_fmt formats[];
extern struct cx25821_fmt *cx25821_format_by_fourcc(unsigned int fourcc);
extern struct cx25821_data timeout_data[MAX_VID_CHANNEL_NUM];
extern void cx25821_video_wakeup(struct cx25821_dev *dev, extern void cx25821_video_wakeup(struct cx25821_dev *dev,
struct cx25821_dmaqueue *q, u32 count); struct cx25821_dmaqueue *q, u32 count);
#ifdef TUNER_FLAG
extern int cx25821_set_tvnorm(struct cx25821_dev *dev, v4l2_std_id norm);
#endif
extern int cx25821_res_get(struct cx25821_dev *dev, struct cx25821_fh *fh,
unsigned int bit);
extern int cx25821_res_check(struct cx25821_fh *fh, unsigned int bit);
extern int cx25821_res_locked(struct cx25821_fh *fh, unsigned int bit);
extern void cx25821_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_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); const 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_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);
extern void cx25821_video_unregister(struct cx25821_dev *dev, int chan_num); extern void cx25821_video_unregister(struct cx25821_dev *dev, int chan_num);
extern int cx25821_video_register(struct cx25821_dev *dev); extern int cx25821_video_register(struct cx25821_dev *dev);
extern int cx25821_get_format_size(void);
extern int cx25821_buffer_setup(struct videobuf_queue *q, unsigned int *count,
unsigned int *size);
extern int cx25821_buffer_prepare(struct videobuf_queue *q,
struct videobuf_buffer *vb,
enum v4l2_field field);
extern void cx25821_buffer_release(struct videobuf_queue *q,
struct videobuf_buffer *vb);
extern struct videobuf_queue *get_queue(struct cx25821_fh *fh);
extern int cx25821_get_resource(struct cx25821_fh *fh, int resource);
extern int cx25821_video_mmap(struct file *file, struct vm_area_struct *vma);
extern int cx25821_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
struct v4l2_format *f);
extern int cx25821_vidioc_querycap(struct file *file, void *priv,
struct v4l2_capability *cap);
extern int cx25821_vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
struct v4l2_fmtdesc *f);
extern int cx25821_vidioc_reqbufs(struct file *file, void *priv,
struct v4l2_requestbuffers *p);
extern int cx25821_vidioc_querybuf(struct file *file, void *priv,
struct v4l2_buffer *p);
extern int cx25821_vidioc_qbuf(struct file *file, void *priv,
struct v4l2_buffer *p);
extern int cx25821_vidioc_s_std(struct file *file, void *priv,
v4l2_std_id tvnorms);
extern int cx25821_enum_input(struct cx25821_dev *dev, struct v4l2_input *i);
extern int cx25821_vidioc_enum_input(struct file *file, void *priv,
struct v4l2_input *i);
extern int cx25821_vidioc_g_input(struct file *file, void *priv,
unsigned int *i);
extern int cx25821_vidioc_s_input(struct file *file, void *priv,
unsigned int i);
extern int cx25821_vidioc_g_ctrl(struct file *file, void *priv,
struct v4l2_control *ctl);
extern int cx25821_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
struct v4l2_format *f);
extern int cx25821_vidioc_g_frequency(struct file *file, void *priv,
struct v4l2_frequency *f);
extern int cx25821_set_freq(struct cx25821_dev *dev, const struct v4l2_frequency *f);
extern int cx25821_vidioc_s_frequency(struct file *file, void *priv,
const struct v4l2_frequency *f);
extern int cx25821_vidioc_g_register(struct file *file, void *fh,
struct v4l2_dbg_register *reg);
extern int cx25821_vidioc_s_register(struct file *file, void *fh,
const struct v4l2_dbg_register *reg);
extern int cx25821_vidioc_g_tuner(struct file *file, void *priv,
struct v4l2_tuner *t);
extern int cx25821_vidioc_s_tuner(struct file *file, void *priv,
const struct v4l2_tuner *t);
extern int cx25821_is_valid_width(u32 width, v4l2_std_id tvnorm);
extern int cx25821_is_valid_height(u32 height, v4l2_std_id tvnorm);
extern int cx25821_vidioc_g_priority(struct file *file, void *f,
enum v4l2_priority *p);
extern int cx25821_vidioc_s_priority(struct file *file, void *f,
enum v4l2_priority prio);
extern int cx25821_vidioc_queryctrl(struct file *file, void *priv,
struct v4l2_queryctrl *qctrl);
extern int cx25821_set_control(struct cx25821_dev *dev,
struct v4l2_control *ctrl, int chan_num);
extern int cx25821_vidioc_cropcap(struct file *file, void *fh,
struct v4l2_cropcap *cropcap);
extern int cx25821_vidioc_s_crop(struct file *file, void *priv,
const struct v4l2_crop *crop);
extern int cx25821_vidioc_g_crop(struct file *file, void *priv,
struct v4l2_crop *crop);
extern int cx25821_vidioc_querystd(struct file *file, void *priv,
v4l2_std_id *norm);
#endif #endif
drivers/media/pci/cx25821/cx25821.h
View file @ a5d0568e
...@@ -33,17 +33,14 @@ ...@@ -33,17 +33,14 @@
#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/v4l2-ctrls.h>
#include <media/tveeprom.h>
#include <media/videobuf-dma-sg.h> #include <media/videobuf-dma-sg.h>
#include <media/videobuf-dvb.h>
#include "btcx-risc.h" #include "btcx-risc.h"
#include "cx25821-reg.h" #include "cx25821-reg.h"
#include "cx25821-medusa-reg.h" #include "cx25821-medusa-reg.h"
#include "cx25821-sram.h" #include "cx25821-sram.h"
#include "cx25821-audio.h" #include "cx25821-audio.h"
#include "media/cx2341x.h"
#include <linux/version.h> #include <linux/version.h>
#include <linux/mutex.h> #include <linux/mutex.h>
...@@ -55,8 +52,6 @@ ...@@ -55,8 +52,6 @@
#define CX25821_MAXBOARDS 2 #define CX25821_MAXBOARDS 2
#define TRUE 1
#define FALSE 0
#define LINE_SIZE_D1 1440 #define LINE_SIZE_D1 1440
/* Number of decoders and encoders */ /* Number of decoders and encoders */
...@@ -67,7 +62,6 @@ ...@@ -67,7 +62,6 @@
/* Max number of inputs by card */ /* Max number of inputs by card */
#define MAX_CX25821_INPUT 8 #define MAX_CX25821_INPUT 8
#define INPUT(nr) (&cx25821_boards[dev->board].input[nr])
#define RESOURCE_VIDEO0 1 #define RESOURCE_VIDEO0 1
#define RESOURCE_VIDEO1 2 #define RESOURCE_VIDEO1 2
#define RESOURCE_VIDEO2 4 #define RESOURCE_VIDEO2 4
...@@ -80,7 +74,6 @@ ...@@ -80,7 +74,6 @@
#define RESOURCE_VIDEO9 512 #define RESOURCE_VIDEO9 512
#define RESOURCE_VIDEO10 1024 #define RESOURCE_VIDEO10 1024
#define RESOURCE_VIDEO11 2048 #define RESOURCE_VIDEO11 2048
#define RESOURCE_VIDEO_IOCTL 4096
#define BUFFER_TIMEOUT (HZ) /* 0.5 seconds */ #define BUFFER_TIMEOUT (HZ) /* 0.5 seconds */
...@@ -97,7 +90,6 @@ ...@@ -97,7 +90,6 @@
#define CX25821_BOARD_CONEXANT_ATHENA10 1 #define CX25821_BOARD_CONEXANT_ATHENA10 1
#define MAX_VID_CHANNEL_NUM 12 #define MAX_VID_CHANNEL_NUM 12
#define VID_CHANNEL_NUM 8 #define VID_CHANNEL_NUM 8
#define CX25821_NR_INPUT 2
struct cx25821_fmt { struct cx25821_fmt {
char *name; char *name;
...@@ -107,14 +99,6 @@ struct cx25821_fmt { ...@@ -107,14 +99,6 @@ struct cx25821_fmt {
u32 cxformat; u32 cxformat;
}; };
struct cx25821_ctrl {
struct v4l2_queryctrl v;
u32 off;
u32 reg;
u32 mask;
u32 shift;
};
struct cx25821_tvnorm { struct cx25821_tvnorm {
char *name; char *name;
v4l2_std_id id; v4l2_std_id id;
...@@ -122,40 +106,6 @@ struct cx25821_tvnorm { ...@@ -122,40 +106,6 @@ struct cx25821_tvnorm {
u32 cxoformat; u32 cxoformat;
}; };
struct cx25821_fh {
struct cx25821_dev *dev;
enum v4l2_buf_type type;
int radio;
u32 resources;
enum v4l2_priority prio;
/* video overlay */
struct v4l2_window win;
struct v4l2_clip *clips;
unsigned int nclips;
/* video capture */
struct cx25821_fmt *fmt;
unsigned int width, height;
int channel_id;
/* vbi capture */
struct videobuf_queue vidq;
struct videobuf_queue vbiq;
/* H264 Encoder specifics ONLY */
struct videobuf_queue mpegq;
atomic_t v4l_reading;
};
enum cx25821_itype {
CX25821_VMUX_COMPOSITE = 1,
CX25821_VMUX_SVIDEO,
CX25821_VMUX_DEBUG,
CX25821_RADIO,
};
enum cx25821_src_sel_type { enum cx25821_src_sel_type {
CX25821_SRC_SEL_EXT_656_VIDEO = 0, CX25821_SRC_SEL_EXT_656_VIDEO = 0,
CX25821_SRC_SEL_PARALLEL_MPEG_VIDEO CX25821_SRC_SEL_PARALLEL_MPEG_VIDEO
...@@ -169,16 +119,10 @@ struct cx25821_buffer { ...@@ -169,16 +119,10 @@ struct cx25821_buffer {
/* cx25821 specific */ /* cx25821 specific */
unsigned int bpl; unsigned int bpl;
struct btcx_riscmem risc; struct btcx_riscmem risc;
struct cx25821_fmt *fmt; const struct cx25821_fmt *fmt;
u32 count; u32 count;
}; };
struct cx25821_input {
enum cx25821_itype type;
unsigned int vmux;
u32 gpio0, gpio1, gpio2, gpio3;
};
enum port { enum port {
CX25821_UNDEFINED = 0, CX25821_UNDEFINED = 0,
CX25821_RAW, CX25821_RAW,
...@@ -190,19 +134,8 @@ struct cx25821_board { ...@@ -190,19 +134,8 @@ struct cx25821_board {
enum port porta; enum port porta;
enum port portb; enum port portb;
enum port portc; enum port portc;
unsigned int tuner_type;
unsigned int radio_type;
unsigned char tuner_addr;
unsigned char radio_addr;
u32 clk_freq; u32 clk_freq;
struct cx25821_input input[CX25821_NR_INPUT];
};
struct cx25821_subid {
u16 subvendor;
u16 subdevice;
u32 card;
}; };
struct cx25821_i2c { struct cx25821_i2c {
...@@ -234,34 +167,70 @@ struct cx25821_dmaqueue { ...@@ -234,34 +167,70 @@ struct cx25821_dmaqueue {
struct cx25821_data { struct cx25821_data {
struct cx25821_dev *dev; struct cx25821_dev *dev;
struct sram_channel *channel; const struct sram_channel *channel;
};
struct cx25821_dev;
struct cx25821_channel;
struct cx25821_video_out_data {
struct cx25821_channel *chan;
int _line_size;
int _prog_cnt;
int _pixel_format;
int _is_first_frame;
int _is_running;
int _file_status;
int _lines_count;
int _frame_count;
unsigned int _risc_size;
__le32 *_dma_virt_start_addr;
__le32 *_dma_virt_addr;
dma_addr_t _dma_phys_addr;
dma_addr_t _dma_phys_start_addr;
unsigned int _data_buf_size;
__le32 *_data_buf_virt_addr;
dma_addr_t _data_buf_phys_addr;
u32 upstream_riscbuf_size;
u32 upstream_databuf_size;
int is_60hz;
int _frame_index;
int cur_frame_index;
int curpos;
wait_queue_head_t waitq;
}; };
struct cx25821_channel { struct cx25821_channel {
struct v4l2_prio_state prio; unsigned id;
struct cx25821_dev *dev;
struct v4l2_fh *streaming_fh;
int ctl_bright; struct v4l2_ctrl_handler hdl;
int ctl_contrast;
int ctl_hue;
int ctl_saturation;
struct cx25821_data timeout_data; struct cx25821_data timeout_data;
struct video_device *video_dev; struct video_device vdev;
struct cx25821_dmaqueue vidq; struct cx25821_dmaqueue dma_vidq;
struct videobuf_queue vidq;
struct sram_channel *sram_channels;
struct mutex lock; const struct sram_channel *sram_channels;
int resources;
const struct cx25821_fmt *fmt;
unsigned int width, height;
int pixel_formats; int pixel_formats;
int use_cif_resolution; int use_cif_resolution;
int cif_width; int cif_width;
/* video output data for the video output channel */
struct cx25821_video_out_data *out;
}; };
struct snd_card;
struct cx25821_dev { struct cx25821_dev {
struct list_head devlist;
atomic_t refcount;
struct v4l2_device v4l2_dev; struct v4l2_device v4l2_dev;
/* pci stuff */ /* pci stuff */
...@@ -273,6 +242,8 @@ struct cx25821_dev { ...@@ -273,6 +242,8 @@ struct cx25821_dev {
u8 __iomem *bmmio; u8 __iomem *bmmio;
int pci_irqmask; int pci_irqmask;
int hwrevision; int hwrevision;
/* used by cx25821-alsa */
struct snd_card *card;
u32 clk_freq; u32 clk_freq;
...@@ -289,17 +260,8 @@ struct cx25821_dev { ...@@ -289,17 +260,8 @@ struct cx25821_dev {
char name[32]; char name[32];
/* Analog video */ /* Analog video */
u32 resources;
unsigned int input; unsigned int input;
u32 tvaudio;
v4l2_std_id tvnorm; v4l2_std_id tvnorm;
unsigned int tuner_type;
unsigned char tuner_addr;
unsigned int radio_type;
unsigned char radio_addr;
unsigned int has_radio;
unsigned int videc_type;
unsigned char videc_addr;
unsigned short _max_num_decoders; unsigned short _max_num_decoders;
/* Analog Audio Upstream */ /* Analog Audio Upstream */
...@@ -323,132 +285,26 @@ struct cx25821_dev { ...@@ -323,132 +285,26 @@ struct cx25821_dev {
__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 */
u32 freq;
struct video_device *vbi_dev;
struct video_device *radio_dev;
struct video_device *ioctl_dev;
spinlock_t slock;
/* Video Upstream */
int _line_size;
int _prog_cnt;
int _pixel_format;
int _is_first_frame;
int _is_running;
int _file_status;
int _lines_count;
int _frame_count;
int _channel_upstream_select;
unsigned int _risc_size;
__le32 *_dma_virt_start_addr;
__le32 *_dma_virt_addr;
dma_addr_t _dma_phys_addr;
dma_addr_t _dma_phys_start_addr;
unsigned int _data_buf_size;
__le32 *_data_buf_virt_addr;
dma_addr_t _data_buf_phys_addr;
char *_filename;
char *_defaultname;
int _line_size_ch2;
int _prog_cnt_ch2;
int _pixel_format_ch2;
int _is_first_frame_ch2;
int _is_running_ch2;
int _file_status_ch2;
int _lines_count_ch2;
int _frame_count_ch2;
int _channel2_upstream_select;
unsigned int _risc_size_ch2;
__le32 *_dma_virt_start_addr_ch2;
__le32 *_dma_virt_addr_ch2;
dma_addr_t _dma_phys_addr_ch2;
dma_addr_t _dma_phys_start_addr_ch2;
unsigned int _data_buf_size_ch2;
__le32 *_data_buf_virt_addr_ch2;
dma_addr_t _data_buf_phys_addr_ch2;
char *_filename_ch2;
char *_defaultname_ch2;
/* MPEG Encoder ONLY settings */
u32 cx23417_mailbox;
struct cx2341x_mpeg_params mpeg_params;
struct video_device *v4l_device;
atomic_t v4l_reader_count;
struct cx25821_tvnorm encodernorm;
u32 upstream_riscbuf_size;
u32 upstream_databuf_size;
u32 upstream_riscbuf_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 _frame_index;
int _audioframe_index; int _audioframe_index;
struct workqueue_struct *_irq_queues;
struct work_struct _irq_work_entry;
struct workqueue_struct *_irq_queues_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_ch2;
int _frame_index_ch2;
int _isNTSC_ch2;
char *vid_stdname_ch2;
int pixel_format_ch2;
int channel_select_ch2;
int command_ch2;
char *input_audiofilename; char *input_audiofilename;
char *vid_stdname;
int pixel_format;
int channel_select;
int command;
int channel_opened;
};
struct upstream_user_struct { /* V4l */
char *input_filename; spinlock_t slock;
char *vid_stdname;
int pixel_format;
int channel_select;
int command;
};
struct downstream_user_struct { /* Video Upstream */
char *vid_stdname; struct cx25821_video_out_data vid_out_data[2];
int pixel_format;
int cif_resolution_enable;
int cif_width;
int decoder_select;
int command;
int reg_address;
int reg_data;
}; };
extern struct upstream_user_struct *up_data;
static inline struct cx25821_dev *get_cx25821(struct v4l2_device *v4l2_dev) static inline struct cx25821_dev *get_cx25821(struct v4l2_device *v4l2_dev)
{ {
return container_of(v4l2_dev, struct cx25821_dev, v4l2_dev); return container_of(v4l2_dev, struct cx25821_dev, v4l2_dev);
} }
#define cx25821_call_all(dev, o, f, args...) \
v4l2_device_call_all(&dev->v4l2_dev, 0, o, f, ##args)
extern struct list_head cx25821_devlist;
extern struct mutex cx25821_devlist_mutex;
extern struct cx25821_board cx25821_boards[]; extern struct cx25821_board cx25821_boards[];
extern struct cx25821_subid cx25821_subids[];
#define SRAM_CH00 0 /* Video A */ #define SRAM_CH00 0 /* Video A */
#define SRAM_CH01 1 /* Video B */ #define SRAM_CH01 1 /* Video B */
...@@ -467,7 +323,6 @@ extern struct cx25821_subid cx25821_subids[]; ...@@ -467,7 +323,6 @@ extern struct cx25821_subid cx25821_subids[];
#define VID_UPSTREAM_SRAM_CHANNEL_I SRAM_CH09 #define VID_UPSTREAM_SRAM_CHANNEL_I SRAM_CH09
#define VID_UPSTREAM_SRAM_CHANNEL_J SRAM_CH10 #define VID_UPSTREAM_SRAM_CHANNEL_J SRAM_CH10
#define AUDIO_UPSTREAM_SRAM_CHANNEL_B SRAM_CH11 #define AUDIO_UPSTREAM_SRAM_CHANNEL_B SRAM_CH11
#define VIDEO_IOCTL_CH 11
struct sram_channel { struct sram_channel {
char *name; char *name;
...@@ -503,10 +358,8 @@ struct sram_channel { ...@@ -503,10 +358,8 @@ struct sram_channel {
u32 jumponly; u32 jumponly;
u32 irq_bit; u32 irq_bit;
}; };
extern struct sram_channel cx25821_sram_channels[];
#define STATUS_SUCCESS 0 extern const struct sram_channel cx25821_sram_channels[];
#define STATUS_UNSUCCESSFUL -1
#define cx_read(reg) readl(dev->lmmio + ((reg)>>2)) #define cx_read(reg) readl(dev->lmmio + ((reg)>>2))
#define cx_write(reg, value) writel((value), dev->lmmio + ((reg)>>2)) #define cx_write(reg, value) writel((value), dev->lmmio + ((reg)>>2))
...@@ -529,8 +382,6 @@ extern struct sram_channel cx25821_sram_channels[]; ...@@ -529,8 +382,6 @@ extern struct sram_channel cx25821_sram_channels[];
pr_info("(%d): " fmt, dev->board, ##args) pr_info("(%d): " fmt, dev->board, ##args)
extern int cx25821_i2c_register(struct cx25821_i2c *bus); extern int cx25821_i2c_register(struct cx25821_i2c *bus);
extern void cx25821_card_setup(struct cx25821_dev *dev);
extern int cx25821_ir_init(struct cx25821_dev *dev);
extern int cx25821_i2c_read(struct cx25821_i2c *bus, u16 reg_addr, int *value); extern int cx25821_i2c_read(struct cx25821_i2c *bus, u16 reg_addr, int *value);
extern int cx25821_i2c_write(struct cx25821_i2c *bus, u16 reg_addr, int value); 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);
...@@ -551,7 +402,7 @@ extern int medusa_set_saturation(struct cx25821_dev *dev, int saturation, ...@@ -551,7 +402,7 @@ extern int medusa_set_saturation(struct cx25821_dev *dev, int saturation,
int decoder); int decoder);
extern int cx25821_sram_channel_setup(struct cx25821_dev *dev, extern int cx25821_sram_channel_setup(struct cx25821_dev *dev,
struct sram_channel *ch, unsigned int bpl, const struct sram_channel *ch, unsigned int bpl,
u32 risc); 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,
...@@ -570,46 +421,31 @@ extern void cx25821_free_buffer(struct videobuf_queue *q, ...@@ -570,46 +421,31 @@ extern void cx25821_free_buffer(struct videobuf_queue *q,
extern int cx25821_risc_stopper(struct pci_dev *pci, struct btcx_riscmem *risc, extern int cx25821_risc_stopper(struct pci_dev *pci, struct btcx_riscmem *risc,
u32 reg, u32 mask, u32 value); u32 reg, u32 mask, u32 value);
extern void cx25821_sram_channel_dump(struct cx25821_dev *dev, extern void cx25821_sram_channel_dump(struct cx25821_dev *dev,
struct sram_channel *ch); const struct sram_channel *ch);
extern void cx25821_sram_channel_dump_audio(struct cx25821_dev *dev, extern void cx25821_sram_channel_dump_audio(struct cx25821_dev *dev,
struct sram_channel *ch); const struct sram_channel *ch);
extern struct cx25821_dev *cx25821_dev_get(struct pci_dev *pci); extern struct cx25821_dev *cx25821_dev_get(struct pci_dev *pci);
extern void cx25821_print_irqbits(char *name, char *tag, char **strings, extern void cx25821_print_irqbits(char *name, char *tag, char **strings,
int len, u32 bits, u32 mask); 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, const struct sram_channel *ch,
unsigned int bpl, u32 risc); unsigned int bpl, u32 risc);
extern int cx25821_vidupstream_init_ch1(struct cx25821_dev *dev, extern int cx25821_vidupstream_init(struct cx25821_channel *chan, int pixel_format);
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, extern int cx25821_audio_upstream_init(struct cx25821_dev *dev,
int channel_select); int channel_select);
extern void cx25821_free_mem_upstream_ch1(struct cx25821_dev *dev); extern int cx25821_write_frame(struct cx25821_channel *chan,
extern void cx25821_free_mem_upstream_ch2(struct cx25821_dev *dev); const char __user *data, size_t count);
extern void cx25821_free_mem_upstream(struct cx25821_channel *chan);
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, extern void cx25821_stop_upstream_video(struct cx25821_channel *chan);
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_stop_upstream_video_ch1(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, extern int cx25821_sram_channel_setup_upstream(struct cx25821_dev *dev,
struct sram_channel *ch, const struct sram_channel *ch,
unsigned int bpl, u32 risc); unsigned int bpl, u32 risc);
extern void cx25821_set_pixel_format(struct cx25821_dev *dev, int channel, extern void cx25821_set_pixel_format(struct cx25821_dev *dev, int channel,
u32 format); u32 format);
extern void cx25821_videoioctl_unregister(struct cx25821_dev *dev);
extern struct video_device *cx25821_vdev_init(struct cx25821_dev *dev,
struct pci_dev *pci,
struct video_device *template,
char *type);
#endif #endif
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7