V4L/DVB (10759): cx18: Convert GPIO connected functions to act as v4l2_subdevices
[safe/jmp/linux-2.6] / drivers / media / video / cx18 / cx18-ioctl.c
index f66ca0b..e4c9e3d 100644 (file)
@@ -4,6 +4,7 @@
  *  Derived from ivtv-ioctl.c
  *
  *  Copyright (C) 2007  Hans Verkuil <hverkuil@xs4all.nl>
+ *  Copyright (C) 2008  Andy Walls <awalls@radix.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -22,6 +23,7 @@
  */
 
 #include "cx18-driver.h"
+#include "cx18-io.h"
 #include "cx18-version.h"
 #include "cx18-mailbox.h"
 #include "cx18-i2c.h"
@@ -56,12 +58,21 @@ u16 cx18_service2vbi(int type)
        }
 }
 
+/* Check if VBI services are allowed on the (field, line) for the video std */
 static int valid_service_line(int field, int line, int is_pal)
 {
-       return (is_pal && line >= 6 && (line != 23 || field == 0)) ||
+       return (is_pal && line >= 6 &&
+               ((field == 0 && line <= 23) || (field == 1 && line <= 22))) ||
               (!is_pal && line >= 10 && line < 22);
 }
 
+/*
+ * For a (field, line, std) and inbound potential set of services for that line,
+ * return the first valid service of those passed in the incoming set for that
+ * line in priority order:
+ * CC, VPS, or WSS over TELETEXT for well known lines
+ * TELETEXT, before VPS, before CC, before WSS, for other lines
+ */
 static u16 select_service_from_set(int field, int line, u16 set, int is_pal)
 {
        u16 valid_set = (is_pal ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525);
@@ -88,6 +99,10 @@ static u16 select_service_from_set(int field, int line, u16 set, int is_pal)
        return 0;
 }
 
+/*
+ * Expand the service_set of *fmt into valid service_lines for the std,
+ * and clear the passed in fmt->service_set
+ */
 void cx18_expand_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
 {
        u16 set = fmt->service_set;
@@ -100,36 +115,35 @@ void cx18_expand_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
        }
 }
 
-
-u16 cx18_get_service_set(struct v4l2_sliced_vbi_format *fmt)
+/*
+ * Sanitize the service_lines in *fmt per the video std, and return 1
+ * if any service_line is left as valid after santization
+ */
+static int check_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
 {
        int f, l;
        u16 set = 0;
 
        for (f = 0; f < 2; f++) {
-               for (l = 0; l < 24; l++)
+               for (l = 0; l < 24; l++) {
+                       fmt->service_lines[f][l] = select_service_from_set(f, l, fmt->service_lines[f][l], is_pal);
                        set |= fmt->service_lines[f][l];
+               }
        }
-       return set;
+       return set != 0;
 }
 
