V4L/DVB: ngene: Code cleanup
authorOliver Endriss <o.endriss@gmx.de>
Wed, 23 Dec 2009 19:26:17 +0000 (16:26 -0300)
committerMauro Carvalho Chehab <mchehab@redhat.com>
Fri, 26 Feb 2010 18:10:54 +0000 (15:10 -0300)
Remove/comment-out unused code, make some functions/declarations static.

Signed-off-by: Oliver Endriss <o.endriss@gmx.de>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
drivers/media/dvb/ngene/ngene-core.c
drivers/media/dvb/ngene/ngene-ioctls.h [deleted file]
drivers/media/dvb/ngene/ngene-snd.c [deleted file]
drivers/media/dvb/ngene/ngene-v4l2.c [deleted file]
drivers/media/dvb/ngene/ngene.h

index 907a5032784e6ea94b8f14597b7ee8e48952f458..6f1b06618147dd90defb95ac093289f98cb19e38 100644 (file)
 #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 @@ done:
 }
 
 
-
 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)
diff --git a/drivers/media/dvb/ngene/ngene-ioctls.h b/drivers/media/dvb/ngene/ngene-ioctls.h
deleted file mode 100644 (file)
index 4aa2f64..0000000
+++ /dev/null
@@ -1,216 +0,0 @@
-/*
- * 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
diff --git a/drivers/media/dvb/ngene/ngene-snd.c b/drivers/media/dvb/ngene/ngene-snd.c
deleted file mode 100644 (file)
index 1ca3432..0000000
+++ /dev/null
@@ -1,421 +0,0 @@
-/*
- * 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;
-}
diff --git a/drivers/media/dvb/ngene/ngene-v4l2.c b/drivers/media/dvb/ngene/ngene-v4l2.c
deleted file mode 100644 (file)
index c0a9147..0000000
+++ /dev/null
@@ -1,1937 +0,0 @@
-/*
- * 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;
-}
index 15505c2b253456857ced6460c4071a107e8a445c..1c6f0e742ad7c5ddc7f327376a1afbb652f8b792 100644 (file)
@@ -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