#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);
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;
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;
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)
{
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.
}
}
-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;
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 **********************************************************************/
}
-
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,
};
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 ******************************************/
{
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);
{
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;
-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 *),
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;
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)
{
}
}
-void free_common_buffers(struct ngene *dev)
+static void free_common_buffers(struct ngene *dev)
{
u32 i;
struct ngene_channel *chan;
/* 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;
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] =
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);
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);
if (chan->number == 0 || !one_adapter)
dvb_unregister_adapter(&dev->adapter[chan->number]);
}
-
}
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",
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) {
nr);
}
}
-
return ret;
}
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)
+++ /dev/null
-/*
- * 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;
-}
projects / openwrt / staging / blogic.git / commitdiff