-static int cx18_cxc(struct cx18 *cx, unsigned int cmd, void *arg)
+/* Compute the service_set from the assumed valid service_lines of *fmt */
+u16 cx18_get_service_set(struct v4l2_sliced_vbi_format *fmt)
 {
-       struct v4l2_register *regs = arg;
-       unsigned long flags;
-
-       if (!capable(CAP_SYS_ADMIN))
-               return -EPERM;
-       if (regs->reg >= CX18_MEM_OFFSET + CX18_MEM_SIZE)
-               return -EINVAL;
+       int f, l;
+       u16 set = 0;
 
-       spin_lock_irqsave(&cx18_cards_lock, flags);
-       if (cmd == VIDIOC_DBG_G_REGISTER)
-               regs->val = read_enc(regs->reg);
-       else
-               write_enc(regs->val, regs->reg);
-       spin_unlock_irqrestore(&cx18_cards_lock, flags);
-       return 0;
+       for (f = 0; f < 2; f++) {
+               for (l = 0; l < 24; l++)
+                       set |= fmt->service_lines[f][l];
+       }
+       return set;
 }
 
 static int cx18_g_fmt_vid_cap(struct file *file, void *fh,
@@ -137,22 +151,22 @@ static int cx18_g_fmt_vid_cap(struct file *file, void *fh,
 {
        struct cx18_open_id *id = fh;
        struct cx18 *cx = id->cx;
+       struct v4l2_pix_format *pixfmt = &fmt->fmt.pix;
 
-       CX18_DEBUG_IOCTL("VIDIOC_G_FMT: V4L2_BUF_TYPE_VIDEO_CAPTURE\n");
-
-       fmt->fmt.pix.width = cx->params.width;
-       fmt->fmt.pix.height = cx->params.height;
-       fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
-       fmt->fmt.pix.field = V4L2_FIELD_INTERLACED;
+       pixfmt->width = cx->params.width;
+       pixfmt->height = cx->params.height;
+       pixfmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
+       pixfmt->field = V4L2_FIELD_INTERLACED;
+       pixfmt->priv = 0;
        if (id->type == CX18_ENC_STREAM_TYPE_YUV) {
-               fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_HM12;
-               /* YUV size is (Y=(h*w) + UV=(h*(w/2))) */
-               fmt->fmt.pix.sizeimage =
-                       fmt->fmt.pix.height * fmt->fmt.pix.width +
-                       fmt->fmt.pix.height * (fmt->fmt.pix.width / 2);
+               pixfmt->pixelformat = V4L2_PIX_FMT_HM12;
+               /* YUV size is (Y=(h*720) + UV=(h*(720/2))) */
+               pixfmt->sizeimage = pixfmt->height * 720 * 3 / 2;
+               pixfmt->bytesperline = 720;
        } else {
-               fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
-               fmt->fmt.pix.sizeimage = 128 * 1024;
+               pixfmt->pixelformat = V4L2_PIX_FMT_MPEG;
+               pixfmt->sizeimage = 128 * 1024;
+               pixfmt->bytesperline = 0;
        }
        return 0;
 }
@@ -161,23 +175,48 @@ static int cx18_g_fmt_vbi_cap(struct file *file, void *fh,
                                struct v4l2_format *fmt)
 {
        struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
-
-       CX18_DEBUG_IOCTL("VIDIOC_G_FMT: V4L2_BUF_TYPE_VBI_CAPTURE\n");
-
-       fmt->fmt.vbi.sampling_rate = 27000000;
-       fmt->fmt.vbi.offset = 248;
-       fmt->fmt.vbi.samples_per_line = cx->vbi.raw_decoder_line_size - 4;
-       fmt->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
-       fmt->fmt.vbi.start[0] = cx->vbi.start[0];
-       fmt->fmt.vbi.start[1] = cx->vbi.start[1];
-       fmt->fmt.vbi.count[0] = fmt->fmt.vbi.count[1] = cx->vbi.count;
+       struct v4l2_vbi_format *vbifmt = &fmt->fmt.vbi;
+
+       vbifmt->sampling_rate = 27000000;
+       vbifmt->offset = 248; /* FIXME - slightly wrong for both 50 & 60 Hz */
+       vbifmt->samples_per_line = vbi_active_samples - 4;
+       vbifmt->sample_format = V4L2_PIX_FMT_GREY;
+       vbifmt->start[0] = cx->vbi.start[0];
+       vbifmt->start[1] = cx->vbi.start[1];
+       vbifmt->count[0] = vbifmt->count[1] = cx->vbi.count;
+       vbifmt->flags = 0;
+       vbifmt->reserved[0] = 0;
+       vbifmt->reserved[1] = 0;
        return 0;
 }
 
 static int cx18_g_fmt_sliced_vbi_cap(struct file *file, void *fh,
                                        struct v4l2_format *fmt)
 {
-       return -EINVAL;
+       struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
+       struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
+
+       /* sane, V4L2 spec compliant, defaults */
+       vbifmt->reserved[0] = 0;
+       vbifmt->reserved[1] = 0;
+       vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
+       memset(vbifmt->service_lines, 0, sizeof(vbifmt->service_lines));
+       vbifmt->service_set = 0;
+
+       /*
+        * Fetch the configured service_lines and total service_set from the
+        * digitizer/slicer.  Note, cx18_av_vbi() wipes the passed in
+        * fmt->fmt.sliced under valid calling conditions
+        */
+       if (v4l2_subdev_call(cx->sd_av, video, g_fmt, fmt))
+               return -EINVAL;
+
+       /* Ensure V4L2 spec compliant output */
+       vbifmt->reserved[0] = 0;
+       vbifmt->reserved[1] = 0;
+       vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
+       vbifmt->service_set = cx18_get_service_set(vbifmt);
+       return 0;
 }
 
 static int cx18_try_fmt_vid_cap(struct file *file, void *fh,
@@ -185,16 +224,20 @@ static int cx18_try_fmt_vid_cap(struct file *file, void *fh,
 {
        struct cx18_open_id *id = fh;
        struct cx18 *cx = id->cx;
-
        int w = fmt->fmt.pix.width;
        int h = fmt->fmt.pix.height;
-
-       CX18_DEBUG_IOCTL("VIDIOC_TRY_FMT: V4L2_BUF_TYPE_VIDEO_CAPTURE\n");
+       int min_h = 2;
 
        w = min(w, 720);
-       w = max(w, 1);
+       w = max(w, 2);
+       if (id->type == CX18_ENC_STREAM_TYPE_YUV) {
+               /* YUV height must be a multiple of 32 */
+               h &= ~0x1f;
+               min_h = 32;
+       }
        h = min(h, cx->is_50hz ? 576 : 480);
-       h = max(h, 2);
+       h = max(h, min_h);
+
        cx18_g_fmt_vid_cap(file, fh, fmt);
        fmt->fmt.pix.width = w;
        fmt->fmt.pix.height = h;
@@ -204,17 +247,26 @@ static int cx18_try_fmt_vid_cap(struct file *file, void *fh,
 static int cx18_try_fmt_vbi_cap(struct file *file, void *fh,
                                struct v4l2_format *fmt)
 {
-       struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
-
-       CX18_DEBUG_IOCTL("VIDIOC_TRY_FMT: V4L2_BUF_TYPE_VBI_CAPTURE\n");
-
        return cx18_g_fmt_vbi_cap(file, fh, fmt);
 }
 
 static int cx18_try_fmt_sliced_vbi_cap(struct file *file, void *fh,
                                        struct v4l2_format *fmt)
 {
-       return -EINVAL;
+       struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
+       struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
+
+       vbifmt->io_size = sizeof(struct v4l2_sliced_vbi_data) * 36;
+       vbifmt->reserved[0] = 0;
+       vbifmt->reserved[1] = 0;
+
+       /* If given a service set, expand it validly & clear passed in set */
+       if (vbifmt->service_set)
+               cx18_expand_service_set(vbifmt, cx->is_50hz);
+       /* Sanitize the service_lines, and compute the new set if any valid */
+       if (check_service_set(vbifmt, cx->is_50hz))
+               vbifmt->service_set = cx18_get_service_set(vbifmt);
+       return 0;
 }
 
 static int cx18_s_fmt_vid_cap(struct file *file, void *fh,
@@ -223,18 +275,17 @@ static int cx18_s_fmt_vid_cap(struct file *file, void *fh,
        struct cx18_open_id *id = fh;
        struct cx18 *cx = id->cx;
        int ret;
-       int w = fmt->fmt.pix.width;
-       int h = fmt->fmt.pix.height;
+       int w, h;
 
        ret = v4l2_prio_check(&cx->prio, &id->prio);
        if (ret)
                return ret;
 
-       CX18_DEBUG_IOCTL("VIDIOC_S_FMT: V4L2_BUF_TYPE_VIDEO_CAPTURE\n");
-
        ret = cx18_try_fmt_vid_cap(file, fh, fmt);
        if (ret)
                return ret;
+       w = fmt->fmt.pix.width;
+       h = fmt->fmt.pix.height;
 
        if (cx->params.width == w && cx->params.height == h)
                return 0;
@@ -244,7 +295,7 @@ static int cx18_s_fmt_vid_cap(struct file *file, void *fh,
 
        cx->params.width = w;
        cx->params.height = h;
-       cx18_av_cmd(cx, VIDIOC_S_FMT, fmt);
+       v4l2_subdev_call(cx->sd_av, video, s_fmt, fmt);
        return cx18_g_fmt_vid_cap(file, fh, fmt);
 }
 
@@ -259,85 +310,163 @@ static int cx18_s_fmt_vbi_cap(struct file *file, void *fh,
        if (ret)
                return ret;
 
-       CX18_DEBUG_IOCTL("VIDIOC_S_FMT: V4L2_BUF_TYPE_VBI_CAPTURE\n");
-
-       if (id->type == CX18_ENC_STREAM_TYPE_VBI &&
-                       cx->vbi.sliced_in->service_set &&
-                       atomic_read(&cx->ana_capturing) > 0)
+       /*
+        * Changing the Encoder's Raw VBI parameters won't have any effect
+        * if any analog capture is ongoing
+        */
+       if (!cx18_raw_vbi(cx) && atomic_read(&cx->ana_capturing) > 0)
                return -EBUSY;
 
+       /*
+        * Set the digitizer registers for raw active VBI.
+        * Note cx18_av_vbi_wipes out alot of the passed in fmt under valid
+        * calling conditions
+        */
+       ret = v4l2_subdev_call(cx->sd_av, video, s_fmt, fmt);
+       if (ret)
+               return ret;
+
+       /* Store our new v4l2 (non-)sliced VBI state */
        cx->vbi.sliced_in->service_set = 0;
-       cx18_av_cmd(cx, VIDIOC_S_FMT, &cx->vbi.in);
+       cx->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
+
        return cx18_g_fmt_vbi_cap(file, fh, fmt);
 }
 
 static int cx18_s_fmt_sliced_vbi_cap(struct file *file, void *fh,
                                        struct v4l2_format *fmt)
 {
-       return -EINVAL;
+       struct cx18_open_id *id = fh;
+       struct cx18 *cx = id->cx;
+       int ret;
+       struct v4l2_sliced_vbi_format *vbifmt = &fmt->fmt.sliced;
+
+       ret = v4l2_prio_check(&cx->prio, &id->prio);
+       if (ret)
+               return ret;
+
+       cx18_try_fmt_sliced_vbi_cap(file, fh, fmt);
+
+       /*
+        * Changing the Encoder's Raw VBI parameters won't have any effect
+        * if any analog capture is ongoing
+        */
+       if (cx18_raw_vbi(cx) && atomic_read(&cx->ana_capturing) > 0)
+               return -EBUSY;
+
+       /*
+        * Set the service_lines requested in the digitizer/slicer registers.
+        * Note, cx18_av_vbi() wipes some "impossible" service lines in the
+        * passed in fmt->fmt.sliced under valid calling conditions
+        */
+       ret = v4l2_subdev_call(cx->sd_av, video, s_fmt, fmt);
+       if (ret)
+               return ret;
+       /* Store our current v4l2 sliced VBI settings */
+       cx->vbi.in.type =  V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
+       memcpy(cx->vbi.sliced_in, vbifmt, sizeof(*cx->vbi.sliced_in));
+       return 0;
 }
 
 static int cx18_g_chip_ident(struct file *file, void *fh,
-                               struct v4l2_chip_ident *chip)
+                               struct v4l2_dbg_chip_ident *chip)
 {
        struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
-
-       CX18_DEBUG_IOCTL("VIDIOC_G_CHIP_IDENT\n");
+       int err = 0;
 
        chip->ident = V4L2_IDENT_NONE;
        chip->revision = 0;
-       if (chip->match_type == V4L2_CHIP_MATCH_HOST) {
-               if (v4l2_chip_match_host(chip->match_type, chip->match_chip))
+       switch (chip->match.type) {
+       case V4L2_CHIP_MATCH_HOST:
+               switch (chip->match.addr) {
+               case 0:
                        chip->ident = V4L2_IDENT_CX23418;
-               return 0;
+                       chip->revision = cx18_read_reg(cx, 0xC72028);
+                       break;
+               case 1:
+                       /*
+                        * The A/V decoder is always present, but in the rare
+                        * case that the card doesn't have analog, we don't
+                        * use it.  We find it w/o using the cx->sd_av pointer
+                        */
+                       cx18_call_hw(cx, CX18_HW_418_AV,
+                                    core, g_chip_ident, chip);
+                       break;
+               default:
+                       /*
+                        * Could return ident = V4L2_IDENT_UNKNOWN if we had
+                        * other host chips at higher addresses, but we don't
+                        */
+                       err = -EINVAL; /* per V4L2 spec */
+                       break;
+               }
+               break;
+       case V4L2_CHIP_MATCH_I2C_DRIVER:
+               /* If needed, returns V4L2_IDENT_AMBIGUOUS without extra work */
+               cx18_call_all(cx, core, g_chip_ident, chip);
+               break;
+       case V4L2_CHIP_MATCH_I2C_ADDR:
+               /*
+                * We could return V4L2_IDENT_UNKNOWN, but we don't do the work
+                * to look if a chip is at the address with no driver.  That's a
+                * dangerous thing to do with EEPROMs anyway.
+                */
+               cx18_call_all(cx, core, g_chip_ident, chip);
+               break;
+       default:
+               err = -EINVAL;
+               break;
        }
-       if (chip->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
-               return cx18_i2c_id(cx, chip->match_chip, VIDIOC_G_CHIP_IDENT,
-                                       chip);
-       if (chip->match_type == V4L2_CHIP_MATCH_I2C_ADDR)
-               return cx18_call_i2c_client(cx, chip->match_chip,
-                                               VIDIOC_G_CHIP_IDENT, chip);
-       return -EINVAL;
+       return err;
+}
+
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+static int cx18_cxc(struct cx18 *cx, unsigned int cmd, void *arg)
+{
+       struct v4l2_dbg_register *regs = arg;
+
+       if (!capable(CAP_SYS_ADMIN))
+               return -EPERM;
+       if (regs->reg >= CX18_MEM_OFFSET + CX18_MEM_SIZE)
+               return -EINVAL;
+
+       regs->size = 4;
+       if (cmd == VIDIOC_DBG_S_REGISTER)
+               cx18_write_enc(cx, regs->val, regs->reg);
+       else
+               regs->val = cx18_read_enc(cx, regs->reg);
+       return 0;
 }
 
 static int cx18_g_register(struct file *file, void *fh,
-                               struct v4l2_register *reg)
+                               struct v4l2_dbg_register *reg)
 {
        struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
 
-       CX18_DEBUG_IOCTL("VIDIOC_DBG_G_REGISTER\n");
-
-       if (v4l2_chip_match_host(reg->match_type, reg->match_chip))
+       if (v4l2_chip_match_host(&reg->match))
                return cx18_cxc(cx, VIDIOC_DBG_G_REGISTER, reg);
-       if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
-               return cx18_i2c_id(cx, reg->match_chip, VIDIOC_DBG_G_REGISTER,
-                                       reg);
-       return cx18_call_i2c_client(cx, reg->match_chip, VIDIOC_DBG_G_REGISTER,
-                                       reg);
+       /* FIXME - errors shouldn't be ignored */
+       cx18_call_all(cx, core, g_register, reg);
+       return 0;
 }
 
 static int cx18_s_register(struct file *file, void *fh,
-                               struct v4l2_register *reg)
+                               struct v4l2_dbg_register *reg)
 {
        struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
 
-       CX18_DEBUG_IOCTL("VIDIOC_DBG_S_REGISTER\n");
-
-       if (v4l2_chip_match_host(reg->match_type, reg->match_chip))
+       if (v4l2_chip_match_host(&reg->match))
                return cx18_cxc(cx, VIDIOC_DBG_S_REGISTER, reg);
-       if (reg->match_type == V4L2_CHIP_MATCH_I2C_DRIVER)
-               return cx18_i2c_id(cx, reg->match_chip, VIDIOC_DBG_S_REGISTER,
-                                       reg);
-       return cx18_call_i2c_client(cx, reg->match_chip, VIDIOC_DBG_S_REGISTER,
-                                       reg);
+       /* FIXME - errors shouldn't be ignored */
+       cx18_call_all(cx, core, s_register, reg);
+       return 0;
 }
+#endif
 
 static int cx18_g_priority(struct file *file, void *fh, enum v4l2_priority *p)
 {
        struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
 
-       CX18_DEBUG_IOCTL("VIDIOC_G_PRIORITY\n");
-
        *p = v4l2_prio_max(&cx->prio);
        return 0;
 }
@@ -347,8 +476,6 @@ static int cx18_s_priority(struct file *file, void *fh, enum v4l2_priority prio)
        struct cx18_open_id *id = fh;
        struct cx18 *cx = id->cx;
 
-       CX18_DEBUG_IOCTL("VIDIOC_S_PRIORITY\n");
-
        return v4l2_prio_change(&cx->prio, &id->prio, prio);
 }
 
@@ -357,11 +484,10 @@ static int cx18_querycap(struct file *file, void *fh,
 {
        struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
 
-       CX18_DEBUG_IOCTL("VIDIOC_QUERYCAP\n");
-
        strlcpy(vcap->driver, CX18_DRIVER_NAME, sizeof(vcap->driver));
        strlcpy(vcap->card, cx->card_name, sizeof(vcap->card));
-       strlcpy(vcap->bus_info, pci_name(cx->dev), sizeof(vcap->bus_info));
+       snprintf(vcap->bus_info, sizeof(vcap->bus_info),
+                "PCI:%s", pci_name(cx->pci_dev));
        vcap->version = CX18_DRIVER_VERSION;        /* version */
        vcap->capabilities = cx->v4l2_cap;          /* capabilities */
        return 0;
@@ -371,8 +497,6 @@ static int cx18_enumaudio(struct file *file, void *fh, struct v4l2_audio *vin)
 {
        struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
 
-       CX18_DEBUG_IOCTL("VIDIOC_ENUMAUDIO\n");
-
        return cx18_get_audio_input(cx, vin->index, vin);
 }
 
@@ -380,8 +504,6 @@ static int cx18_g_audio(struct file *file, void *fh, struct v4l2_audio *vin)
 {
        struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
 
-       CX18_DEBUG_IOCTL("VIDIOC_G_AUDIO\n");
-
        vin->index = cx->audio_input;
        return cx18_get_audio_input(cx, vin->index, vin);
 }
@@ -390,8 +512,6 @@ static int cx18_s_audio(struct file *file, void *fh, struct v4l2_audio *vout)
 {
        struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
 
-       CX18_DEBUG_IOCTL("VIDIOC_S_AUDIO\n");
-
        if (vout->index >= cx->nof_audio_inputs)
                return -EINVAL;
        cx->audio_input = vout->index;
@@ -403,8 +523,6 @@ static int cx18_enum_input(struct file *file, void *fh, struct v4l2_input *vin)
 {
        struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
 
-       CX18_DEBUG_IOCTL("VIDIOC_ENUMINPUT\n");
-
        /* set it to defaults from our table */
        return cx18_get_input(cx, vin->index, vin);
 }
@@ -414,8 +532,6 @@ static int cx18_cropcap(struct file *file, void *fh,
 {
        struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
 
-       CX18_DEBUG_IOCTL("VIDIOC_CROPCAP\n");
-
        if (cropcap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
                return -EINVAL;
        cropcap->bounds.top = cropcap->bounds.left = 0;
@@ -437,22 +553,20 @@ static int cx18_s_crop(struct file *file, void *fh, struct v4l2_crop *crop)
        if (ret)
                return ret;
 
-       CX18_DEBUG_IOCTL("VIDIOC_S_CROP\n");
-
        if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
                return -EINVAL;
-       return cx18_av_cmd(cx, VIDIOC_S_CROP, crop);
+       CX18_DEBUG_WARN("VIDIOC_S_CROP not implemented\n");
+       return -EINVAL;
 }
 
 static int cx18_g_crop(struct file *file, void *fh, struct v4l2_crop *crop)
 {
        struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
 
-       CX18_DEBUG_IOCTL("VIDIOC_G_CROP\n");
-
        if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
                return -EINVAL;
-       return cx18_av_cmd(cx, VIDIOC_G_CROP, crop);
+       CX18_DEBUG_WARN("VIDIOC_G_CROP not implemented\n");
+       return -EINVAL;
 }
 
 static int cx18_enum_fmt_vid_cap(struct file *file, void *fh,
@@ -467,10 +581,6 @@ static int cx18_enum_fmt_vid_cap(struct file *file, void *fh,
                }
        };
 
-       struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
-
-       CX18_DEBUG_IOCTL("VIDIOC_ENUM_FMT: V4L2_BUF_TYPE_VIDEO_CAPTURE\n");
-
        if (fmt->index > 1)
                return -EINVAL;
        *fmt = formats[fmt->index];
@@ -481,8 +591,6 @@ static int cx18_g_input(struct file *file, void *fh, unsigned int *i)
 {
        struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
 
-       CX18_DEBUG_IOCTL("VIDIOC_G_INPUT\n");
-
        *i = cx->active_input;
        return 0;
 }
@@ -497,8 +605,6 @@ int cx18_s_input(struct file *file, void *fh, unsigned int inp)
        if (ret)
                return ret;
 
-       CX18_DEBUG_IOCTL("VIDIOC_S_INPUT\n");
-
        if (inp < 0 || inp >= cx->nof_inputs)
                return -EINVAL;
 
@@ -528,12 +634,10 @@ static int cx18_g_frequency(struct file *file, void *fh,
 {
        struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
 
-       CX18_DEBUG_IOCTL("VIDIOC_G_FREQUENCY\n");
-
        if (vf->tuner != 0)
                return -EINVAL;
 
-       cx18_call_i2c_clients(cx, VIDIOC_G_FREQUENCY, vf);
+       cx18_call_all(cx, tuner, g_frequency, vf);
        return 0;
 }
 
@@ -547,14 +651,12 @@ int cx18_s_frequency(struct file *file, void *fh, struct v4l2_frequency *vf)
        if (ret)
                return ret;
 
-       CX18_DEBUG_IOCTL("VIDIOC_S_FREQUENCY\n");
-
        if (vf->tuner != 0)
                return -EINVAL;
 
        cx18_mute(cx);
        CX18_DEBUG_INFO("v4l2 ioctl: set frequency %d\n", vf->frequency);
-       cx18_call_i2c_clients(cx, VIDIOC_S_FREQUENCY, vf);
+       cx18_call_all(cx, tuner, s_frequency, vf);
        cx18_unmute(cx);
        return 0;
 }
@@ -563,8 +665,6 @@ static int cx18_g_std(struct file *file, void *fh, v4l2_std_id *std)
 {
        struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
 
-       CX18_DEBUG_IOCTL("VIDIOC_G_STD\n");
-
        *std = cx->std;
        return 0;
 }
@@ -579,8 +679,6 @@ int cx18_s_std(struct file *file, void *fh, v4l2_std_id *std)
        if (ret)
                return ret;
 
-       CX18_DEBUG_IOCTL("VIDIOC_S_STD\n");
-
        if ((*std & V4L2_STD_ALL) == 0)
                return -EINVAL;
 
@@ -603,12 +701,11 @@ int cx18_s_std(struct file *file, void *fh, v4l2_std_id *std)
        cx->vbi.count = cx->is_50hz ? 18 : 12;
        cx->vbi.start[0] = cx->is_50hz ? 6 : 10;
        cx->vbi.start[1] = cx->is_50hz ? 318 : 273;
-       cx->vbi.sliced_decoder_line_size = cx->is_60hz ? 272 : 284;
        CX18_DEBUG_INFO("Switching standard to %llx.\n",
                        (unsigned long long) cx->std);
 
        /* Tuner */
-       cx18_call_i2c_clients(cx, VIDIOC_S_STD, &cx->std);
+       cx18_call_all(cx, tuner, s_std, cx->std);
        return 0;
 }
 
@@ -622,14 +719,10 @@ static int cx18_s_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
        if (ret)
                return ret;
 
-       CX18_DEBUG_IOCTL("VIDIOC_S_TUNER\n");
-
        if (vt->index != 0)
                return -EINVAL;
 
-       /* Setting tuner can only set audio mode */
-       cx18_call_i2c_clients(cx, VIDIOC_S_TUNER, vt);
-
+       cx18_call_all(cx, tuner, s_tuner, vt);
        return 0;
 }
 
@@ -637,12 +730,10 @@ static int cx18_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
 {
        struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
 
-       CX18_DEBUG_IOCTL("VIDIOC_G_TUNER\n");
-
        if (vt->index != 0)
                return -EINVAL;
 
-       cx18_call_i2c_clients(cx, VIDIOC_G_TUNER, vt);
+       cx18_call_all(cx, tuner, g_tuner, vt);
 
        if (test_bit(CX18_F_I_RADIO_USER, &cx->i_flags)) {
                strlcpy(vt->name, "cx18 Radio Tuner", sizeof(vt->name));
@@ -658,7 +749,30 @@ static int cx18_g_tuner(struct file *file, void *fh, struct v4l2_tuner *vt)
 static int cx18_g_sliced_vbi_cap(struct file *file, void *fh,
                                        struct v4l2_sliced_vbi_cap *cap)
 {
-       return -EINVAL;
+       struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
+       int set = cx->is_50hz ? V4L2_SLICED_VBI_625 : V4L2_SLICED_VBI_525;
+       int f, l;
+
+       if (cap->type != V4L2_BUF_TYPE_SLICED_VBI_CAPTURE)
+               return -EINVAL;
+
+       cap->service_set = 0;
+       for (f = 0; f < 2; f++) {
+               for (l = 0; l < 24; l++) {
+                       if (valid_service_line(f, l, cx->is_50hz)) {
+                               /*
+                                * We can find all v4l2 supported vbi services
+                                * for the standard, on a valid line for the std
+                                */
+                               cap->service_lines[f][l] = set;
+                               cap->service_set |= set;
+                       } else
+                               cap->service_lines[f][l] = 0;
+               }
+       }
+       for (f = 0; f < 3; f++)
+               cap->reserved[f] = 0;
+       return 0;
 }
 
 static int cx18_g_enc_index(struct file *file, void *fh,
@@ -672,8 +786,7 @@ static int cx18_encoder_cmd(struct file *file, void *fh,
 {
        struct cx18_open_id *id = fh;
        struct cx18 *cx = id->cx;
-
-       CX18_DEBUG_IOCTL("VIDIOC_ENCODER_CMD:\n");
+       u32 h;
 
        switch (enc->cmd) {
        case V4L2_ENC_CMD_START:
@@ -695,8 +808,14 @@ static int cx18_encoder_cmd(struct file *file, void *fh,
                        return -EPERM;
                if (test_and_set_bit(CX18_F_I_ENC_PAUSED, &cx->i_flags))
                        return 0;
+               h = cx18_find_handle(cx);
+               if (h == CX18_INVALID_TASK_HANDLE) {
+                       CX18_ERR("Can't find valid task handle for "
+                                "V4L2_ENC_CMD_PAUSE\n");
+                       return -EBADFD;
+               }
                cx18_mute(cx);
-               cx18_vapi(cx, CX18_CPU_CAPTURE_PAUSE, 1, cx18_find_handle(cx));
+               cx18_vapi(cx, CX18_CPU_CAPTURE_PAUSE, 1, h);
                break;
 
        case V4L2_ENC_CMD_RESUME:
@@ -706,7 +825,13 @@ static int cx18_encoder_cmd(struct file *file, void *fh,
                        return -EPERM;
                if (!test_and_clear_bit(CX18_F_I_ENC_PAUSED, &cx->i_flags))
                        return 0;
-               cx18_vapi(cx, CX18_CPU_CAPTURE_RESUME, 1, cx18_find_handle(cx));
+               h = cx18_find_handle(cx);
+               if (h == CX18_INVALID_TASK_HANDLE) {
+                       CX18_ERR("Can't find valid task handle for "
+                                "V4L2_ENC_CMD_RESUME\n");
+                       return -EBADFD;
+               }
+               cx18_vapi(cx, CX18_CPU_CAPTURE_RESUME, 1, h);
                cx18_unmute(cx);
                break;
 
@@ -722,8 +847,6 @@ static int cx18_try_encoder_cmd(struct file *file, void *fh,
 {
        struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
 
-       CX18_DEBUG_IOCTL("VIDIOC_TRY_ENCDOER_CMD:\n");
-
        switch (enc->cmd) {
        case V4L2_ENC_CMD_START:
                CX18_DEBUG_IOCTL("V4L2_ENC_CMD_START\n");
@@ -759,128 +882,143 @@ static int cx18_log_status(struct file *file, void *fh)
        struct v4l2_audio audin;
        int i;
 
-       CX18_DEBUG_IOCTL("VIDIOC_LOG_STATUS\n");
-       CX18_INFO("=================  START STATUS CARD #%d  =================\n", cx->num);
+       CX18_INFO("=================  START STATUS CARD #%d  "
+                 "=================\n", cx->instance);
+       CX18_INFO("Version: %s  Card: %s\n", CX18_VERSION, cx->card_name);
        if (cx->hw_flags & CX18_HW_TVEEPROM) {
                struct tveeprom tv;
 
                cx18_read_eeprom(cx, &tv);
        }
-       cx18_call_i2c_clients(cx, VIDIOC_LOG_STATUS, NULL);
+       cx18_call_all(cx, core, log_status);
        cx18_get_input(cx, cx->active_input, &vidin);
        cx18_get_audio_input(cx, cx->audio_input, &audin);
        CX18_INFO("Video Input: %s\n", vidin.name);
        CX18_INFO("Audio Input: %s\n", audin.name);
+       mutex_lock(&cx->gpio_lock);
+       CX18_INFO("GPIO:  direction 0x%08x, value 0x%08x\n",
+               cx->gpio_dir, cx->gpio_val);
+       mutex_unlock(&cx->gpio_lock);
        CX18_INFO("Tuner: %s\n",
                test_bit(CX18_F_I_RADIO_USER, &cx->i_flags) ?  "Radio" : "TV");
-       cx2341x_log_status(&cx->params, cx->name);
+       cx2341x_log_status(&cx->params, cx->v4l2_dev.name);
        CX18_INFO("Status flags: 0x%08lx\n", cx->i_flags);
        for (i = 0; i < CX18_MAX_STREAMS; i++) {
                struct cx18_stream *s = &cx->streams[i];
 
-               if (s->v4l2dev == NULL || s->buffers == 0)
+               if (s->video_dev == NULL || s->buffers == 0)
                        continue;
                CX18_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n",
                          s->name, s->s_flags,
-                         (s->buffers - s->q_free.buffers) * 100 / s->buffers,
+                         atomic_read(&s->q_full.buffers) * 100 / s->buffers,
                          (s->buffers * s->buf_size) / 1024, s->buffers);
        }
        CX18_INFO("Read MPEG/VBI: %lld/%lld bytes\n",
                        (long long)cx->mpg_data_received,
                        (long long)cx->vbi_data_inserted);
-       CX18_INFO("==================  END STATUS CARD #%d  ==================\n", cx->num);
+       CX18_INFO("==================  END STATUS CARD #%d  "
+                 "==================\n", cx->instance);
        return 0;
 }
 
-static int cx18_default(struct file *file, void *fh, int cmd, void *arg)
+static long cx18_default(struct file *file, void *fh, int cmd, void *arg)
 {
        struct cx18 *cx = ((struct cx18_open_id *)fh)->cx;
 
        switch (cmd) {
        case VIDIOC_INT_S_AUDIO_ROUTING: {
                struct v4l2_routing *route = arg;
-               CX18_DEBUG_IOCTL("VIDIOC_INT_S_AUDIO_ROUTING (%d, %d)\n",
-                                       route->input, route->output);
-               cx18_audio_set_route(cx, route);
+
+               CX18_DEBUG_IOCTL("VIDIOC_INT_S_AUDIO_ROUTING(%d, %d)\n",
+                       route->input, route->output);
+               cx18_call_hw(cx, cx->card->hw_audio_ctrl, audio, s_routing,
+                            route);
                break;
        }
+
        case VIDIOC_INT_RESET: {
                u32 val = *(u32 *)arg;
-               CX18_DEBUG_IOCTL("VIDIOC_INT_RESET (%#10x)\n", val);
-               /* No op right now */
-               /* cx18_av_cmd(cx, cmd, arg) */
-               /* cx18_call_i2c_clients(cx, cmd, arg) */
+
+               if ((val == 0) || (val & 0x01))
+                       cx18_call_hw(cx, CX18_HW_GPIO_RESET_CTRL, core, reset,
+                                    (u32) CX18_GPIO_RESET_Z8F0811);
                break;
        }
+
        default:
-               if (cx18_debug & CX18_DBGFLG_IOCTL) {
-                       printk(KERN_INFO "cx18%d ioctl: unsupported cmd: ",
-                                cx->num);
-                       v4l_printk_ioctl(cmd);
-                       printk("\n");
-               }
                return -EINVAL;
        }
        return 0;
 }
 
-int cx18_v4l2_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
+long cx18_v4l2_ioctl(struct file *filp, unsigned int cmd,
                    unsigned long arg)
 {
+       struct video_device *vfd = video_devdata(filp);
        struct cx18_open_id *id = (struct cx18_open_id *)filp->private_data;
        struct cx18 *cx = id->cx;
-       int res;
+       long res;
 
        mutex_lock(&cx->serialize_lock);
-       res = video_ioctl2(inode, filp, cmd, arg);
+
+       /* FIXME - consolidate v4l2_prio_check()'s here */
+
+       if (cx18_debug & CX18_DBGFLG_IOCTL)
+               vfd->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
+       res = video_ioctl2(filp, cmd, arg);
+       vfd->debug = 0;
        mutex_unlock(&cx->serialize_lock);
        return res;
 }
 
+static const struct v4l2_ioctl_ops cx18_ioctl_ops = {
+       .vidioc_querycap                = cx18_querycap,
+       .vidioc_g_priority              = cx18_g_priority,
+       .vidioc_s_priority              = cx18_s_priority,
+       .vidioc_s_audio                 = cx18_s_audio,
+       .vidioc_g_audio                 = cx18_g_audio,
+       .vidioc_enumaudio               = cx18_enumaudio,
+       .vidioc_enum_input              = cx18_enum_input,
+       .vidioc_cropcap                 = cx18_cropcap,
+       .vidioc_s_crop                  = cx18_s_crop,
+       .vidioc_g_crop                  = cx18_g_crop,
+       .vidioc_g_input                 = cx18_g_input,
+       .vidioc_s_input                 = cx18_s_input,
+       .vidioc_g_frequency             = cx18_g_frequency,
+       .vidioc_s_frequency             = cx18_s_frequency,
+       .vidioc_s_tuner                 = cx18_s_tuner,
+       .vidioc_g_tuner                 = cx18_g_tuner,
+       .vidioc_g_enc_index             = cx18_g_enc_index,
+       .vidioc_g_std                   = cx18_g_std,
+       .vidioc_s_std                   = cx18_s_std,
+       .vidioc_log_status              = cx18_log_status,
+       .vidioc_enum_fmt_vid_cap        = cx18_enum_fmt_vid_cap,
+       .vidioc_encoder_cmd             = cx18_encoder_cmd,
+       .vidioc_try_encoder_cmd         = cx18_try_encoder_cmd,
+       .vidioc_g_fmt_vid_cap           = cx18_g_fmt_vid_cap,
+       .vidioc_g_fmt_vbi_cap           = cx18_g_fmt_vbi_cap,
+       .vidioc_g_fmt_sliced_vbi_cap    = cx18_g_fmt_sliced_vbi_cap,
+       .vidioc_s_fmt_vid_cap           = cx18_s_fmt_vid_cap,
+       .vidioc_s_fmt_vbi_cap           = cx18_s_fmt_vbi_cap,
+       .vidioc_s_fmt_sliced_vbi_cap    = cx18_s_fmt_sliced_vbi_cap,
+       .vidioc_try_fmt_vid_cap         = cx18_try_fmt_vid_cap,
+       .vidioc_try_fmt_vbi_cap         = cx18_try_fmt_vbi_cap,
+       .vidioc_try_fmt_sliced_vbi_cap  = cx18_try_fmt_sliced_vbi_cap,
+       .vidioc_g_sliced_vbi_cap        = cx18_g_sliced_vbi_cap,
+       .vidioc_g_chip_ident            = cx18_g_chip_ident,
+#ifdef CONFIG_VIDEO_ADV_DEBUG
+       .vidioc_g_register              = cx18_g_register,
+       .vidioc_s_register              = cx18_s_register,
+#endif
+       .vidioc_default                 = cx18_default,
+       .vidioc_queryctrl               = cx18_queryctrl,
+       .vidioc_querymenu               = cx18_querymenu,
+       .vidioc_g_ext_ctrls             = cx18_g_ext_ctrls,
+       .vidioc_s_ext_ctrls             = cx18_s_ext_ctrls,
+       .vidioc_try_ext_ctrls           = cx18_try_ext_ctrls,
+};
+
 void cx18_set_funcs(struct video_device *vdev)
 {
-       vdev->vidioc_querycap                = cx18_querycap;
-       vdev->vidioc_g_priority              = cx18_g_priority;
-       vdev->vidioc_s_priority              = cx18_s_priority;
-       vdev->vidioc_s_audio                 = cx18_s_audio;
-       vdev->vidioc_g_audio                 = cx18_g_audio;
-       vdev->vidioc_enumaudio               = cx18_enumaudio;
-       vdev->vidioc_enum_input              = cx18_enum_input;
-       vdev->vidioc_cropcap                 = cx18_cropcap;
-       vdev->vidioc_s_crop                  = cx18_s_crop;
-       vdev->vidioc_g_crop                  = cx18_g_crop;
-       vdev->vidioc_g_input                 = cx18_g_input;
-       vdev->vidioc_s_input                 = cx18_s_input;
-       vdev->vidioc_g_frequency             = cx18_g_frequency;
-       vdev->vidioc_s_frequency             = cx18_s_frequency;
-       vdev->vidioc_s_tuner                 = cx18_s_tuner;
-       vdev->vidioc_g_tuner                 = cx18_g_tuner;
-       vdev->vidioc_g_enc_index             = cx18_g_enc_index;
-       vdev->vidioc_g_std                   = cx18_g_std;
-       vdev->vidioc_s_std                   = cx18_s_std;
-       vdev->vidioc_log_status              = cx18_log_status;
-       vdev->vidioc_enum_fmt_vid_cap        = cx18_enum_fmt_vid_cap;
-       vdev->vidioc_encoder_cmd             = cx18_encoder_cmd;
-       vdev->vidioc_try_encoder_cmd         = cx18_try_encoder_cmd;
-       vdev->vidioc_g_fmt_vid_cap           = cx18_g_fmt_vid_cap;
-       vdev->vidioc_g_fmt_vbi_cap           = cx18_g_fmt_vbi_cap;
-       vdev->vidioc_g_fmt_sliced_vbi_cap    = cx18_g_fmt_sliced_vbi_cap;
-       vdev->vidioc_s_fmt_vid_cap           = cx18_s_fmt_vid_cap;
-       vdev->vidioc_s_fmt_vbi_cap           = cx18_s_fmt_vbi_cap;
-       vdev->vidioc_s_fmt_sliced_vbi_cap    = cx18_s_fmt_sliced_vbi_cap;
-       vdev->vidioc_try_fmt_vid_cap         = cx18_try_fmt_vid_cap;
-       vdev->vidioc_try_fmt_vbi_cap         = cx18_try_fmt_vbi_cap;
-       vdev->vidioc_try_fmt_sliced_vbi_cap  = cx18_try_fmt_sliced_vbi_cap;
-       vdev->vidioc_g_sliced_vbi_cap        = cx18_g_sliced_vbi_cap;
-       vdev->vidioc_g_chip_ident            = cx18_g_chip_ident;
-       vdev->vidioc_g_register              = cx18_g_register;
-       vdev->vidioc_s_register              = cx18_s_register;
-       vdev->vidioc_default                 = cx18_default;
-       vdev->vidioc_queryctrl               = cx18_queryctrl;
-       vdev->vidioc_querymenu               = cx18_querymenu;
-       vdev->vidioc_g_ctrl                  = cx18_g_ctrl;
-       vdev->vidioc_s_ctrl                  = cx18_s_ctrl;
-       vdev->vidioc_g_ext_ctrls             = cx18_g_ext_ctrls;
-       vdev->vidioc_s_ext_ctrls             = cx18_s_ext_ctrls;
-       vdev->vidioc_try_ext_ctrls           = cx18_try_ext_ctrls;
+       vdev->ioctl_ops = &cx18_ioctl_ops;
 }