Skip to content

L
linux
Commit 9fdd7976 authored by Oliver Endriss's avatar Oliver Endriss Committed by Mauro Carvalho Chehab
Browse files
Options

V4L/DVB: ngene: Code cleanup 

Remove/comment-out unused code, make some functions/declarations static.
Signed-off-by: default avatarOliver Endriss <o.endriss@gmx.de>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@redhat.com>
parent cf1b12f2
Hide whitespace changes
Inline Side-by-side
Showing with 10 additions and 3365 deletions
drivers/media/dvb/ngene/ngene-core.c
View file @ 9fdd7976
......@@ -48,17 +48,10 @@
#include "stv090x.h"
#include "lnbh24.h"
#ifdef NGENE_COMMAND_API
#include "ngene-ioctls.h"
#endif
static int one_adapter = 1;
module_param(one_adapter, int, 0444);
MODULE_PARM_DESC(one_adapter, "Use only one adapter.");
static int copy_eeprom;
module_param(copy_eeprom, int, 0444);
MODULE_PARM_DESC(copy_eeprom, "Copy eeprom.");
static int debug;
module_param(debug, int, 0444);
......@@ -342,19 +335,8 @@ static int ngene_command(struct ngene *dev, struct ngene_command *com)
return result;
}
int ngene_command_nop(struct ngene *dev)
{
struct ngene_command com;
com.cmd.hdr.Opcode = CMD_NOP;
com.cmd.hdr.Length = 0;
com.in_len = 0;
com.out_len = 0;
return ngene_command(dev, &com);
}
int ngene_command_i2c_read(struct ngene *dev, u8 adr,
static int ngene_command_i2c_read(struct ngene *dev, u8 adr,
u8 *out, u8 outlen, u8 *in, u8 inlen, int flag)
{
struct ngene_command com;
......@@ -381,7 +363,8 @@ int ngene_command_i2c_read(struct ngene *dev, u8 adr,
return 0;
}
int ngene_command_i2c_write(struct ngene *dev, u8 adr, u8 *out, u8 outlen)
static int ngene_command_i2c_write(struct ngene *dev, u8 adr,
u8 *out, u8 outlen)
{
struct ngene_command com;
......@@ -435,81 +418,6 @@ static int ngene_command_load_firmware(struct ngene *dev,
return ngene_command(dev, &com);
}
int ngene_command_imem_read(struct ngene *dev, u8 adr, u8 *data, int type)
{
struct ngene_command com;
com.cmd.hdr.Opcode = type ? CMD_SFR_READ : CMD_IRAM_READ;
com.cmd.hdr.Length = 1;
com.cmd.SfrIramRead.address = adr;
com.in_len = 1;
com.out_len = 2;
if (ngene_command(dev, &com) < 0)
return -EIO;
*data = com.cmd.raw8[1];
return 0;
}
int ngene_command_imem_write(struct ngene *dev, u8 adr, u8 data, int type)
{
struct ngene_command com;
com.cmd.hdr.Opcode = type ? CMD_SFR_WRITE : CMD_IRAM_WRITE;
com.cmd.hdr.Length = 2;
com.cmd.SfrIramWrite.address = adr;
com.cmd.SfrIramWrite.data = data;
com.in_len = 2;
com.out_len = 1;
if (ngene_command(dev, &com) < 0)
return -EIO;
return 0;
}
static int ngene_command_config_uart(struct ngene *dev, u8 config,
tx_cb_t *tx_cb, rx_cb_t *rx_cb)
{
struct ngene_command com;
com.cmd.hdr.Opcode = CMD_CONFIGURE_UART;
com.cmd.hdr.Length = sizeof(struct FW_CONFIGURE_UART) - 2;
com.cmd.ConfigureUart.UartControl = config;
com.in_len = sizeof(struct FW_CONFIGURE_UART);
com.out_len = 0;
if (ngene_command(dev, &com) < 0)
return -EIO;
dev->TxEventNotify = tx_cb;
dev->RxEventNotify = rx_cb;
dprintk(KERN_DEBUG DEVICE_NAME ": Set UART config %02x.\n", config);
return 0;
}
static void tx_cb(struct ngene *dev, u32 ts)
{
dev->tx_busy = 0;
wake_up_interruptible(&dev->tx_wq);
}
static void rx_cb(struct ngene *dev, u32 ts, u8 c)
{
int rp = dev->uart_rp;
int nwp, wp = dev->uart_wp;
/* dprintk(KERN_DEBUG DEVICE_NAME ": %c\n", c); */
nwp = (wp + 1) % (UART_RBUF_LEN);
if (nwp == rp)
return;
dev->uart_rbuf[wp] = c;
dev->uart_wp = nwp;
wake_up_interruptible(&dev->rx_wq);
}
static int ngene_command_config_buf(struct ngene *dev, u8 config)
{
......@@ -555,16 +463,6 @@ static int ngene_command_gpio_set(struct ngene *dev, u8 select, u8 level)
return ngene_command(dev, &com);
}
/* The reset is only wired to GPIO4 on MicRacer Revision 1.10 !
Also better set bootdelay to 1 in nvram or less. */
static void ngene_reset_decypher(struct ngene *dev)
{
printk(KERN_INFO DEVICE_NAME ": Resetting Decypher.\n");
ngene_command_gpio_set(dev, 4, 0);
msleep(1);
ngene_command_gpio_set(dev, 4, 1);
msleep(2000);
}
/*
02000640 is sample on rising edge.
......@@ -693,8 +591,8 @@ static void clear_buffers(struct ngene_channel *chan)
}
}
int ngene_command_stream_control(struct ngene *dev, u8 stream, u8 control,
u8 mode, u8 flags)
static int ngene_command_stream_control(struct ngene *dev, u8 stream,
u8 control, u8 mode, u8 flags)
{
struct ngene_channel *chan = &dev->channel[stream];
struct ngene_command com;
......@@ -847,23 +745,6 @@ int ngene_command_stream_control(struct ngene *dev, u8 stream, u8 control,
return 0;
}
int ngene_stream_control(struct ngene *dev, u8 stream, u8 control, u8 mode,
u16 lines, u16 bpl, u16 vblines, u16 vbibpl)
{
if (!(mode & SMODE_TRANSPORT_STREAM))
return -EINVAL;
if (lines * bpl > MAX_VIDEO_BUFFER_SIZE)
return -EINVAL;
if ((mode & SMODE_TRANSPORT_STREAM) && (((bpl * lines) & 0xff) != 0))
return -EINVAL;
if ((mode & SMODE_VIDEO_CAPTURE) && (bpl & 7) != 0)
return -EINVAL;
return ngene_command_stream_control(dev, stream, control, mode, 0);
}
/****************************************************************************/
/* I2C **********************************************************************/
......@@ -924,13 +805,12 @@ static int ngene_i2c_master_xfer(struct i2c_adapter *adapter,
}
static u32 ngene_i2c_functionality(struct i2c_adapter *adap)
{
return I2C_FUNC_SMBUS_EMUL;
}
struct i2c_algorithm ngene_i2c_algo = {
static struct i2c_algorithm ngene_i2c_algo = {
.master_xfer = ngene_i2c_master_xfer,
.functionality = ngene_i2c_functionality,
};
......@@ -956,476 +836,6 @@ static int ngene_i2c_init(struct ngene *dev, int dev_nr)
return i2c_add_adapter(adap);
}
int i2c_write(struct i2c_adapter *adapter, u8 adr, u8 data)
{
u8 m[1] = {data};
struct i2c_msg msg = {.addr = adr, .flags = 0, .buf = m, .len = 1};
if (i2c_transfer(adapter, &msg, 1) != 1) {
printk(KERN_ERR DEVICE_NAME
": Failed to write to I2C adr %02x!\n", adr);
return -1;
}
return 0;
}
static int i2c_write_read(struct i2c_adapter *adapter,
u8 adr, u8 *w, u8 wlen, u8 *r, u8 rlen)
{
struct i2c_msg msgs[2] = {{.addr = adr, .flags = 0,
.buf = w, .len = wlen},
{.addr = adr, .flags = I2C_M_RD,
.buf = r, .len = rlen} };
if (i2c_transfer(adapter, msgs, 2) != 2) {
printk(KERN_ERR DEVICE_NAME ": error in i2c_write_read\n");
return -1;
}
return 0;
}
static int test_dec_i2c(struct i2c_adapter *adapter, int reg)
{
u8 data[256] = { reg, 0x00, 0x93, 0x78, 0x43, 0x45 };
u8 data2[256];
int i;
memset(data2, 0, 256);
i2c_write_read(adapter, 0x66, data, 2, data2, 4);
for (i = 0; i < 4; i++)
printk("%02x ", data2[i]);
printk("\n");
return 0;
}
/****************************************************************************/
/* EEPROM TAGS **************************************************************/
/****************************************************************************/
#define MICNG_EE_START 0x0100
#define MICNG_EE_END 0x0FF0
#define MICNG_EETAG_END0 0x0000
#define MICNG_EETAG_END1 0xFFFF
/* 0x0001 - 0x000F reserved for housekeeping */
/* 0xFFFF - 0xFFFE reserved for housekeeping */
/* Micronas assigned tags
EEProm tags for hardware support */
#define MICNG_EETAG_DRXD1_OSCDEVIATION 0x1000 /* 2 Bytes data */
#define MICNG_EETAG_DRXD2_OSCDEVIATION 0x1001 /* 2 Bytes data */
#define MICNG_EETAG_MT2060_1_1STIF 0x1100 /* 2 Bytes data */
#define MICNG_EETAG_MT2060_2_1STIF 0x1101 /* 2 Bytes data */
/* Tag range for OEMs */
#define MICNG_EETAG_OEM_FIRST 0xC000
#define MICNG_EETAG_OEM_LAST 0xFFEF
static int i2c_write_eeprom(struct i2c_adapter *adapter,
u8 adr, u16 reg, u8 data)
{
u8 m[3] = {(reg >> 8), (reg & 0xff), data};
struct i2c_msg msg = {.addr = adr, .flags = 0, .buf = m,
.len = sizeof(m)};
if (i2c_transfer(adapter, &msg, 1) != 1) {
dprintk(KERN_ERR DEVICE_NAME ": Error writing EEPROM!\n");
return -EIO;
}
return 0;
}
static int i2c_read_eeprom(struct i2c_adapter *adapter,
u8 adr, u16 reg, u8 *data, int len)
{
u8 msg[2] = {(reg >> 8), (reg & 0xff)};
struct i2c_msg msgs[2] = {{.addr = adr, .flags = 0,
.buf = msg, .len = 2 },
{.addr = adr, .flags = I2C_M_RD,
.buf = data, .len = len} };
if (i2c_transfer(adapter, msgs, 2) != 2) {
dprintk(KERN_ERR DEVICE_NAME ": Error reading EEPROM\n");
return -EIO;
}
return 0;
}
static int i2c_dump_eeprom(struct i2c_adapter *adapter, u8 adr)
{
u8 buf[64];
int i;
if (i2c_read_eeprom(adapter, adr, 0x0000, buf, sizeof(buf))) {
printk(KERN_ERR DEVICE_NAME ": No EEPROM?\n");
return -1;
}
for (i = 0; i < sizeof(buf); i++) {
if (!(i & 15))
printk("\n");
printk("%02x ", buf[i]);
}
printk("\n");
return 0;
}
static int i2c_copy_eeprom(struct i2c_adapter *adapter, u8 adr, u8 adr2)
{
u8 buf[64];
int i;
if (i2c_read_eeprom(adapter, adr, 0x0000, buf, sizeof(buf))) {
printk(KERN_ERR DEVICE_NAME ": No EEPROM?\n");
return -1;
}
buf[36] = 0xc3;
buf[39] = 0xab;
for (i = 0; i < sizeof(buf); i++) {
i2c_write_eeprom(adapter, adr2, i, buf[i]);
msleep(10);
}
return 0;
}
/****************************************************************************/
/* COMMAND API interface ****************************************************/
/****************************************************************************/
#ifdef NGENE_COMMAND_API
static int command_do_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, void *parg)
{
struct dvb_device *dvbdev = file->private_data;
struct ngene_channel *chan = dvbdev->priv;
struct ngene *dev = chan->dev;
int err = 0;
switch (cmd) {
case IOCTL_MIC_NO_OP:
err = ngene_command_nop(dev);
break;
case IOCTL_MIC_DOWNLOAD_FIRMWARE:
break;
case IOCTL_MIC_I2C_READ:
{
MIC_I2C_READ *msg = parg;
err = ngene_command_i2c_read(dev, msg->I2CAddress >> 1,
msg->OutData, msg->OutLength,
msg->OutData, msg->InLength, 1);
break;
}
case IOCTL_MIC_I2C_WRITE:
{
MIC_I2C_WRITE *msg = parg;
err = ngene_command_i2c_write(dev, msg->I2CAddress >> 1,
msg->Data, msg->Length);
break;
}
case IOCTL_MIC_TEST_GETMEM:
{
MIC_MEM *m = parg;
if (m->Length > 64 * 1024 || m->Start + m->Length > 64 * 1024)
return -EINVAL;
/* WARNING, only use this on x86,
other archs may not swallow this */
err = copy_to_user(m->Data, dev->iomem + m->Start, m->Length);
break;
}
case IOCTL_MIC_TEST_SETMEM:
{
MIC_MEM *m = parg;
if (m->Length > 64 * 1024 || m->Start + m->Length > 64 * 1024)
return -EINVAL;
err = copy_from_user(dev->iomem + m->Start, m->Data, m->Length);
break;
}
case IOCTL_MIC_SFR_READ:
{
MIC_IMEM *m = parg;
err = ngene_command_imem_read(dev, m->Address, &m->Data, 1);
break;
}
case IOCTL_MIC_SFR_WRITE:
{
MIC_IMEM *m = parg;
err = ngene_command_imem_write(dev, m->Address, m->Data, 1);
break;
}
case IOCTL_MIC_IRAM_READ:
{
MIC_IMEM *m = parg;
err = ngene_command_imem_read(dev, m->Address, &m->Data, 0);
break;
}
case IOCTL_MIC_IRAM_WRITE:
{
MIC_IMEM *m = parg;
err = ngene_command_imem_write(dev, m->Address, m->Data, 0);
break;
}
case IOCTL_MIC_STREAM_CONTROL:
{
MIC_STREAM_CONTROL *m = parg;
err = ngene_stream_control(dev, m->Stream, m->Control, m->Mode,
m->nLines, m->nBytesPerLine,
m->nVBILines, m->nBytesPerVBILine);
break;
}
default:
err = -EINVAL;
break;
}
return err;
}
static int command_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg)
{
void *parg = (void *)arg, *pbuf = NULL;
char buf[64];
int res = -EFAULT;
if (_IOC_DIR(cmd) & _IOC_WRITE) {
parg = buf;
if (_IOC_SIZE(cmd) > sizeof(buf)) {
pbuf = kmalloc(_IOC_SIZE(cmd), GFP_KERNEL);
if (!pbuf)
return -ENOMEM;
parg = pbuf;
}
if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))
goto error;
}
res = command_do_ioctl(inode, file, cmd, parg);
if (res < 0)
goto error;
if (_IOC_DIR(cmd) & _IOC_READ)
if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
res = -EFAULT;
error:
kfree(pbuf);
return res;
}
struct page *ngene_nopage(struct vm_area_struct *vma,
unsigned long address, int *type)
{
return 0;
}
static int ngene_mmap(struct file *file, struct vm_area_struct *vma)
{
struct dvb_device *dvbdev = file->private_data;
struct ngene_channel *chan = dvbdev->priv;
struct ngene *dev = chan->dev;
unsigned long size = vma->vm_end - vma->vm_start;
unsigned long off = vma->vm_pgoff << PAGE_SHIFT;
unsigned long padr = pci_resource_start(dev->pci_dev, 0) + off;
unsigned long psize = pci_resource_len(dev->pci_dev, 0) - off;
if (size > psize)
return -EINVAL;
if (io_remap_pfn_range(vma, vma->vm_start, padr >> PAGE_SHIFT, size,
vma->vm_page_prot))
return -EAGAIN;
return 0;
}
static int write_uart(struct ngene *dev, u8 *data, int len)
{
struct ngene_command com;
com.cmd.hdr.Opcode = CMD_WRITE_UART;
com.cmd.hdr.Length = len;
memcpy(com.cmd.WriteUart.Data, data, len);
com.cmd.WriteUart.Data[len] = 0;
com.cmd.WriteUart.Data[len + 1] = 0;
com.in_len = len;
com.out_len = 0;
if (ngene_command(dev, &com) < 0)
return -EIO;
return 0;
}
static int send_cli(struct ngene *dev, char *cmd)
{
/* printk(KERN_INFO DEVICE_NAME ": %s", cmd); */
return write_uart(dev, cmd, strlen(cmd));
}
static int send_cli_val(struct ngene *dev, char *cmd, u32 val)
{
char s[32];
snprintf(s, 32, "%s %d\n", cmd, val);
/* printk(KERN_INFO DEVICE_NAME ": %s", s); */
return write_uart(dev, s, strlen(s));
}
static int ngene_command_write_uart_user(struct ngene *dev,
const u8 *data, int len)
{
struct ngene_command com;
dev->tx_busy = 1;
com.cmd.hdr.Opcode = CMD_WRITE_UART;
com.cmd.hdr.Length = len;
if (copy_from_user(com.cmd.WriteUart.Data, data, len))
return -EFAULT;
com.in_len = len;
com.out_len = 0;
if (ngene_command(dev, &com) < 0)
return -EIO;
return 0;
}
static ssize_t uart_write(struct file *file, const char *buf,
size_t count, loff_t *ppos)
{
struct dvb_device *dvbdev = file->private_data;
struct ngene_channel *chan = dvbdev->priv;
struct ngene *dev = chan->dev;
int len, ret = 0;
size_t left = count;
while (left) {
len = left;
if (len > 250)
len = 250;
ret = wait_event_interruptible(dev->tx_wq, dev->tx_busy == 0);
if (ret < 0)
return ret;
ngene_command_write_uart_user(dev, buf, len);
left -= len;
buf += len;
}
return count;
}
static ssize_t ts_write(struct file *file, const char *buf,
size_t count, loff_t *ppos)
{
struct dvb_device *dvbdev = file->private_data;
struct ngene_channel *chan = dvbdev->priv;
struct ngene *dev = chan->dev;
if (wait_event_interruptible(dev->tsout_rbuf.queue,
dvb_ringbuffer_free
(&dev->tsout_rbuf) >= count) < 0)
return 0;
dvb_ringbuffer_write(&dev->tsout_rbuf, buf, count);
return count;
}
static ssize_t uart_read(struct file *file, char *buf,
size_t count, loff_t *ppos)
{
struct dvb_device *dvbdev = file->private_data;
struct ngene_channel *chan = dvbdev->priv;
struct ngene *dev = chan->dev;
int left;
int wp, rp, avail, len;
if (!dev->uart_rbuf)
return -EINVAL;
if (count > 128)
count = 128;
left = count;
while (left) {
if (wait_event_interruptible(dev->rx_wq,
dev->uart_wp != dev->uart_rp) < 0)
return -EAGAIN;
wp = dev->uart_wp;
rp = dev->uart_rp;
avail = (wp - rp);
if (avail < 0)
avail += UART_RBUF_LEN;
if (avail > left)
avail = left;
if (wp < rp) {
len = UART_RBUF_LEN - rp;
if (len > avail)
len = avail;
if (copy_to_user(buf, dev->uart_rbuf + rp, len))
return -EFAULT;
if (len < avail)
if (copy_to_user(buf + len, dev->uart_rbuf,
avail - len))
return -EFAULT;
} else {
if (copy_to_user(buf, dev->uart_rbuf + rp, avail))
return -EFAULT;
}
dev->uart_rp = (rp + avail) % UART_RBUF_LEN;
left -= avail;
buf += avail;
}
return count;
}
static const struct file_operations command_fops = {
.owner = THIS_MODULE,
.read = uart_read,
.write = ts_write,
.ioctl = command_ioctl,
.open = dvb_generic_open,
.release = dvb_generic_release,
.poll = 0,
.mmap = ngene_mmap,
};
static struct dvb_device dvbdev_command = {
.priv = 0,
.readers = -1,
.writers = -1,
.users = -1,
.fops = &command_fops,
};
#endif
/****************************************************************************/
/* DVB functions and API interface ******************************************/
......@@ -1550,32 +960,6 @@ static int ngene_start_feed(struct dvb_demux_feed *dvbdmxfeed)
{
struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
struct ngene_channel *chan = dvbdmx->priv;
#ifdef NGENE_COMMAND_API
struct ngene *dev = chan->dev;
if (dev->card_info->io_type[chan->number] & NGENE_IO_TSOUT) {
switch (dvbdmxfeed->pes_type) {
case DMX_TS_PES_VIDEO:
send_cli_val(dev, "vpid", dvbdmxfeed->pid);
send_cli(dev, "res 1080i50\n");
/* send_cli(dev, "vdec mpeg2\n"); */
break;
case DMX_TS_PES_AUDIO:
send_cli_val(dev, "apid", dvbdmxfeed->pid);
send_cli(dev, "start\n");
break;
case DMX_TS_PES_PCR:
send_cli_val(dev, "pcrpid", dvbdmxfeed->pid);
break;
default:
break;
}
}
#endif
if (chan->users == 0) {
set_transfer(chan, 1);
......@@ -1589,27 +973,6 @@ static int ngene_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
{
struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
struct ngene_channel *chan = dvbdmx->priv;
#ifdef NGENE_COMMAND_API
struct ngene *dev = chan->dev;
if (dev->card_info->io_type[chan->number] & NGENE_IO_TSOUT) {
switch (dvbdmxfeed->pes_type) {
case DMX_TS_PES_VIDEO:
send_cli(dev, "stop\n");
break;
case DMX_TS_PES_AUDIO:
break;
case DMX_TS_PES_PCR:
break;
default:
break;
}
}
#endif
if (--chan->users)
return chan->users;
......@@ -1621,23 +984,6 @@ static int ngene_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
static int write_to_decoder(struct dvb_demux_feed *feed,
const u8 *buf, size_t len)
{
struct dvb_demux *dvbdmx = feed->demux;
struct ngene_channel *chan = dvbdmx->priv;
struct ngene *dev = chan->dev;
if (wait_event_interruptible(dev->tsout_rbuf.queue,
dvb_ringbuffer_free
(&dev->tsout_rbuf) >= len) < 0)
return 0;
dvb_ringbuffer_write(&dev->tsout_rbuf, buf, len);
return len;
}
static int my_dvb_dmx_ts_card_init(struct dvb_demux *dvbdemux, char *id,
int (*start_feed)(struct dvb_demux_feed *),
int (*stop_feed)(struct dvb_demux_feed *),
......@@ -1678,86 +1024,12 @@ static int my_dvb_dmxdev_ts_card_init(struct dmxdev *dmxdev,
return dvbdemux->dmx.connect_frontend(&dvbdemux->dmx, hw_frontend);
}
/****************************************************************************/
/* Decypher firmware loading ************************************************/
/****************************************************************************/
#define DECYPHER_FW "decypher.fw"
static int dec_ts_send(struct ngene *dev, u8 *buf, u32 len)
{
while (dvb_ringbuffer_free(&dev->tsout_rbuf) < len)
msleep(1);
dvb_ringbuffer_write(&dev->tsout_rbuf, buf, len);
return len;
}
u8 dec_fw_fill_ts[188] = { 0x47, 0x09, 0x0e, 0x10, 0xff, 0xff, 0x00, 0x00 };
int dec_fw_send(struct ngene *dev, u8 *fw, u32 size)
{
struct ngene_channel *chan = &dev->channel[4];
u32 len = 180, cc = 0;
u8 buf[8] = { 0x47, 0x09, 0x0e, 0x10, 0x00, 0x00, 0x00, 0x00 };
set_transfer(chan, 1);
msleep(100);
while (size) {
len = 180;
if (len > size)
len = size;
buf[3] = 0x10 | (cc & 0x0f);
buf[4] = (cc >> 8);
buf[5] = cc & 0xff;
buf[6] = len;
dec_ts_send(dev, buf, 8);
dec_ts_send(dev, fw, len);
if (len < 180)
dec_ts_send(dev, dec_fw_fill_ts + len + 8, 180 - len);
cc++;
size -= len;
fw += len;
}
for (len = 0; len < 512; len++)
dec_ts_send(dev, dec_fw_fill_ts, 188);
while (dvb_ringbuffer_avail(&dev->tsout_rbuf))
msleep(10);
msleep(100);
set_transfer(chan, 0);
return 0;
}
int dec_fw_boot(struct ngene *dev)
{
u32 size;
const struct firmware *fw = NULL;
u8 *dec_fw;
if (request_firmware(&fw, DECYPHER_FW, &dev->pci_dev->dev) < 0) {
printk(KERN_ERR DEVICE_NAME
": %s not found. Check hotplug directory.\n",
DECYPHER_FW);
return -1;
}
printk(KERN_INFO DEVICE_NAME ": Booting decypher firmware file %s\n",
DECYPHER_FW);
size = fw->size;
dec_fw = (u8 *)fw->data;
dec_fw_send(dev, dec_fw, size);
release_firmware(fw);
return 0;
}
/****************************************************************************/
/* nGene hardware init and release functions ********************************/
/****************************************************************************/
void free_ringbuffer(struct ngene *dev, struct SRingBufferDescriptor *rb)
static void free_ringbuffer(struct ngene *dev, struct SRingBufferDescriptor *rb)
{
struct SBufferHeader *Cur = rb->Head;
u32 j;
......@@ -1786,7 +1058,7 @@ void free_ringbuffer(struct ngene *dev, struct SRingBufferDescriptor *rb)
pci_free_consistent(dev->pci_dev, rb->MemSize, rb->Head, rb->PAHead);
}
void free_idlebuffer(struct ngene *dev,
static void free_idlebuffer(struct ngene *dev,
struct SRingBufferDescriptor *rb,
struct SRingBufferDescriptor *tb)
{
......@@ -1804,7 +1076,7 @@ void free_idlebuffer(struct ngene *dev,
}
}
void free_common_buffers(struct ngene *dev)
static void free_common_buffers(struct ngene *dev)
{
u32 i;
struct ngene_channel *chan;
......@@ -1832,7 +1104,7 @@ void free_common_buffers(struct ngene *dev)
/* Ring buffer handling *****************************************************/
/****************************************************************************/
int create_ring_buffer(struct pci_dev *pci_dev,
static int create_ring_buffer(struct pci_dev *pci_dev,
struct SRingBufferDescriptor *descr, u32 NumBuffers)
{
dma_addr_t tmp;
......@@ -2311,8 +1583,6 @@ static int ngene_start(struct ngene *dev)
goto fail;
if (dev->card_info->fw_version == 17) {
u8 hdtv_config[6] =
{6144 / 64, 0, 0, 2048 / 64, 2048 / 64, 2048 / 64};
u8 tsin4_config[6] =
{3072 / 64, 3072 / 64, 0, 3072 / 64, 3072 / 64, 0};
u8 default_config[6] =
......@@ -2321,30 +1591,14 @@ static int ngene_start(struct ngene *dev)
if (dev->card_info->io_type[3] == NGENE_IO_TSIN)
bconf = tsin4_config;
if (dev->card_info->io_type[0] == NGENE_IO_HDTV) {
bconf = hdtv_config;
ngene_reset_decypher(dev);
}
dprintk(KERN_DEBUG DEVICE_NAME ": FW 17 buffer config\n");
stat = ngene_command_config_free_buf(dev, bconf);
} else {
int bconf = BUFFER_CONFIG_4422;
if (dev->card_info->io_type[0] == NGENE_IO_HDTV) {
bconf = BUFFER_CONFIG_8022;
ngene_reset_decypher(dev);
}
if (dev->card_info->io_type[3] == NGENE_IO_TSIN)
bconf = BUFFER_CONFIG_3333;
stat = ngene_command_config_buf(dev, bconf);
}
if (dev->card_info->io_type[0] == NGENE_IO_HDTV) {
ngene_command_config_uart(dev, 0xc1, tx_cb, rx_cb);
test_dec_i2c(&dev->channel[0].i2c_adapter, 0);
test_dec_i2c(&dev->channel[0].i2c_adapter, 1);
}
return stat;
fail:
ngwritel(0, NGENE_INT_ENABLE);
......@@ -2432,10 +1686,6 @@ static void release_channel(struct ngene_channel *chan)
tasklet_kill(&chan->demux_tasklet);
if (io & (NGENE_IO_TSIN | NGENE_IO_TSOUT)) {
#ifdef NGENE_COMMAND_API
if (chan->command_dev)
dvb_unregister_device(chan->command_dev);
#endif
if (chan->fe) {
dvb_unregister_frontend(chan->fe);
dvb_frontend_detach(chan->fe);
......@@ -2452,7 +1702,6 @@ static void release_channel(struct ngene_channel *chan)
if (chan->number == 0 || !one_adapter)
dvb_unregister_adapter(&dev->adapter[chan->number]);
}
}
static int init_channel(struct ngene_channel *chan)
......@@ -2472,10 +1721,6 @@ static int init_channel(struct ngene_channel *chan)
if (io & (NGENE_IO_TSIN | NGENE_IO_TSOUT)) {
if (nr >= STREAM_AUDIOIN1)
chan->DataFormatFlags = DF_SWAP32;
if (io & NGENE_IO_TSOUT)
dec_fw_boot(dev);
if (nr == 0 || !one_adapter) {
adapter = &dev->adapter[nr];
ret = dvb_register_adapter(adapter, "nGene",
......@@ -2494,14 +1739,6 @@ static int init_channel(struct ngene_channel *chan)
ret = my_dvb_dmxdev_ts_card_init(&chan->dmxdev, &chan->demux,
&chan->hw_frontend,
&chan->mem_frontend, adapter);
if (io & NGENE_IO_TSOUT) {
dvbdemux->write_to_decoder = write_to_decoder;
}
#ifdef NGENE_COMMAND_API
dvb_register_device(adapter, &chan->command_dev,
&dvbdev_command, (void *)chan,
DVB_DEVICE_SEC);
#endif
}
if (io & NGENE_IO_TSIN) {
......@@ -2522,7 +1759,6 @@ static int init_channel(struct ngene_channel *chan)
nr);
}
}
return ret;
}
......@@ -2589,12 +1825,6 @@ static int __devinit ngene_probe(struct pci_dev *pci_dev,
goto fail1;
dev->i2c_current_bus = -1;
/* Disable analog TV decoder chips if present */
if (copy_eeprom) {
i2c_copy_eeprom(&dev->channel[0].i2c_adapter, 0x50, 0x52);
i2c_dump_eeprom(&dev->channel[0].i2c_adapter, 0x52);
}
/*i2c_check_eeprom(&dev->i2c_adapter);*/
/* Register DVB adapters and devices for both channels */
if (init_channels(dev) < 0)
......
drivers/media/dvb/ngene/ngene-ioctls.h deleted 100644 → 0
View file @ cf1b12f2
/*
* Copyright (C) 2006-2007 Micronas
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* version 2 only, as published by the Free Software Foundation.
*
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA
* Or, point your browser to http://www.gnu.org/copyleft/gpl.html
*/
#ifndef _NGENE_IOCTLS_H_
#define _NGENE_IOCTLS_H_
#include <linux/ioctl.h>
#include <linux/types.h>
#define NGENE_MAGIC 'n'
typedef struct {
unsigned char I2CAddress;
unsigned char OutLength; /* bytes to write first */
unsigned char InLength; /* bytes to read */
unsigned char OutData[256]; /* output data */
unsigned char InData[256]; /* input data */
} MIC_I2C_READ, *PMIC_I2C_READ;
#define IOCTL_MIC_I2C_READ _IOWR(NGENE_MAGIC, 0x00, MIC_I2C_READ)
typedef struct {
unsigned char I2CAddress;
unsigned char Length;
unsigned char Data[250];
} MIC_I2C_WRITE, *PMIC_I2C_WRITE;
typedef struct {
unsigned char Length;
unsigned char Data[250];
} MIC_I2C_CONTINUE_WRITE, *PMIC_I2C_CONTINUE_WRITE;
#define IOCTL_MIC_I2C_WRITE _IOW(NGENE_MAGIC, 0x01, \
MIC_I2C_WRITE)
#define IOCTL_MIC_I2C_WRITE_NOSTOP _IOW(NGENE_MAGIC, 0x0c, \
MIC_I2C_WRITE)
#define IOCTL_MIC_I2C_CONTINUE_WRITE_NOSTOP _IOW(NGENE_MAGIC, 0x0d, \
MIC_I2C_CONTINUE_WRITE)
#define IOCTL_MIC_I2C_CONTINUE_WRITE _IOW(NGENE_MAGIC, 0x0e, \
MIC_I2C_CONTINUE_WRITE)
typedef struct {
unsigned char ModeSelect; /* see bellow */
unsigned char OutLength; /* bytes to write first */
unsigned char InLength; /* bytes to read */
unsigned char OutData[250]; /* output data */
} MIC_SPI_READ, *PMIC_SPI_READ;
#define IOCTL_MIC_SPI_READ _IOWR(NGENE_MAGIC, 0x02, MIC_SPI_READ)
typedef struct {
unsigned char ModeSelect; /* see below */
unsigned char Length;
unsigned char Data[250];
} MIC_SPI_WRITE, *PMIC_SPI_WRITE;
#define IOCTL_MIC_SPI_WRITE _IOW(NGENE_MAGIC, 0x03, MIC_SPI_READ)
#define IOCTL_MIC_DOWNLOAD_FIRMWARE _IOW(NGENE_MAGIC, 0x06, unsigned char)
#define IOCTL_MIC_NO_OP _IO(NGENE_MAGIC, 0x18)
#define IOCTL_MIC_TUN_RDY _IO(NGENE_MAGIC, 0x07)
#define IOCTL_MIC_DEC_SRATE _IOW(NGENE_MAGIC, 0x0a, int)
#define IOCTL_MIC_DEC_RDY _IO(NGENE_MAGIC, 0x09)
#define IOCTL_MIC_DEC_FREESYNC _IOW(NGENE_MAGIC, 0x08, int)
#define IOCTL_MIC_TUN_DETECT _IOWR(NGENE_MAGIC, 0x0b, int)
typedef struct {
unsigned char Stream; /* < UVI1, UVI2, or TVOUT */
unsigned char Control;
unsigned char Mode;
unsigned short nLines;
unsigned short nBytesPerLine;
unsigned short nVBILines;
unsigned short nBytesPerVBILine;
} MIC_STREAM_CONTROL, *PMIC_STREAM_CONTROL;
enum MIC_STREAM_CONTROL_MODE_BITS {
MSC_MODE_LOOPBACK = 0x80,
MSC_MODE_AVLOOP = 0x40,
MSC_MODE_AUDIO_SPDIF = 0x20,
MSC_MODE_AVSYNC = 0x10,
MSC_MODE_TRANSPORT_STREAM = 0x08,
MSC_MODE_AUDIO_CAPTURE = 0x04,
MSC_MODE_VBI_CAPTURE = 0x02,
MSC_MODE_VIDEO_CAPTURE = 0x01
};
#define IOCTL_MIC_STREAM_CONTROL _IOW(NGENE_MAGIC, 0x22, MIC_STREAM_CONTROL)
typedef struct {
unsigned char Stream; /* < UVI1, UVI2 */
unsigned int Rate; /* < Rate in 100nsec to release the buffers
to the stream filters */
} MIC_SIMULATE_CONTROL, *PMIC_SIMULATE_CONTROL;
#define IOCTL_MIC_SIMULATE_CONTROL _IOW(NGENE_MAGIC, 0x23, \
MIC_SIMULATE_CONTROL)
/*
* IOCTL definitions for the test driver
*
* NOTE: the test driver also supports following IOCTL defined above:
* IOCTL_MIC_NO_OP:
* IOCTL_MIC_RECEIVE_BUFFER:
* IOCTL_MIC_STREAM_CONTROL:
* IOCTL_MIC_I2C_READ:
* IOCTL_MIC_I2C_WRITE:
*
*
* VI2C access to NGene memory (read)
*
* GETMEM in : ULONG start offset
* out : read data (length defined by size of output buffer)
* SETMEM in : ULONG start offset followed by data to be written
* (length defined by size of input buffer)
*/
typedef struct {
__u32 Start;
__u32 Length;
__u8 *Data;
} MIC_MEM;
#define IOCTL_MIC_TEST_GETMEM _IOWR(NGENE_MAGIC, 0x90, MIC_MEM)
#define IOCTL_MIC_TEST_SETMEM _IOW(NGENE_MAGIC, 0x91, MIC_MEM)
typedef struct {
__u8 Address;
__u8 Data;
} MIC_IMEM;
#define IOCTL_MIC_SFR_READ _IOWR(NGENE_MAGIC, 0xa2, MIC_IMEM)
#define IOCTL_MIC_SFR_WRITE _IOWR(NGENE_MAGIC, 0xa3, MIC_IMEM)
#define IOCTL_MIC_IRAM_READ _IOWR(NGENE_MAGIC, 0xa4, MIC_IMEM)
#define IOCTL_MIC_IRAM_WRITE _IOWR(NGENE_MAGIC, 0xa5, MIC_IMEM)
/*
* Set Ngene gpio bit
*/
typedef struct {
unsigned char Select;
unsigned char Level;
} MIC_SET_GPIO_PIN, *PMIC_SET_GPIO_PIN;
#define IOCTL_MIC_SET_GPIO_PIN _IOWR(NGENE_MAGIC, 0xa6, MIC_SET_GPIO_PIN)
/*
* Uart ioctls:
* These are implemented in the test driver.
*
* Enable UART
*
* In: 1 byte containing baud rate: 0 = 19200, 1 = 9600, 2 = 4800, 3 = 2400
* Out: nothing
*/
#define IOCTL_MIC_UART_ENABLE _IOW(NGENE_MAGIC, 0xa9, unsigned char)
/*
* Enable UART
*
* In: nothing
* Out: nothing
*/
#define IOCTL_MIC_UART_DISABLE _IO(NGENE_MAGIC, 0xAA)
/*
* Write UART
*
* In: data to write
* Out: nothing
* Note: Call returns immediatly, data are send out asynchrounsly
*/
#define IOCTL_MIC_UART_WRITE _IOW(NGENE_MAGIC, 0xAB, unsigned char)
/*
* Read UART
*
* In: nothing
* Out: Data read (since last call)
* Note: Call returns immediatly
*/
#define IOCTL_MIC_UART_READ _IOR(NGENE_MAGIC, 0xAC, unsigned char)
/*
* UART Status
*
* In: nothing
* Out: Byte 0 : Transmitter busy,
* Byte 1 : Nbr of characters available for read.
* Note: Call returns immediatly
*/
#define IOCTL_MIC_UART_STATUS _IOR(NGENE_MAGIC, 0xAD, unsigned char)
#endif
drivers/media/dvb/ngene/ngene-snd.c deleted 100644 → 0
View file @ cf1b12f2
/*
* ngene_snd.c: nGene PCIe bridge driver ALSA support
*
* Copyright (C) 2005-2007 Micronas
*
* Based on the initial ALSA support port by Thomas Eschbach.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* version 2 only, as published by the Free Software Foundation.
*
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA
* Or, point your browser to http://www.gnu.org/copyleft/gpl.html
*/
#include <linux/version.h>
#include <linux/module.h>
#include "ngene.h"
#include "ngene-ioctls.h"
static int sound_dev;
/* sound module parameters (see "Module Parameters") */
static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
static int enable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 1};
/****************************************************************************/
/* PCM Sound Funktions ******************************************************/
/****************************************************************************/
static struct snd_pcm_hardware snd_mychip_capture_hw = {
.info = (SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER),
.formats = SNDRV_PCM_FMTBIT_S16_LE,
.rates = (SNDRV_PCM_RATE_11025 | SNDRV_PCM_RATE_16000
| SNDRV_PCM_RATE_22050 | SNDRV_PCM_RATE_32000
| SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000),
.rate_min = 11025,
.rate_max = 48000,
.channels_min = 2,
.channels_max = 2,
.buffer_bytes_max = 16384,
.period_bytes_min = 8192,
.period_bytes_max = 8192,
.periods_min = 1,
.periods_max = 2,
};
/* open callback */
static int snd_mychip_capture_open(struct snd_pcm_substream *substream)
{
struct mychip *chip = snd_pcm_substream_chip(substream);
struct snd_pcm_runtime *runtime = substream->runtime;
runtime->hw = snd_mychip_capture_hw;
chip->substream = substream;
return 0;
}
/* close callback */
static int snd_mychip_capture_close(struct snd_pcm_substream *substream)
{
struct mychip *chip = snd_pcm_substream_chip(substream);
chip->substream = NULL;
return 0;
}
/* hw_params callback */
static int snd_mychip_pcm_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *hw_params)
{
struct mychip *chip = snd_pcm_substream_chip(substream);
struct ngene_channel *chan = chip->chan;
if (chan->soundbuffisallocated == 0) {
chan->soundbuffisallocated = 1;
return snd_pcm_lib_malloc_pages(substream,
params_buffer_bytes(hw_params));
}
return 0;
}
/* hw_free callback */
static int snd_mychip_pcm_hw_free(struct snd_pcm_substream *substream)
{
struct mychip *chip = snd_pcm_substream_chip(substream);
struct ngene_channel *chan = chip->chan;
int retval = 0;
if (chan->soundbuffisallocated == 1) {
chan->soundbuffisallocated = 0;
retval = snd_pcm_lib_free_pages(substream);
}
return retval;
}
/* prepare callback */
static int snd_mychip_pcm_prepare(struct snd_pcm_substream *substream)
{
struct mychip *chip = snd_pcm_substream_chip(substream);
struct snd_pcm_runtime *runtime = substream->runtime;
struct ngene_channel *chan = chip->chan;
struct ngene_channel *ch = &chan->dev->channel[chan->number - 2];
struct i2c_adapter *adap = &ch->i2c_adapter;
if (ch->soundstreamon == 1)
;/*ngene_command_stream_control_sound(chan->dev, chan->number,
0x00, 0x00);*/
i2c_clients_command(adap, IOCTL_MIC_DEC_SRATE, &(runtime->rate));
mdelay(80);
if (ch->soundstreamon == 1)
;/*ngene_command_stream_control_sound(chan->dev, chan->number,
0x80, 0x04);*/
return 0;
}
/* trigger callback */
static int snd_mychip_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
{
struct mychip *chip = snd_pcm_substream_chip(substream);
struct ngene_channel *chan = chip->chan;
switch (cmd) {
case SNDRV_PCM_TRIGGER_START:
/* do something to start the PCM engine */
chan->sndbuffflag = 0;
break;
case SNDRV_PCM_TRIGGER_STOP:
/* do something to stop the PCM engine */
chip->substream = NULL;
chan->sndbuffflag = 0;
break;
default:
return -EINVAL;
}
return 0;
}
/* pointer callback */
static snd_pcm_uframes_t
snd_mychip_pcm_pointer(struct snd_pcm_substream *substream)
{
struct mychip *chip = snd_pcm_substream_chip(substream);
struct ngene_channel *chan = chip->chan;
unsigned int current_ptr;
if (chan->sndbuffflag == 0) {
current_ptr = (unsigned int)
bytes_to_frames(substream->runtime, 0);
} else {
current_ptr = (unsigned int)
bytes_to_frames(substream->runtime, 8192);
}
return current_ptr;
}
/*copy sound buffer to pcm middel layer*/
static int snd_capture_copy(struct snd_pcm_substream *substream, int channel,
snd_pcm_uframes_t pos, void *dst,
snd_pcm_uframes_t count)
{
struct snd_pcm_runtime *runtime = substream->runtime;
struct mychip *chip = snd_pcm_substream_chip(substream);
struct ngene_channel *chan = chip->chan;
memcpy(dst, chan->soundbuffer, frames_to_bytes(runtime, count));
return 0;
}
static int snd_pcm_capture_silence(struct snd_pcm_substream *substream,
int channel,
snd_pcm_uframes_t pos,
snd_pcm_uframes_t count)
{
/*
struct snd_pcm_runtime *runtime = substream->runtime;
struct mychip *chip = snd_pcm_substream_chip(substream);
struct ngene_channel *chan = chip->chan;
*/
return 0;
}
/* operators */
static struct snd_pcm_ops snd_mychip_capture_ops = {
.open = snd_mychip_capture_open,
.close = snd_mychip_capture_close,
.ioctl = snd_pcm_lib_ioctl,
.hw_params = snd_mychip_pcm_hw_params,
.hw_free = snd_mychip_pcm_hw_free,
.prepare = snd_mychip_pcm_prepare,
.trigger = snd_mychip_pcm_trigger,
.pointer = snd_mychip_pcm_pointer,
.copy = snd_capture_copy,
.silence = snd_pcm_capture_silence,
};
static void mychip_pcm_free(struct snd_pcm *pcm)
{
pcm->private_data = NULL;
}
/* create a pcm device */
static int snd_mychip_new_pcm(struct mychip *chip, struct ngene_channel *chan)
{
struct snd_pcm *pcm;
int err;
char gro[10];
sprintf(gro, "PCM%d", chan->number);
err = snd_pcm_new(chip->card, gro, 0, 0, 1, &pcm);
if (err < 0)
return err;
pcm->private_data = chip;
pcm->private_free = mychip_pcm_free;
sprintf(pcm->name, "MyPCM_%d", chan->number);
chip->pcm = pcm;
/* set operators */
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_mychip_capture_ops);
/* pre-allocation of buffers */
err = snd_pcm_lib_preallocate_pages_for_all(pcm,
SNDRV_DMA_TYPE_CONTINUOUS,
snd_dma_continuous_data(
GFP_KERNEL),
0, 16 * 1024);
return 0;
}
#define ngene_VOLUME(xname, xindex, addr) \
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
.info = snd_volume_info, \
.get = snd_volume_get, .put = snd_volume_put, \
.private_value = addr }
static int snd_volume_info(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_info *uinfo)
{
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
uinfo->count = 2;
uinfo->value.integer.min = 0;
uinfo->value.integer.max = 20;
return 0;
}
static int snd_volume_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct mychip *chip = snd_kcontrol_chip(kcontrol);
int addr = kcontrol->private_value;
ucontrol->value.integer.value[0] = chip->mixer_volume[addr][0];
ucontrol->value.integer.value[1] = chip->mixer_volume[addr][1];
return 0;
}
static int snd_volume_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct mychip *chip = snd_kcontrol_chip(kcontrol);
int change, addr = kcontrol->private_value;
int left, right;
left = ucontrol->value.integer.value[0];
if (left < 0)
left = 0;
if (left > 20)
left = 20;
right = ucontrol->value.integer.value[1];
if (right < 0)
right = 0;
if (right > 20)
right = 20;
spin_lock_irq(&chip->mixer_lock);
change = chip->mixer_volume[addr][0] != left ||
chip->mixer_volume[addr][1] != right;
chip->mixer_volume[addr][0] = left;
chip->mixer_volume[addr][1] = right;
spin_unlock_irq(&chip->mixer_lock);
return change;
}
#define ngene_CAPSRC(xname, xindex, addr) \
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
.info = snd_capsrc_info, \
.get = snd_capsrc_get, .put = snd_capsrc_put, \
.private_value = addr }
static int snd_capsrc_info(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_info *uinfo)
{
uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
uinfo->count = 2;
uinfo->value.integer.min = 0;
uinfo->value.integer.max = 1;
return 0;
}
static int snd_capsrc_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct mychip *chip = snd_kcontrol_chip(kcontrol);
int addr = kcontrol->private_value;
spin_lock_irq(&chip->mixer_lock);
ucontrol->value.integer.value[0] = chip->capture_source[addr][0];
ucontrol->value.integer.value[1] = chip->capture_source[addr][1];
spin_unlock_irq(&chip->mixer_lock);
return 0;
}
static int snd_capsrc_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct mychip *chip = snd_kcontrol_chip(kcontrol);
int change, addr = kcontrol->private_value;
int left, right;
left = ucontrol->value.integer.value[0] & 1;
right = ucontrol->value.integer.value[1] & 1;
spin_lock_irq(&chip->mixer_lock);
change = chip->capture_source[addr][0] != left ||
chip->capture_source[addr][1] != right;
chip->capture_source[addr][0] = left;
chip->capture_source[addr][1] = right;
spin_unlock_irq(&chip->mixer_lock);
if (change)
printk(KERN_INFO "snd_capsrc_put change\n");
return 0;
}
static struct snd_kcontrol_new snd_controls[] = {
ngene_VOLUME("Video Volume", 0, MIXER_ADDR_TVTUNER),
ngene_CAPSRC("Video Capture Switch", 0, MIXER_ADDR_TVTUNER),
};
static int snd_card_new_mixer(struct mychip *chip)
{
struct snd_card *card = chip->card;
unsigned int idx;
int err;
strcpy(card->mixername, "NgeneMixer");
for (idx = 0; idx < ARRAY_SIZE(snd_controls); idx++) {
err = snd_ctl_add(card, snd_ctl_new1(&snd_controls[idx], chip));
if (err < 0)
return err;
}
return 0;
}
int ngene_snd_init(struct ngene_channel *chan)
{
struct snd_card *card;
struct mychip *chip;
int err;
if (sound_dev >= SNDRV_CARDS)
return -ENODEV;
if (!enable[sound_dev]) {
sound_dev++;
return -ENOENT;
}
card = snd_card_new(index[sound_dev], id[sound_dev],
THIS_MODULE, sizeof(struct mychip));
if (card == NULL)
return -ENOMEM;
chip = card->private_data;
chip->card = card;
chip->irq = -1;
sprintf(card->shortname, "MyChip%d%d", chan->dev->nr, chan->number);
sprintf(card->shortname, "Myown%d%d", chan->dev->nr, chan->number);
sprintf(card->longname, "My first Own Chip on Card Nr.%d is %d",
chan->dev->nr, chan->number);
spin_lock_init(&chip->lock);
spin_lock_init(&chip->mixer_lock);
snd_card_new_mixer(chip);
snd_mychip_new_pcm(chip, chan);
err = snd_card_register(card);
if (err < 0) {
snd_card_free(card);
return err;
}
chan->soundcard = card;
chan->mychip = chip;
chip->chan = chan;
sound_dev++;
return 0;
}
int ngene_snd_exit(struct ngene_channel *chan)
{
snd_card_free(chan->soundcard);
return 0;
}
drivers/media/dvb/ngene/ngene-v4l2.c deleted 100644 → 0
View file @ cf1b12f2
/*
* ngene_v4l2.c: nGene PCIe bridge driver V4L2 support
*
* Copyright (C) 2005-2007 Micronas
*
* Based on the initial V4L2 support port by Thomas Eschbach.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* version 2 only, as published by the Free Software Foundation.
*
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA
* Or, point your browser to http://www.gnu.org/copyleft/gpl.html
*/
#include <linux/module.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/sched.h>
#include <linux/spinlock.h>
#include <linux/fs.h>
#include <linux/unistd.h>
#include <linux/time.h>
#include <linux/pci.h>
#include <linux/vmalloc.h>
#include <linux/pagemap.h>
#include <linux/videodev2.h>
#include <linux/videodev.h>
#include <linux/version.h>
#include <asm/uaccess.h>
#include <asm/semaphore.h>
#include <asm/system.h>
#include <asm/io.h>
#include <asm/kmap_types.h>
#include <linux/videodev.h>
#include <media/v4l2-dev.h>
#include "ngene.h"
#include "ngene-ioctls.h"
/****************************************************************************/
static unsigned int gbuffers = 8;
static unsigned int gbufsize = 0x208000;
enum km_type ngene_km_types[] = {
KM_USER0,
KM_USER1,
KM_SOFTIRQ0,
KM_SOFTIRQ1,
};
#define V4L2_STD_NTSC_M_KOREA ((v4l2_std_id)0x00004000)
#define V4L2_STD_SECAM_L1 ((v4l2_std_id)0x00008000)
static inline void *my_video_get_drvdata(struct video_device *vd)
{
return dev_get_drvdata(vd->dev);
}
static inline void my_video_set_drvdata(struct video_device *vd, void *d)
{
dev_set_drvdata(vd->dev, d);
}
static struct ngene_tvnorm ngene_tvnorms_hd[] = {
{
.v4l2_id = V4L2_STD_PAL_BG,
.name = "1080i50",
.swidth = 1920,
.sheight = 1080,
.tuner_norm = 1,
.soundstd = 1,
}
};
static struct ngene_tvnorm ngene_tvnorms_sd[] = {
/* PAL-BDGHI */
/* max. active video is actually 922, but 924 is divisible by 4 & 3!*/
/* actually, max active PAL with HSCALE=0 is 948, NTSC is 768 - nil */
{
.v4l2_id = V4L2_STD_PAL_BG,
.name = "PAL-BG",
.swidth = 720,
.sheight = 576,
.tuner_norm = 1,
.soundstd = 1,
}, {
.v4l2_id = V4L2_STD_PAL_DK,
.name = "PAL-DK",
.swidth = 720,
.sheight = 576,
.tuner_norm = 2,
.soundstd = 2,
}, {
.v4l2_id = V4L2_STD_PAL_H,
.name = "PAL-H",
.swidth = 720,
.sheight = 576,
.tuner_norm = 0,
.soundstd = 1,
}, {
.v4l2_id = V4L2_STD_PAL_I,
.name = "PAL-I",
.swidth = 720,
.sheight = 576,
.tuner_norm = 4,
.soundstd = 4,
}, {
.v4l2_id = V4L2_STD_PAL_M,
.name = "PAL_M",
.swidth = 720,
.sheight = 5760,
.tuner_norm = 7,
.soundstd = 5,
}, {
.v4l2_id = V4L2_STD_NTSC_M,
.name = "NTSC_M",
.swidth = 720,
.sheight = 480,
.tuner_norm = 7,
.soundstd = 5,
}, {
.v4l2_id = V4L2_STD_NTSC_M_JP,
.name = "NTSC_M_JP",
.swidth = 720,
.sheight = 480,
.tuner_norm = 7,
.soundstd = 6,
}, {
.v4l2_id = V4L2_STD_PAL_N,
.name = "PAL-N",
.swidth = 720,
.sheight = 576,
.tuner_norm = 7,
.soundstd = 5,
}, {
.v4l2_id = V4L2_STD_SECAM_B,
.name = "SECAM_B",
.swidth = 720,
.sheight = 576,
.tuner_norm = 1,
.soundstd = 1,
}, {
.v4l2_id = V4L2_STD_SECAM_D,
.name = "SECAM_D",
.swidth = 720,
.sheight = 576,
.tuner_norm = 2,
.soundstd = 2,
}, {
.v4l2_id = V4L2_STD_SECAM_G,
.name = "SECAM_G",
.swidth = 720,
.sheight = 576,
.tuner_norm = 3,
.soundstd = 1,
}, {
.v4l2_id = V4L2_STD_SECAM_H,
.name = "SECAM_H",
.swidth = 720,
.sheight = 576,
.tuner_norm = 3,
.soundstd = 1,
}, {
.v4l2_id = V4L2_STD_SECAM_K,
.name = "SECAM_K",
.swidth = 720,
.sheight = 576,
.tuner_norm = 2,
.soundstd = 2,
}, {
.v4l2_id = V4L2_STD_SECAM_K1,
.name = "SECAM_K1",
.swidth = 720,
.sheight = 576,
.tuner_norm = 2,
.soundstd = 2,
}, {
.v4l2_id = V4L2_STD_SECAM_L,
.name = "SECAM_L",
.swidth = 720,
.sheight = 576,
.tuner_norm = 5,
.soundstd = 3,
}, {
.v4l2_id = V4L2_STD_NTSC_M_KOREA,
.name = "NTSC_M_KOREA",
.swidth = 720,
.sheight = 480,
.tuner_norm = 7,
.soundstd = 7,
}, {
.v4l2_id = V4L2_STD_SECAM_L1,
.name = "SECAM_L1",
.swidth = 720,
.sheight = 576,
.tuner_norm = 6,
.soundstd = 3,
}
};
static const int NGENE_TVNORMS = ARRAY_SIZE(ngene_tvnorms_sd);
static u8 BlackLine[1440] = {
/* 0x80, */ 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80, 0x10, 0x80, 0x10, 0x80, 0x10, 0x80, 0x10,
0x80,
};
#define V4L2_CID_PRIVATE_SHARPNESS (V4L2_CID_PRIVATE_BASE + 0)
#define V4L2_CID_PRIVATE_LASTP1 (V4L2_CID_PRIVATE_BASE + 1)
static const struct v4l2_queryctrl no_ctl = {
.name = "no_ctl",
.flags = V4L2_CTRL_FLAG_DISABLED,
};
static const struct v4l2_queryctrl ngene_ctls[] = {
/* --- video --- */
{
.id = V4L2_CID_BRIGHTNESS,
.name = "Brightness",
.minimum = -127,
.maximum = 127,
.step = 1,
.default_value = 0,
.type = V4L2_CTRL_TYPE_INTEGER,
}, {
.id = V4L2_CID_CONTRAST,
.name = "Contrast",
.minimum = 0,
.maximum = 63,
.step = 1,
.default_value = 30,
.type = V4L2_CTRL_TYPE_INTEGER,
}, {
.id = V4L2_CID_SATURATION,
.name = "Saturation",
.minimum = 0,
.maximum = 4094,
.step = 1,
.default_value = 2000,
.type = V4L2_CTRL_TYPE_INTEGER,
}, {
.id = V4L2_CID_HUE,
.name = "Hue",
.minimum = -2047,
.maximum = 2047,
.step = 1,
.default_value = 0,
.type = V4L2_CTRL_TYPE_INTEGER,
},
/* --- audio --- */
{
.id = V4L2_CID_AUDIO_MUTE,
.name = "Mute",
.minimum = 0,
.maximum = 1,
.type = V4L2_CTRL_TYPE_BOOLEAN,
}, {
.id = V4L2_CID_PRIVATE_SHARPNESS,
.name = "sharpness",
.minimum = 0,
.maximum = 100,
.step = 1,
.default_value = 50,
.type = V4L2_CTRL_TYPE_INTEGER,
},
};
static const int NGENE_CTLS = ARRAY_SIZE(ngene_ctls);
static const struct ngene_format ngene_formats[] = {
{
.name = "4:2:2, packed, YUYV",
.palette = -1,
.fourcc = V4L2_PIX_FMT_YUYV,
.format = V4L2_PIX_FMT_YUYV,
.palette = VIDEO_PALETTE_YUYV,
.depth = 16,
.flags = 0x02,/* FORMAT_FLAGS_PACKED, */
}
};
static const unsigned int NGENE_FORMATS = ARRAY_SIZE(ngene_formats);
/****************************************************************************/
static struct videobuf_queue *ngene_queue(struct ngene_vopen *vopen)
{
struct videobuf_queue *q = NULL;
switch (vopen->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE:
q = &vopen->vbuf_q;
break;
case V4L2_BUF_TYPE_VBI_CAPTURE:
q = &vopen->vbi;
break;
default:
break;
}
return q;
}
static int ngene_resource(struct ngene_vopen *vopen)
{
int res = 0;
switch (vopen->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE:
res = RESOURCE_VIDEO;
break;
case V4L2_BUF_TYPE_VBI_CAPTURE:
res = RESOURCE_VBI;
break;
default:
break;
}
return res;
}
static int ngene_try_fmt(struct ngene_vopen *vopen, struct ngene_channel *chan,
struct v4l2_format *f)
{
switch (f->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE:
{
const struct ngene_format *fmt;
enum v4l2_field field;
unsigned int maxw, maxh;
int maxLinesPerField;
fmt = ngene_formats;
if (NULL == fmt)
return -EINVAL;
/* fixup format */
maxw = chan->tvnorms[chan->tvnorm].swidth;
maxLinesPerField = chan->tvnorms[chan->tvnorm].sheight;
maxh = maxLinesPerField;
field = f->fmt.pix.field;
if (V4L2_FIELD_ANY == field)
field = (f->fmt.pix.height > maxh / 2)
? V4L2_FIELD_INTERLACED : V4L2_FIELD_BOTTOM;
if (V4L2_FIELD_SEQ_BT == field)
field = V4L2_FIELD_SEQ_TB;
/* update data for the application */
f->fmt.pix.field = field;
if (f->fmt.pix.width < 48)
f->fmt.pix.width = 48;
if (f->fmt.pix.height < 32)
f->fmt.pix.height = 32;
if (f->fmt.pix.width > maxw)
f->fmt.pix.width = maxw;
if (f->fmt.pix.height > maxh)
f->fmt.pix.height = maxh;
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;
}
case V4L2_BUF_TYPE_VIDEO_OVERLAY:
return -EINVAL;
case V4L2_BUF_TYPE_VBI_CAPTURE:
return 0;
default:
return -EINVAL;
}
}
/****************************************************************************/
/* Analog driver stuff ******************************************************/
/****************************************************************************/
static int check_alloc_res(struct ngene_channel *channel,
struct ngene_vopen *vopen, int bit)
{
if (vopen->resources & bit)
/* have it already allocated */
return 1;
/* is it free? */
down(&channel->reslock);
if (channel->resources & bit) {
/* no, someone else uses it */
up(&channel->reslock);
return 0;
}
/* it's free, grab it */
vopen->resources |= bit;
channel->resources |= bit;
up(&channel->reslock);
return 1;
}
static int check_res(struct ngene_vopen *vopen, int bit)
{
return vopen->resources & bit;
}
static int locked_res(struct ngene_channel *chan, int bit)
{
return chan->resources & bit;
}
static void free_res(struct ngene_channel *channel,
struct ngene_vopen *vopen, int bits)
{
down(&channel->reslock);
vopen->resources &= ~bits;
channel->resources &= ~bits;
up(&channel->reslock);
}
/****************************************************************************/
/* MISC HELPERS *************************************************************/
/****************************************************************************/
static int ngene_g_fmt(struct ngene_vopen *vopen, struct v4l2_format *f)
{
if (!vopen->fmt)
vopen->fmt = ngene_formats;
switch (f->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE:
memset(&f->fmt.pix, 0, sizeof(struct v4l2_pix_format));
f->fmt.pix.width = vopen->width;
f->fmt.pix.height = vopen->height;
f->fmt.pix.field = vopen->vbuf_q.field;
f->fmt.pix.pixelformat = vopen->fmt->fourcc;
f->fmt.pix.bytesperline = (f->fmt.pix.width * 16) >> 3;
f->fmt.pix.sizeimage =
f->fmt.pix.height * f->fmt.pix.bytesperline;
return 0;
case V4L2_BUF_TYPE_VIDEO_OVERLAY:
memset(&f->fmt.win, 0, sizeof(struct v4l2_window));
return 0;
f->fmt.win.w = vopen->ov.w;
f->fmt.win.field = vopen->ov.field;
return 0;
case V4L2_BUF_TYPE_VBI_CAPTURE:
return -EINVAL;
default:
return -EINVAL;
}
}
static int ngene_switch_type(struct ngene_vopen *vopen, enum v4l2_buf_type type)
{
struct videobuf_queue *q = ngene_queue(vopen);
int res = ngene_resource(vopen);
if (check_res(vopen, res))
return -EBUSY;
if (videobuf_queue_is_busy(q))
return -EBUSY;
vopen->type = type;
return 0;
}
static int ngene_s_fmt(struct ngene_vopen *vopen, struct ngene_channel *chan,
struct v4l2_format *f)
{
int retval;
switch (f->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE:
{
const struct ngene_format *fmt;
retval = ngene_try_fmt(vopen, chan, f);
if (0 != retval)
return retval;
retval = ngene_switch_type(vopen, f->type);
if (0 != retval)
return retval;
fmt = ngene_formats;
if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV)
return -EINVAL;
/* update our state informations */
mutex_lock(&vopen->vbuf_q.lock);
vopen->fmt = fmt;
vopen->vbuf_q.field = f->fmt.pix.field;
vopen->vbuf_q.last = V4L2_FIELD_INTERLACED;
vopen->width = f->fmt.pix.width;
vopen->height = f->fmt.pix.height;
chan->init.fmt = fmt;
chan->init.width = f->fmt.pix.width;
chan->init.height = f->fmt.pix.height;
mutex_unlock(&vopen->vbuf_q.lock);
return 0;
}
case V4L2_BUF_TYPE_VIDEO_OVERLAY:
return -EINVAL;
case V4L2_BUF_TYPE_VBI_CAPTURE:
return -EINVAL;
default:
return -EINVAL;
}
}
/****************************************************************************/
/* SG support ***************************************************************/
/****************************************************************************/
static inline enum km_type ngene_kmap_type(int out)
{
return ngene_km_types[(in_softirq() ? 2 : 0) + out];
}
static inline void *ngene_kmap(struct page *page, int out)
{
return kmap_atomic(page, ngene_kmap_type(out));
}
static inline void ngene_kunmap(void *vaddr, int out)
{
kunmap_atomic(vaddr, ngene_kmap_type(out));
}
struct scatter_walk {
struct scatterlist *sg;
struct page *page;
void *data;
unsigned int len_this_page;
unsigned int len_this_segment;
unsigned int offset;
};
static inline struct scatterlist *sg_next(struct scatterlist *sg)
{
return sg + 1;
}
void *scatterwalk_whichbuf(struct scatter_walk *walk, unsigned int nbytes)
{
if (nbytes <= walk->len_this_page &&
(((unsigned long)walk->data) &
(PAGE_CACHE_SIZE - 1)) + nbytes <= PAGE_CACHE_SIZE)
return walk->data;
else
return walk->data;
}
void scatterwalk_start(struct scatter_walk *walk, struct scatterlist *sg)
{
unsigned int rest_of_page;
walk->sg = sg;
walk->page = sg->page;
walk->len_this_segment = sg->length;
rest_of_page = PAGE_CACHE_SIZE - (sg->offset & (PAGE_CACHE_SIZE - 1));
walk->len_this_page = min(sg->length, rest_of_page);
walk->offset = sg->offset;
}
void scatterwalk_map(struct scatter_walk *walk, int out)
{
walk->data = ngene_kmap(walk->page, out) + walk->offset;
}
static void scatterwalk_pagedone(struct scatter_walk *walk, int out,
unsigned int more)
{
/* walk->data may be pointing the first byte of the next page;
however, we know we transfered at least one byte. So,
walk->data - 1 will be a virtual address in the mapped page. */
if (out)
flush_dcache_page(walk->page);
if (more) {
walk->len_this_segment -= walk->len_this_page;
if (walk->len_this_segment) {
walk->page++;
walk->len_this_page = min(walk->len_this_segment,
(unsigned)PAGE_CACHE_SIZE);
walk->offset = 0;
} else {
scatterwalk_start(walk, sg_next(walk->sg));
}
}
}
void scatterwalk_done(struct scatter_walk *walk, int out, int more)
{
ngene_kunmap(walk->data, out);
if (walk->len_this_page == 0 || !more)
scatterwalk_pagedone(walk, out, more);
}
/*
* Do not call this unless the total length of all of the fragments
* has been verified as multiple of the block size.
*/
int scatterwalk_copychunks(struct scatter_walk *walk, size_t nbytes, int out)
{
walk->offset += nbytes;
walk->len_this_page -= nbytes;
walk->len_this_segment -= nbytes;
return 0;
}
static void *vid_exchange(void *priv, void *buf, u32 len, u32 clock, u32 flags)
{
struct ngene_channel *chan = priv;
struct ngene_buffer *item;
int wstrich, hstrich;
u8 *odd, *even;
u32 bpl = chan->tvnorms[chan->tvnorm].swidth * 2;
struct scatter_walk walk_out;
const unsigned int bsize = PAGE_SIZE;
unsigned int nbytes;
int rest_of_buffer, ah, rwstrich;
spin_lock(&chan->s_lock);
if (list_empty(&chan->capture)) {
chan->evenbuffer = NULL;
goto out;
}
item = list_entry(chan->capture.next, struct ngene_buffer, vb.queue);
if (chan->tvnorms[chan->tvnorm].sheight == 1080)
buf += 3840;
odd = buf;
hstrich = item->vb.height;
if (hstrich > chan->tvnorms[chan->tvnorm].sheight)
hstrich = chan->tvnorms[chan->tvnorm].sheight;
wstrich = item->vb.width;
if (wstrich > chan->tvnorms[chan->tvnorm].swidth)
wstrich = chan->tvnorms[chan->tvnorm].swidth;
wstrich <<= 1;
if (flags & BEF_EVEN_FIELD) {
chan->evenbuffer = buf;
if (chan->lastbufferflag) {
chan->lastbufferflag = 0;
if (chan->tvnorms[chan->tvnorm].sheight == 576) {
memcpy(buf + 413280, BlackLine, 1440);
memcpy(buf + 411840, BlackLine, 1440);
}
goto out;
}
}
chan->lastbufferflag = 1;
if (chan->evenbuffer)
even = chan->evenbuffer;
else
even = odd;
if (chan->tvnorms[chan->tvnorm].sheight == 576) {
memcpy(odd + 413280, BlackLine, 1440);
memcpy(odd + 411840, BlackLine, 1440);
}
nbytes = item->vb.dma.sglen * PAGE_SIZE;
scatterwalk_start(&walk_out, item->vb.dma.sglist);
ah = 0;
rwstrich = wstrich;
do {
u8 *dst_p;
rest_of_buffer = bsize;
scatterwalk_map(&walk_out, 1);
dst_p = scatterwalk_whichbuf(&walk_out, bsize);
nbytes -= bsize;
scatterwalk_copychunks(&walk_out, bsize, 1);
while (rest_of_buffer > 0 && ah < hstrich) {
if (rest_of_buffer >= rwstrich) {
if (ah % 2 == 0) {
memcpy(walk_out.data +
(bsize - rest_of_buffer),
odd, rwstrich);
odd += bpl - (wstrich - rwstrich);
} else {
memcpy(walk_out.data +
(bsize - rest_of_buffer),
even, rwstrich);
even += bpl - (wstrich - rwstrich);
}
rest_of_buffer -= rwstrich;
ah++;
rwstrich = wstrich;
} else {
if (ah % 2 == 0) {
memcpy(walk_out.data +
(bsize - rest_of_buffer),
odd, rest_of_buffer);
odd += rest_of_buffer;
} else {
memcpy(walk_out.data +
(bsize - rest_of_buffer),
even, rest_of_buffer);
even += rest_of_buffer;
}
rwstrich -= rest_of_buffer;
rest_of_buffer = 0;
}
}
scatterwalk_done(&walk_out, 1, nbytes);
} while (nbytes && ah < hstrich);
{
struct timeval ts;
do_gettimeofday(&ts);
list_del(&item->vb.queue);
item->vb.state = STATE_DONE;
item->vb.ts = ts;
wake_up(&item->vb.done);
chan->evenbuffer = NULL;
}
out:
spin_unlock(&chan->s_lock);
return 0;
}
static void *snd_exchange(void *priv, void *buf, u32 len, u32 clock, u32 flags)
{
struct ngene_channel *chan = priv;
struct mychip *mychip = chan->mychip;
if (chan->audiomute == 0)
memcpy(chan->soundbuffer, (u8 *) buf, MAX_AUDIO_BUFFER_SIZE);
else
memset(chan->soundbuffer, 0, MAX_AUDIO_BUFFER_SIZE);
if (mychip->substream != NULL) {
if (chan->sndbuffflag == 0)
chan->sndbuffflag = 1;
else
chan->sndbuffflag = 0;
spin_unlock(&mychip->lock);
snd_pcm_period_elapsed(mychip->substream);
spin_lock(&mychip->lock);
}
return 0;
}
static void set_analog_transfer(struct ngene_channel *chan, int state)
{
struct ngene_channel *ch;
u8 flags = 0;
ch = &chan->dev->channel[chan->number + 2];
/* printk(KERN_INFO "set_analog_transfer %d\n", state); */
if (1) { /* chan->tun_dec_rdy == 1){ */
if (state) {
chan->Capture1Length =
chan->tvnorms[chan->tvnorm].swidth *
chan->tvnorms[chan->tvnorm].sheight;
if (chan->tvnorms[chan->tvnorm].sheight == 576)
chan->nLines = 287;
else if (chan->tvnorms[chan->tvnorm].sheight == 1080)
chan->nLines = 541;
else
chan->nLines =
chan->tvnorms[chan->tvnorm].sheight / 2;
chan->nBytesPerLine =
chan->tvnorms[chan->tvnorm].swidth * 2;
if (chan->dev->card_info->io_type[chan->number] ==
NGENE_IO_HDTV) {
chan->itumode = 2;
flags = SFLAG_ORDER_LUMA_CHROMA;
} else {
chan->itumode = 0;
flags = SFLAG_ORDER_LUMA_CHROMA;
}
chan->pBufferExchange = vid_exchange;
ngene_command_stream_control(chan->dev, chan->number,
0x80,
SMODE_VIDEO_CAPTURE,
flags);
ch->Capture1Length = MAX_AUDIO_BUFFER_SIZE;
ch->pBufferExchange = snd_exchange;
ngene_command_stream_control(ch->dev, ch->number,
0x80,
SMODE_AUDIO_CAPTURE, 0);
ch->soundstreamon = 1;
} else {
ngene_command_stream_control(chan->dev, chan->number,
0, 0, 0);
ngene_command_stream_control(ch->dev, ch->number,
0, 0, 0);
ch->soundstreamon = 0;
}
}
}
static int ngene_analog_start_feed(struct ngene_channel *chan)
{
int freerunmode = 1;
struct i2c_adapter *adapter = &chan->i2c_adapter;
if (chan->users == 0 && chan->number < 2) {
chan->evenbuffer = NULL;
chan->users = 1;
i2c_clients_command(adapter, IOCTL_MIC_DEC_FREESYNC,
&freerunmode);
msleep(25);
set_analog_transfer(chan, 1);
msleep(25);
freerunmode = 0;
i2c_clients_command(adapter, IOCTL_MIC_DEC_FREESYNC,
&freerunmode);
}
return chan->users;
}
static int ngene_analog_stop_feed(struct ngene_channel *chan)
{
int freerunmode = 1;
struct i2c_adapter *adapter = &chan->i2c_adapter;
if (chan->users == 1 && chan->number < 2) {
chan->users = 0;
i2c_clients_command(adapter,
IOCTL_MIC_DEC_FREESYNC, &freerunmode);
msleep(20);
set_analog_transfer(chan, 0);
}
return 0;
}
/****************************************************************************/
/* V4L2 API interface *******************************************************/
/****************************************************************************/
void ngene_dma_free(struct videobuf_queue *q,
struct ngene_channel *chan, struct ngene_buffer *buf)
{
videobuf_waiton(&buf->vb, 0, 0);
videobuf_dma_unmap(q, &buf->vb.dma);
videobuf_dma_free(&buf->vb.dma);
buf->vb.state = STATE_NEEDS_INIT;
}
static int ngene_prepare_buffer(struct videobuf_queue *q,
struct ngene_channel *chan,
struct ngene_buffer *buf,
const struct ngene_format *fmt,
unsigned int width, unsigned int height,
enum v4l2_field field)
{
int rc = 0;
/* check settings */
if (NULL == fmt)
return -EINVAL;
if (width < 48 || height < 32)
return -EINVAL;
buf->vb.size = (width * height * 16 /* fmt->depth */) >> 3;
if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
return -EINVAL;
/* alloc + fill struct ngene_buffer (if changed) */
if (buf->vb.width != width || buf->vb.height != height ||
buf->vb.field != field || buf->fmt != fmt ||
buf->tvnorm != chan->tvnorm) {
buf->vb.width = width;
buf->vb.height = height;
buf->vb.field = field;
buf->tvnorm = chan->tvnorm;
buf->fmt = fmt;
ngene_dma_free(q, chan, buf);
}
if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
return -EINVAL;
if (buf->vb.field == 0)
buf->vb.field = V4L2_FIELD_INTERLACED;
if (STATE_NEEDS_INIT == buf->vb.state) {
buf->vb.width = width;
buf->vb.height = height;
buf->vb.field = field;
buf->tvnorm = chan->tvnorm;
buf->fmt = fmt;
rc = videobuf_iolock(q, &buf->vb, &chan->fbuf);
if (0 != rc)
goto fail;
}
if (!buf->vb.dma.bus_addr)
videobuf_dma_sync(q, &buf->vb.dma);
buf->vb.state = STATE_PREPARED;
return 0;
fail:
ngene_dma_free(q, chan, buf);
return rc;
}
static int buffer_setup(struct videobuf_queue *q,
unsigned int *count, unsigned int *size)
{
struct ngene_vopen *vopen = q->priv_data;
*size = 2 * vopen->width * vopen->height;
if (0 == *count)
*count = gbuffers;
while (*size * *count > gbuffers * gbufsize)
(*count)--;
q->field = V4L2_FIELD_INTERLACED;
q->last = V4L2_FIELD_INTERLACED;
return 0;
}
static int buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
enum v4l2_field field)
{
struct ngene_buffer *buf = container_of(vb, struct ngene_buffer, vb);
struct ngene_vopen *vopen = q->priv_data;
return ngene_prepare_buffer(q, vopen->ch, buf, vopen->fmt,
vopen->width, vopen->height, field);
}
static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
{
struct ngene_buffer *buf = container_of(vb, struct ngene_buffer, vb);
struct ngene_vopen *vopen = q->priv_data;
ngene_dma_free(q, vopen->ch, buf);
}
static void buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
{
struct ngene_buffer *buf = container_of(vb, struct ngene_buffer, vb);
struct ngene_vopen *vopen = q->priv_data;
struct ngene_channel *chan = vopen->ch;
buf->vb.state = STATE_QUEUED;
list_add_tail(&buf->vb.queue, &chan->capture);
}
static struct videobuf_queue_ops ngene_video_qops = {
.buf_setup = buffer_setup,
.buf_prepare = buffer_prepare,
.buf_queue = buffer_queue,
.buf_release = buffer_release,
};
int video_open(struct inode *inode, struct file *flip)
{
struct ngene_vopen *vopen = NULL;
enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
struct video_device *vd = video_devdata(flip);
struct ngene_channel *chan = my_video_get_drvdata(vd);
vopen = kmalloc(sizeof(*vopen), GFP_KERNEL);
if (!vopen)
return -ENOMEM;
memset(vopen, 0, sizeof(*vopen));
flip->private_data = vopen;
v4l2_prio_open(&chan->prio, &vopen->prio);
vopen->ch = chan;
vopen->picxcount = 0;
vopen->type = type;
videobuf_queue_init(&vopen->vbuf_q, &ngene_video_qops,
chan->dev->pci_dev, &chan->s_lock,
V4L2_BUF_TYPE_VIDEO_CAPTURE,
V4L2_FIELD_INTERLACED,
sizeof(struct ngene_buffer), vopen);
vopen->ovfmt = ngene_formats;
chan->videousers++;
if (chan->dev->card_info->switch_ctrl)
chan->dev->card_info->switch_ctrl(chan, 2, 1);
return 0;
}
int video_close(struct inode *inode, struct file *filp)
{
struct ngene_vopen *vopen = filp->private_data;
struct ngene_channel *chan = vopen->ch;
chan->videousers--;
if (!chan->videousers) {
if (chan->dev->card_info->switch_ctrl)
chan->dev->card_info->switch_ctrl(chan, 2, 0);
ngene_analog_stop_feed(chan);
}
videobuf_mmap_free(&vopen->vbuf_q);
v4l2_prio_close(&chan->prio, &vopen->prio);
filp->private_data = NULL;
kfree(vopen);
return 0;
}
/****************************************************************************/
static int vid_do_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, void *parg)
{
struct ngene_vopen *vopen = file->private_data;
struct ngene_channel *chan = vopen->ch;
struct ngene *dev = chan->dev;
struct i2c_adapter *adap = &chan->i2c_adapter;
int retval = 0;
int err = 0;
switch (cmd) {
case VIDIOC_S_CTRL:
{
struct v4l2_control *c = parg;
err = v4l2_prio_check(&chan->prio, &vopen->prio);
if (err)
return err;
if (c->id == V4L2_CID_AUDIO_MUTE) {
if (c->value)
(dev->channel[chan->number + 2]).audiomute = 1;
else
(dev->channel[chan->number + 2]).audiomute = 0;
return 0;
}
if (c->value != V4L2_CID_AUDIO_MUTE)
ngene_analog_stop_feed(chan);
i2c_clients_command(adap, cmd, parg);
return 0;
}
case VIDIOC_S_TUNER:
{
err = v4l2_prio_check(&chan->prio, &vopen->prio);
if (err != 0)
return err;
i2c_clients_command(adap, cmd, parg);
return 0;
}
case VIDIOC_S_FREQUENCY:
{
struct v4l2_frequency *f = parg;
u8 drxa = dev->card_info->demoda[chan->number];
if (chan->fe && chan->fe->ops.tuner_ops.set_frequency)
chan->fe->ops.tuner_ops.
set_frequency(chan->fe, f->frequency * 62500);
if (drxa)
;
}
case VIDIOC_S_INPUT:
{
err = v4l2_prio_check(&chan->prio, &vopen->prio);
if (err != 0)
return err;
i2c_clients_command(adap, cmd, parg);
return 0;
}
case VIDIOC_G_STD:
{
v4l2_std_id *id = parg;
*id = chan->tvnorms[chan->tvnorm].v4l2_id;
return 0;
}
case VIDIOC_S_STD:
{
v4l2_std_id *id = parg;
unsigned int i;
err = v4l2_prio_check(&chan->prio, &vopen->prio);
if (err != 0)
return err;
ngene_analog_stop_feed(chan);
i2c_clients_command(adap, cmd, parg);
for (i = 0; i < chan->tvnorm_num; i++)
if (*id & chan->tvnorms[i].v4l2_id)
break;
if (i == chan->tvnorm_num)
return -EINVAL;
chan->tvnorm = i;
mdelay(50);
ngene_analog_start_feed(chan);
return 0;
}
case VIDIOC_G_FREQUENCY:
case VIDIOC_G_INPUT:
case VIDIOC_S_AUDIO:
case VIDIOC_G_AUDIO:
case VIDIOC_ENUMAUDIO:
case VIDIOC_S_MODULATOR:
case VIDIOC_G_MODULATOR:
case VIDIOC_G_CTRL:
{
i2c_clients_command(adap, cmd, parg);
return 0;
}
case VIDIOC_G_TUNER:
{
struct v4l2_tuner *tuner = parg;
if (tuner->index != 0)
return -EINVAL;
i2c_clients_command(adap, cmd, parg);
if (chan->fe && chan->fe->ops.tuner_ops.get_status) {
u32 status;
chan->fe->ops.tuner_ops.get_status(chan->fe, &status);
tuner->signal = status;
}
return 0;
}
case VIDIOC_QUERYCTRL:
{
struct v4l2_queryctrl *c = parg;
int i;
if ((c->id < V4L2_CID_BASE ||
c->id >= V4L2_CID_LASTP1) &&
(c->id < V4L2_CID_PRIVATE_BASE ||
c->id >= V4L2_CID_PRIVATE_LASTP1))
return -EINVAL;
for (i = 0; i < NGENE_CTLS; i++)
if (ngene_ctls[i].id == c->id)
break;
if (i == NGENE_CTLS) {
*c = no_ctl;
return 0;
}
*c = ngene_ctls[i];
return 0;
}
case VIDIOC_G_FMT:
{
struct v4l2_format *f = parg;
ngene_g_fmt(vopen, f);
}
case VIDIOC_S_FMT:
{
struct v4l2_format *f = parg;
ngene_analog_stop_feed(chan);
return ngene_s_fmt(vopen, chan, f);
}
case VIDIOC_ENUM_FMT:
{
struct v4l2_fmtdesc *f = parg;
enum v4l2_buf_type type;
unsigned int i;
int index;
type = f->type;
if (V4L2_BUF_TYPE_VBI_CAPTURE == type) {
/* vbi
index = f->index;
if (0 != index)
return -EINVAL;
memset(f, 0, sizeof(*f));
f->index = index;
f->type = type;
f->pixelformat = V4L2_PIX_FMT_GREY;
strcpy(f->description, "vbi data"); */
return EINVAL;
}
/* video capture + overlay */
index = -1;
for (i = 0; i < NGENE_FORMATS; i++) {
if (ngene_formats[i].fourcc != -1)
index++;
if ((unsigned int)index == f->index)
break;
}
if (NGENE_FORMATS == i)
return -EINVAL;
switch (f->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE:
break;
case V4L2_BUF_TYPE_VIDEO_OVERLAY:
/* dprintk(KERN_DEBUG
"Video Overlay not supported yet.\n"); */
return -EINVAL;
break;
default:
return -EINVAL;
}
memset(f, 0, sizeof(*f));
f->index = index;
f->type = type;
f->pixelformat = ngene_formats[i].fourcc;
strlcpy(f->description, ngene_formats[i].name,
sizeof(f->description));
return 0;
}
case VIDIOC_QUERYSTD:
{
v4l2_std_id *id = parg;
*id = V4L2_STD_625_50 | V4L2_STD_525_60;
return 0;
}
case VIDIOC_ENUMSTD:
{
struct v4l2_standard *e = parg;
unsigned int index = e->index;
if (index >= chan->tvnorm_num)
return -EINVAL;
v4l2_video_std_construct(e, chan->tvnorms[e->index].v4l2_id,
chan->tvnorms[e->index].name);
e->index = index;
return 0;
}
case VIDIOC_QUERYCAP:
{
static char driver[] = {'n', 'G', 'e', 'n', 'e', '\0'};
static char card[] = {'M', 'k', '4', 'x', 'x', '\0'};
struct v4l2_capability *cap = parg;
memset(cap, 0, sizeof(*cap));
if (dev->nr == 0)
card[3] = '0';
else
card[3] = '1';
if (chan->number)
card[4] = 'a';
else
card[4] = 'b';
strlcpy(cap->driver, driver, sizeof(cap->driver));
strlcpy(cap->card, card, sizeof(cap->card));
cap->bus_info[0] = 0;
cap->version = KERNEL_VERSION(0, 8, 1);
cap->capabilities = V4L2_CAP_VIDEO_CAPTURE|
V4L2_CAP_TUNER|V4L2_CAP_AUDIO|
V4L2_CAP_READWRITE|V4L2_CAP_STREAMING;
return 0;
}
case VIDIOC_ENUMINPUT:
{
static char *inputname[2] = {
"AnalogTuner",
"S-Video"
};
struct v4l2_input *i = parg;
unsigned int index;
index = i->index;
if (index > 1)
return -EINVAL;
memset(i, 0, sizeof(*i));
i->index = index;
strlcpy(i->name, inputname[index], sizeof(i->name));
i->type = index ? V4L2_INPUT_TYPE_CAMERA :
V4L2_INPUT_TYPE_TUNER;
i->audioset = 0;
i->tuner = 0;
i->std = V4L2_STD_PAL_BG | V4L2_STD_NTSC_M;
i->status = 0;/* V4L2_IN_ST_NO_H_LOCK; */
return 0;
}
case VIDIOC_G_PARM:
return -EINVAL;
case VIDIOC_S_PARM:
return -EINVAL;
case VIDIOC_G_PRIORITY:
{
enum v4l2_priority *prio = parg;
*prio = v4l2_prio_max(&chan->prio);
return 0;
}
case VIDIOC_S_PRIORITY:
{
enum v4l2_priority *prio = parg;
return v4l2_prio_change(&chan->prio, &vopen->prio, *prio);
return 0;
}
case VIDIOC_CROPCAP:
return -EINVAL;
case VIDIOC_G_CROP:
return -EINVAL;
case VIDIOC_S_CROP:
return -EINVAL;
case VIDIOC_G_FBUF:
{
struct v4l2_framebuffer *fb = parg;
*fb = chan->fbuf;
fb->capability = 0;
if (vopen->ovfmt)
fb->fmt.pixelformat = vopen->ovfmt->fourcc;
return 0;
}
case VIDIOC_REQBUFS:
return videobuf_reqbufs(ngene_queue(vopen), parg);
case VIDIOC_QUERYBUF:
return videobuf_querybuf(ngene_queue(vopen), parg);
case VIDIOC_QBUF:
return videobuf_qbuf(ngene_queue(vopen), parg);
case VIDIOC_DQBUF:
return videobuf_dqbuf(ngene_queue(vopen), parg,
file->f_flags & O_NONBLOCK);
case VIDIOC_S_FBUF:
{
/* ngene_analog_stop_feed(chan); */
struct v4l2_framebuffer *fb = parg;
const struct ngene_format *fmt;
if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RAWIO))
return -EPERM;
/* check args */
fmt = ngene_formats; /*format_by_fourcc(fb->fmt.pixelformat);*/
if (NULL == fmt)
return -EINVAL;
if (0 == (fmt->flags & 0x02 /*FORMAT_FLAGS_PACKED*/))
return -EINVAL;
mutex_lock(&vopen->vbuf_q.lock);
retval = -EINVAL;
if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
int maxLinesPerField;
if (fb->fmt.width >
chan->tvnorms[chan->tvnorm].swidth)
goto vopen_unlock_and_return;
maxLinesPerField = chan->tvnorms[chan->tvnorm].sheight;
if (fb->fmt.height > maxLinesPerField)
goto vopen_unlock_and_return;
}
/* ok, accept it */
chan->fbuf.base = fb->base;
chan->fbuf.fmt.width = fb->fmt.width;
chan->fbuf.fmt.height = fb->fmt.height;
if (0 != fb->fmt.bytesperline)
chan->fbuf.fmt.bytesperline = fb->fmt.bytesperline;
else
chan->fbuf.fmt.bytesperline =
chan->fbuf.fmt.width * fmt->depth / 8;
retval = 0;
vopen->ovfmt = fmt;
chan->init.ovfmt = fmt;
vopen_unlock_and_return:
mutex_unlock(&vopen->vbuf_q.lock);
return retval;
}
case VIDIOC_ENUMOUTPUT:
return -EINVAL;
case VIDIOC_TRY_FMT:
{
struct v4l2_format *f = parg;
return ngene_try_fmt(vopen, chan, f);
}
case VIDIOC_STREAMON:
{
int res = ngene_resource(vopen);
if (!check_alloc_res(chan, vopen, res))
return -EBUSY;
ngene_analog_start_feed(chan);
return videobuf_streamon(ngene_queue(vopen));
}
case VIDIOC_STREAMOFF:
{
int res = ngene_resource(vopen);
int retval = videobuf_streamoff(ngene_queue(vopen));
ngene_analog_stop_feed(chan);
if (retval < 0)
return retval;
free_res(chan, vopen, res);
return 0;
}
case VIDIOC_OVERLAY:
return -EINVAL;
case VIDIOCGFBUF:
{
struct video_buffer *vb = parg;
memset(vb, 0, sizeof(*vb));
return 0;
}
default:
err = -EINVAL;
break;
}
return err;
}
/*
static int vid_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg)
{
return video_usercopy(inode, file, cmd, arg, vid_do_ioctl);
}
*/
static unsigned int video_fix_command(unsigned int cmd)
{
switch (cmd) {
}
return cmd;
}
static int vid_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg)
{
void *parg = (void *)arg, *pbuf = NULL;
char buf[64];
int res = -EFAULT;
cmd = video_fix_command(cmd);
if (_IOC_DIR(cmd) & _IOC_WRITE) {
parg = buf;
if (_IOC_SIZE(cmd) > sizeof(buf)) {
pbuf = kmalloc(_IOC_SIZE(cmd), GFP_KERNEL);
if (!pbuf)
return -ENOMEM;
parg = pbuf;
}
if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))
goto error;
}
res = vid_do_ioctl(inode, file, cmd, parg);
if (res < 0)
goto error;
if (_IOC_DIR(cmd) & _IOC_READ)
if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
res = -EFAULT;
error:
kfree(pbuf);
return res;
}
static int ngene_mmap(struct file *file, struct vm_area_struct *vma)
{
struct ngene_vopen *vopen = file->private_data;
return videobuf_mmap_mapper(ngene_queue(vopen), vma);
}
#define MAGIC_BUFFER 0x20040302
void *my_videobuf_alloc(unsigned int size)
{
struct videobuf_buffer *vb;
vb = kmalloc(size, GFP_KERNEL);
if (NULL != vb) {
memset(vb, 0, size);
videobuf_dma_init(&vb->dma);
init_waitqueue_head(&vb->done);
vb->magic = MAGIC_BUFFER;
}
return vb;
}
static ssize_t driver_read(struct file *file, char *user,
size_t count, loff_t *offset)
{
char __user *data = user;
struct ngene_channel *chan;
int retval = 0;
struct videobuf_queue *q;
struct ngene_vopen *vopen = file->private_data;
int nonblocking = file->f_flags & O_NONBLOCK;
enum v4l2_field field;
unsigned long flags;
unsigned size, nbufs, bytes;
if (!vopen)
return 0;
chan = vopen->ch;
q = &vopen->vbuf_q;
mutex_lock(&q->lock);
nbufs = 1;
size = 0;
q->ops->buf_setup(q, &nbufs, &size);
if (NULL == q->read_buf) {
/* need to capture a new frame */
retval = -ENOMEM;
q->read_buf = my_videobuf_alloc(q->msize);
if (NULL == q->read_buf)
goto done;
q->read_buf->memory = V4L2_MEMORY_USERPTR;
field = V4L2_FIELD_INTERLACED;
retval = q->ops->buf_prepare(q, q->read_buf, field);
if (0 != retval) {
kfree(q->read_buf);
q->read_buf = NULL;
goto done;
}
spin_lock_irqsave(q->irqlock, flags);
q->ops->buf_queue(q, q->read_buf);
spin_unlock_irqrestore(q->irqlock, flags);
q->read_off = 0;
}
ngene_analog_start_feed(chan);
/* wait until capture is done */
retval = videobuf_waiton(q->read_buf, nonblocking, 1);
if (0 != retval)
goto done;
videobuf_dma_sync(q, &q->read_buf->dma);
if (STATE_ERROR == q->read_buf->state) {
/* catch I/O errors */
q->ops->buf_release(q, q->read_buf);
kfree(q->read_buf);
q->read_buf = NULL;
retval = -EIO;
goto done;
}
/* copy to userspace */
bytes = count;
if (bytes > q->read_buf->size - q->read_off)
bytes = q->read_buf->size - q->read_off;
retval = -EFAULT;
if (copy_to_user(data, q->read_buf->dma.vmalloc + q->read_off, bytes))
goto done;
retval = bytes;
q->read_off += bytes;
if (q->read_off == q->read_buf->size) {
/* all data copied, cleanup */
q->ops->buf_release(q, q->read_buf);
kfree(q->read_buf);
q->read_buf = NULL;
}
done:
mutex_unlock(&q->lock);
ngene_analog_stop_feed(chan);
return retval;
}
static unsigned int ngene_poll(struct file *file, poll_table *wait)
{
struct ngene_vopen *vopen = file->private_data;
struct ngene_buffer *buf;
enum v4l2_field field;
if (check_res(vopen, RESOURCE_VIDEO)) {
/* streaming capture */
if (list_empty(&vopen->vbuf_q.stream))
return POLLERR;
buf = list_entry(vopen->vbuf_q.stream.next,
struct ngene_buffer, vb.stream);
} else {
/* read() capture */
mutex_lock(&vopen->vbuf_q.lock);
if (NULL == vopen->vbuf_q.read_buf) {
/* need to capture a new frame */
if (locked_res(vopen->ch, RESOURCE_VIDEO)) {
mutex_unlock(&vopen->vbuf_q.lock);
return POLLERR;
}
vopen->vbuf_q.read_buf =
videobuf_alloc(vopen->vbuf_q.msize);
if (NULL == vopen->vbuf_q.read_buf) {
mutex_unlock(&vopen->vbuf_q.lock);
return POLLERR;
}
vopen->vbuf_q.read_buf->memory = V4L2_MEMORY_USERPTR;
field = videobuf_next_field(&vopen->vbuf_q);
if (0 !=
vopen->vbuf_q.ops->
buf_prepare(&vopen->vbuf_q,
vopen->vbuf_q.read_buf, field)) {
mutex_unlock(&vopen->vbuf_q.lock);
return POLLERR;
}
vopen->vbuf_q.ops->buf_queue(&vopen->vbuf_q,
vopen->vbuf_q.read_buf);
vopen->vbuf_q.read_off = 0;
}
mutex_unlock(&vopen->vbuf_q.lock);
buf = (struct ngene_buffer *)vopen->vbuf_q.read_buf;
}
poll_wait(file, &buf->vb.done, wait);
if (buf->vb.state == STATE_DONE || buf->vb.state == STATE_ERROR)
return POLLIN | POLLRDNORM;
return 0;
}
static const struct file_operations ngene_fops = {
.owner = THIS_MODULE,
.read = driver_read,
.write = 0,
.open = video_open,
.release = video_close,
.ioctl = vid_ioctl,
.poll = ngene_poll,
.mmap = ngene_mmap,
};
static struct video_device ngene_cinfo = {
.name = "analog_Ngene",
.type = VID_TYPE_CAPTURE | VID_TYPE_TUNER | VID_TYPE_SCALES,
.fops = &ngene_fops,
.minor = -1,
};
void ngene_v4l2_remove(struct ngene_channel *chan)
{
video_unregister_device(chan->v4l_dev);
}
int ngene_v4l2_init(struct ngene_channel *chan)
{
int ret = 0;
struct video_device *v_dev;
chan->evenbuffer = NULL;
chan->dma_on = 0;
v_dev = video_device_alloc();
*v_dev = ngene_cinfo;
/* v_dev->dev = &(chan->dev->pci_dev->dev); */
v_dev->release = video_device_release;
v_dev->minor = -1;
video_register_device(v_dev, VFL_TYPE_GRABBER, -1);
snprintf(v_dev->name, sizeof(v_dev->name), "AnalognGene%d",
v_dev->minor);
chan->v4l_dev = v_dev;
chan->minor = v_dev->minor;
printk(KERN_INFO "nGene V4L2 device video%d registered.\n",
v_dev->minor);
v_dev->dev = &chan->device;
my_video_set_drvdata(chan->v4l_dev, chan);
v4l2_prio_init(&chan->prio);
if (chan->dev->card_info->io_type[chan->number] == NGENE_IO_HDTV) {
chan->tvnorms = ngene_tvnorms_hd;
chan->tvnorm_num = 1;
} else {
chan->tvnorms = ngene_tvnorms_sd;
chan->tvnorm_num = NGENE_TVNORMS;
}
chan->tvnorm = 0;
spin_lock_init(&chan->s_lock);
init_MUTEX(&chan->reslock);
INIT_LIST_HEAD(&chan->capture);
chan->users = 0;
chan->videousers = 0;
chan->init.ov.w.width = 384;
chan->init.ov.w.height = 288;
chan->init.fmt = ngene_formats;
chan->init.width = 384;
chan->init.height = 288;
chan->tun_rdy = 0;
chan->dec_rdy = 0;
chan->tun_dec_rdy = 0;
chan->lastbufferflag = -1;
if (chan->dev->card_info->avf[chan->number])
avf4910a_attach(&chan->i2c_adapter,
chan->dev->card_info->avf[chan->number]);
return ret;
}
drivers/media/dvb/ngene/ngene.h
View file @ 9fdd7976
......@@ -857,17 +857,6 @@ struct ngene_buffer {
};
#endif
int ngene_command_stream_control(struct ngene *dev,
u8 stream, u8 control, u8 mode, u8 flags);
int ngene_command_nop(struct ngene *dev);
int ngene_command_i2c_read(struct ngene *dev, u8 adr,
u8 *out, u8 outlen, u8 *in, u8 inlen, int flag);
int ngene_command_i2c_write(struct ngene *dev, u8 adr, u8 *out, u8 outlen);
int ngene_command_imem_read(struct ngene *dev, u8 adr, u8 *data, int type);
int ngene_command_imem_write(struct ngene *dev, u8 adr, u8 data, int type);
int ngene_stream_control(struct ngene *dev, u8 stream, u8 control, u8 mode,
u16 lines, u16 bpl, u16 vblines, u16 vbibpl);
#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