1 files changed, 218 insertions, 170 deletions

diff --git a/drivers/media/video/cx88/cx88-video.c b/drivers/media/video/cx88/cx88-video.c
index 5f58c103198a..61d4b29ec302 100644
--- a/drivers/media/video/cx88/cx88-video.c
+++ b/drivers/media/video/cx88/cx88-video.c
@@ -1,5 +1,4 @@
 /*
- * $Id: cx88-video.c,v 1.82 2005/07/22 05:13:34 mkrufky Exp $
  *
  * device driver for Conexant 2388x based TV cards
  * video4linux video interface
@@ -66,7 +65,7 @@ module_param(vid_limit,int,0644);
 MODULE_PARM_DESC(vid_limit,"capture memory limit in megabytes");
 
 #define dprintk(level,fmt, arg...)      if (video_debug >= level) \
-        printk(KERN_DEBUG "%s/0: " fmt, dev->core->name , ## arg)
+        printk(KERN_DEBUG "%s/0: " fmt, core->name , ## arg)
 
 /* ------------------------------------------------------------------ */
 
@@ -326,22 +325,23 @@ static const int CX8800_CTLS = ARRAY_SIZE(cx8800_ctls);
 
 static int res_get(struct cx8800_dev *dev, struct cx8800_fh *fh, unsigned int bit)
 {
+        struct cx88_core *core = dev->core;
         if (fh->resources & bit)
                 /* have it already allocated */
                 return 1;
 
         /* is it free? */
-        down(&dev->lock);
+        down(&core->lock);
         if (dev->resources & bit) {
                 /* no, someone else uses it */
-                up(&dev->lock);
+                up(&core->lock);
                 return 0;
         }
         /* it's free, grab it */
         fh->resources  |= bit;
         dev->resources |= bit;
         dprintk(1,"res: get %d\n",bit);
-        up(&dev->lock);
+        up(&core->lock);
         return 1;
 }
 
@@ -360,27 +360,29 @@ int res_locked(struct cx8800_dev *dev, unsigned int bit)
 static
 void res_free(struct cx8800_dev *dev, struct cx8800_fh *fh, unsigned int bits)
 {
+        struct cx88_core *core = dev->core;
         if ((fh->resources & bits) != bits)
                 BUG();
 
-        down(&dev->lock);
+        down(&core->lock);
         fh->resources  &= ~bits;
         dev->resources &= ~bits;
         dprintk(1,"res: put %d\n",bits);
-        up(&dev->lock);
+        up(&core->lock);
 }
 
 /* ------------------------------------------------------------------ */
 
-static int video_mux(struct cx8800_dev *dev, unsigned int input)
+/* static int video_mux(struct cx8800_dev *dev, unsigned int input) */
+static int video_mux(struct cx88_core *core, unsigned int input)
 {
-        struct cx88_core *core = dev->core;
+        /* struct cx88_core *core = dev->core; */
 
         dprintk(1,"video_mux: %d [vmux=%d,gpio=0x%x,0x%x,0x%x,0x%x]\n",
                 input, INPUT(input)->vmux,
                 INPUT(input)->gpio0,INPUT(input)->gpio1,
                 INPUT(input)->gpio2,INPUT(input)->gpio3);
-        dev->core->input = input;
+        core->input = input;
         cx_andor(MO_INPUT_FORMAT, 0x03 << 14, INPUT(input)->vmux << 14);
         cx_write(MO_GP3_IO, INPUT(input)->gpio3);
         cx_write(MO_GP0_IO, INPUT(input)->gpio0);
@@ -413,9 +415,9 @@ static int start_video_dma(struct cx8800_dev    *dev,
         struct cx88_core *core = dev->core;
 
         /* setup fifo + format */
-        cx88_sram_channel_setup(dev->core, &cx88_sram_channels[SRAM_CH21],
+        cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH21],
                                 buf->bpl, buf->risc.dma);
-        cx88_set_scale(dev->core, buf->vb.width, buf->vb.height, buf->vb.field);
+        cx88_set_scale(core, buf->vb.width, buf->vb.height, buf->vb.field);
         cx_write(MO_COLOR_CTRL, buf->fmt->cxformat | ColorFormatGamma);
 
         /* reset counter */
@@ -424,6 +426,14 @@ static int start_video_dma(struct cx8800_dev    *dev,
 
         /* enable irqs */
         cx_set(MO_PCI_INTMSK, core->pci_irqmask | 0x01);
+
+        /* Enables corresponding bits at PCI_INT_STAT:
+                bits 0 to 4: video, audio, transport stream, VIP, Host
+                bit 7: timer
+                bits 8 and 9: DMA complete for: SRC, DST
+                bits 10 and 11: BERR signal asserted for RISC: RD, WR
+                bits 12 to 15: BERR signal asserted for: BRDG, SRC, DST, IPB
+         */
         cx_set(MO_VID_INTMSK, 0x0f0011);
 
         /* enable capture */
@@ -431,7 +441,7 @@ static int start_video_dma(struct cx8800_dev    *dev,
 
         /* start dma */
         cx_set(MO_DEV_CNTRL2, (1<<5));
-        cx_set(MO_VID_DMACNTRL, 0x11);
+        cx_set(MO_VID_DMACNTRL, 0x11); /* Planar Y and packed FIFO and RISC enable */
 
         return 0;
 }
@@ -455,6 +465,7 @@ static int stop_video_dma(struct cx8800_dev    *dev)
 static int restart_video_queue(struct cx8800_dev    *dev,
                                struct cx88_dmaqueue *q)
 {
+        struct cx88_core *core = dev->core;
         struct cx88_buffer *buf, *prev;
         struct list_head *item;
 
@@ -524,12 +535,13 @@ buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
 {
         struct cx8800_fh   *fh  = q->priv_data;
         struct cx8800_dev  *dev = fh->dev;
+        struct cx88_core *core = dev->core;
         struct cx88_buffer *buf = container_of(vb,struct cx88_buffer,vb);
         int rc, init_buffer = 0;
 
         BUG_ON(NULL == fh->fmt);
-        if (fh->width  < 48 || fh->width  > norm_maxw(dev->core->tvnorm) ||
-            fh->height < 32 || fh->height > norm_maxh(dev->core->tvnorm))
+        if (fh->width  < 48 || fh->width  > norm_maxw(core->tvnorm) ||
+            fh->height < 32 || fh->height > norm_maxh(core->tvnorm))
                 return -EINVAL;
         buf->vb.size = (fh->width * fh->height * fh->fmt->depth) >> 3;
         if (0 != buf->vb.baddr  &&  buf->vb.bsize < buf->vb.size)
@@ -609,6 +621,7 @@ buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
         struct cx88_buffer    *prev;
         struct cx8800_fh      *fh   = vq->priv_data;
         struct cx8800_dev     *dev  = fh->dev;
+        struct cx88_core      *core = dev->core;
         struct cx88_dmaqueue  *q    = &dev->vidq;
 
         /* add jump to stopper */
@@ -701,6 +714,7 @@ static int video_open(struct inode *inode, struct file *file)
 {
         int minor = iminor(inode);
         struct cx8800_dev *h,*dev = NULL;
+        struct cx88_core *core;
         struct cx8800_fh *fh;
         struct list_head *list;
         enum v4l2_buf_type type = 0;
@@ -725,6 +739,8 @@ static int video_open(struct inode *inode, struct file *file)
         if (NULL == dev)
                 return -ENODEV;
 
+        core = dev->core;
+
         dprintk(1,"open minor=%d radio=%d type=%s\n",
                 minor,radio,v4l2_type_names[type]);
 
@@ -755,17 +771,16 @@ static int video_open(struct inode *inode, struct file *file)
                             fh);
 
         if (fh->radio) {
-                struct cx88_core *core = dev->core;
                 int board = core->board;
                 dprintk(1,"video_open: setting radio device\n");
                 cx_write(MO_GP3_IO, cx88_boards[board].radio.gpio3);
                 cx_write(MO_GP0_IO, cx88_boards[board].radio.gpio0);
                 cx_write(MO_GP1_IO, cx88_boards[board].radio.gpio1);
                 cx_write(MO_GP2_IO, cx88_boards[board].radio.gpio2);
-                dev->core->tvaudio = WW_FM;
+                core->tvaudio = WW_FM;
                 cx88_set_tvaudio(core);
                 cx88_set_stereo(core,V4L2_TUNER_MODE_STEREO,1);
-                cx88_call_i2c_clients(dev->core,AUDC_SET_RADIO,NULL);
+                cx88_call_i2c_clients(core,AUDC_SET_RADIO,NULL);
         }
 
         return 0;
@@ -857,6 +872,9 @@ static int video_release(struct inode *inode, struct file *file)
         videobuf_mmap_free(&fh->vbiq);
         file->private_data = NULL;
         kfree(fh);
+
+        cx88_call_i2c_clients (dev->core, TUNER_SET_STANDBY, NULL);
+
         return 0;
 }
 
@@ -870,9 +888,10 @@ video_mmap(struct file *file, struct vm_area_struct * vma)
 
 /* ------------------------------------------------------------------ */
 
-static int get_control(struct cx8800_dev *dev, struct v4l2_control *ctl)
+/* static int get_control(struct cx8800_dev *dev, struct v4l2_control *ctl) */
+static int get_control(struct cx88_core *core, struct v4l2_control *ctl)
 {
-        struct cx88_core *core = dev->core;
+        /* struct cx88_core *core = dev->core; */
         struct cx88_ctrl *c = NULL;
         u32 value;
         int i;
@@ -898,9 +917,10 @@ static int get_control(struct cx8800_dev *dev, struct v4l2_control *ctl)
         return 0;
 }
 
-static int set_control(struct cx8800_dev *dev, struct v4l2_control *ctl)
+/* static int set_control(struct cx8800_dev *dev, struct v4l2_control *ctl) */
+static int set_control(struct cx88_core *core, struct v4l2_control *ctl)
 {
-        struct cx88_core *core = dev->core;
+        /* struct cx88_core *core = dev->core; */
         struct cx88_ctrl *c = NULL;
         u32 v_sat_value;
         u32 value;
@@ -913,9 +933,9 @@ static int set_control(struct cx8800_dev *dev, struct v4l2_control *ctl)
                 return -EINVAL;
 
         if (ctl->value < c->v.minimum)
-                return -ERANGE;
+                ctl->value = c->v.minimum;
         if (ctl->value > c->v.maximum)
-                return -ERANGE;
+                ctl->value = c->v.maximum;
         switch (ctl->id) {
         case V4L2_CID_AUDIO_BALANCE:
                 value = (ctl->value < 0x40) ? (0x40 - ctl->value) : ctl->value;
@@ -946,7 +966,8 @@ static int set_control(struct cx8800_dev *dev, struct v4l2_control *ctl)
         return 0;
 }
 
-static void init_controls(struct cx8800_dev *dev)
+/* static void init_controls(struct cx8800_dev *dev) */
+static void init_controls(struct cx88_core *core)
 {
         static struct v4l2_control mute = {
                 .id    = V4L2_CID_AUDIO_MUTE,
@@ -969,11 +990,11 @@ static void init_controls(struct cx8800_dev *dev)
                 .value = 0x80,
         };
 
-        set_control(dev,&mute);
-        set_control(dev,&volume);
-        set_control(dev,&hue);
-        set_control(dev,&contrast);
-        set_control(dev,&brightness);
+        set_control(core,&mute);
+        set_control(core,&volume);
+        set_control(core,&hue);
+        set_control(core,&contrast);
+        set_control(core,&brightness);
 }
 
 /* ------------------------------------------------------------------ */
@@ -1004,6 +1025,8 @@ static int cx8800_g_fmt(struct cx8800_dev *dev, struct cx8800_fh *fh,
 static int cx8800_try_fmt(struct cx8800_dev *dev, struct cx8800_fh *fh,
                           struct v4l2_format *f)
 {
+        struct cx88_core *core = dev->core;
+
         switch (f->type) {
         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
         {
@@ -1016,8 +1039,8 @@ static int cx8800_try_fmt(struct cx8800_dev *dev, struct cx8800_fh *fh,
                         return -EINVAL;
 
                 field = f->fmt.pix.field;
-                maxw  = norm_maxw(dev->core->tvnorm);
-                maxh  = norm_maxh(dev->core->tvnorm);
+                maxw  = norm_maxw(core->tvnorm);
+                maxh  = norm_maxh(core->tvnorm);
 
                 if (V4L2_FIELD_ANY == field) {
                         field = (f->fmt.pix.height > maxh/2)
@@ -1101,12 +1124,14 @@ static int video_do_ioctl(struct inode *inode, struct file *file,
         if (video_debug > 1)
                 cx88_print_ioctl(core->name,cmd);
         switch (cmd) {
+
+        /* --- capabilities ------------------------------------------ */
         case VIDIOC_QUERYCAP:
         {
                 struct v4l2_capability *cap = arg;
 
                 memset(cap,0,sizeof(*cap));
-                strcpy(cap->driver, "cx8800");
+                strcpy(cap->driver, "cx8800");
                 strlcpy(cap->card, cx88_boards[core->board].name,
                         sizeof(cap->card));
                 sprintf(cap->bus_info,"PCI:%s",pci_name(dev->pci));
@@ -1116,12 +1141,128 @@ static int video_do_ioctl(struct inode *inode, struct file *file,
                         V4L2_CAP_READWRITE     |
                         V4L2_CAP_STREAMING     |
                         V4L2_CAP_VBI_CAPTURE   |
+                        V4L2_CAP_VIDEO_OVERLAY |
                         0;
                 if (UNSET != core->tuner_type)
                         cap->capabilities |= V4L2_CAP_TUNER;
                 return 0;
         }
 
+        /* --- capture ioctls ---------------------------------------- */
+        case VIDIOC_ENUM_FMT:
+        {
+                struct v4l2_fmtdesc *f = arg;
+                enum v4l2_buf_type type;
+                unsigned int index;
+
+                index = f->index;
+                type  = f->type;
+                switch (type) {
+                case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+                        if (index >= ARRAY_SIZE(formats))
+                                return -EINVAL;
+                        memset(f,0,sizeof(*f));
+                        f->index = index;
+                        f->type  = type;
+                        strlcpy(f->description,formats[index].name,sizeof(f->description));
+                        f->pixelformat = formats[index].fourcc;
+                        break;
+                default:
+                        return -EINVAL;
+                }
+                return 0;
+        }
+        case VIDIOC_G_FMT:
+        {
+                struct v4l2_format *f = arg;
+                return cx8800_g_fmt(dev,fh,f);
+        }
+        case VIDIOC_S_FMT:
+        {
+                struct v4l2_format *f = arg;
+                return cx8800_s_fmt(dev,fh,f);
+        }
+        case VIDIOC_TRY_FMT:
+        {
+                struct v4l2_format *f = arg;
+                return cx8800_try_fmt(dev,fh,f);
+        }
+
+        /* --- streaming capture ------------------------------------- */
+        case VIDIOCGMBUF:
+        {
+                struct video_mbuf *mbuf = arg;
+                struct videobuf_queue *q;
+                struct v4l2_requestbuffers req;
+                unsigned int i;
+
+                q = get_queue(fh);
+                memset(&req,0,sizeof(req));
+                req.type   = q->type;
+                req.count  = 8;
+                req.memory = V4L2_MEMORY_MMAP;
+                err = videobuf_reqbufs(q,&req);
+                if (err < 0)
+                        return err;
+                memset(mbuf,0,sizeof(*mbuf));
+                mbuf->frames = req.count;
+                mbuf->size   = 0;
+                for (i = 0; i < mbuf->frames; i++) {
+                        mbuf->offsets[i]  = q->bufs[i]->boff;
+                        mbuf->size       += q->bufs[i]->bsize;
+                }
+                return 0;
+        }
+        case VIDIOC_REQBUFS:
+                return videobuf_reqbufs(get_queue(fh), arg);
+
+        case VIDIOC_QUERYBUF:
+                return videobuf_querybuf(get_queue(fh), arg);
+
+        case VIDIOC_QBUF:
+                return videobuf_qbuf(get_queue(fh), arg);
+
+        case VIDIOC_DQBUF:
+                return videobuf_dqbuf(get_queue(fh), arg,
+                                        file->f_flags & O_NONBLOCK);
+
+        case VIDIOC_STREAMON:
+        {
+                int res = get_ressource(fh);
+
+                if (!res_get(dev,fh,res))
+                        return -EBUSY;
+                return videobuf_streamon(get_queue(fh));
+        }
+        case VIDIOC_STREAMOFF:
+        {
+                int res = get_ressource(fh);
+
+                err = videobuf_streamoff(get_queue(fh));
+                if (err < 0)
+                        return err;
+                res_free(dev,fh,res);
+                return 0;
+        }
+
+        default:
+                return cx88_do_ioctl( inode, file, fh->radio, core, cmd, arg, video_do_ioctl );
+        }
+        return 0;
+}
+
+int cx88_do_ioctl(struct inode *inode, struct file *file, int radio,
+                  struct cx88_core *core, unsigned int cmd, void *arg, v4l2_kioctl driver_ioctl)
+{
+        int err;
+
+        if (video_debug > 1)
+                cx88_print_ioctl(core->name,cmd);
+        printk( KERN_INFO "CORE IOCTL: 0x%x\n", cmd );
+        cx88_print_ioctl(core->name,cmd);
+        dprintk( 1, "CORE IOCTL: 0x%x\n", cmd );
+
+        switch (cmd) {
         /* ---------- tv norms ---------- */
         case VIDIOC_ENUMSTD:
         {
@@ -1156,9 +1297,9 @@ static int video_do_ioctl(struct inode *inode, struct file *file,
                 if (i == ARRAY_SIZE(tvnorms))
                         return -EINVAL;
 
-                down(&dev->lock);
-                cx88_set_tvnorm(dev->core,&tvnorms[i]);
-                up(&dev->lock);
+                down(&core->lock);
+                cx88_set_tvnorm(core,&tvnorms[i]);
+                up(&core->lock);
                 return 0;
         }
 
@@ -1199,7 +1340,7 @@ static int video_do_ioctl(struct inode *inode, struct file *file,
         {
                 unsigned int *i = arg;
 
-                *i = dev->core->input;
+                *i = core->input;
                 return 0;
         }
         case VIDIOC_S_INPUT:
@@ -1208,55 +1349,15 @@ static int video_do_ioctl(struct inode *inode, struct file *file,
 
                 if (*i >= 4)
                         return -EINVAL;
-                down(&dev->lock);
+                down(&core->lock);
                 cx88_newstation(core);
-                video_mux(dev,*i);
-                up(&dev->lock);
+                video_mux(core,*i);
+                up(&core->lock);
                 return 0;
         }
 
 
 
-        /* --- capture ioctls ---------------------------------------- */
-        case VIDIOC_ENUM_FMT:
-        {
-                struct v4l2_fmtdesc *f = arg;
-                enum v4l2_buf_type type;
-                unsigned int index;
-
-                index = f->index;
-                type  = f->type;
-                switch (type) {
-                case V4L2_BUF_TYPE_VIDEO_CAPTURE:
-                        if (index >= ARRAY_SIZE(formats))
-                                return -EINVAL;
-                        memset(f,0,sizeof(*f));
-                        f->index = index;
-                        f->type  = type;
-                        strlcpy(f->description,formats[index].name,sizeof(f->description));
-                        f->pixelformat = formats[index].fourcc;
-                        break;
-                default:
-                        return -EINVAL;
-                }
-                return 0;
-        }
-        case VIDIOC_G_FMT:
-        {
-                struct v4l2_format *f = arg;
-                return cx8800_g_fmt(dev,fh,f);
-        }
-        case VIDIOC_S_FMT:
-        {
-                struct v4l2_format *f = arg;
-                return cx8800_s_fmt(dev,fh,f);
-        }
-        case VIDIOC_TRY_FMT:
-        {
-                struct v4l2_format *f = arg;
-                return cx8800_try_fmt(dev,fh,f);
-        }
-
         /* --- controls ---------------------------------------------- */
         case VIDIOC_QUERYCTRL:
         {
@@ -1277,9 +1378,9 @@ static int video_do_ioctl(struct inode *inode, struct file *file,
                 return 0;
         }
         case VIDIOC_G_CTRL:
-                return get_control(dev,arg);
+                return get_control(core,arg);
         case VIDIOC_S_CTRL:
-                return set_control(dev,arg);
+                return set_control(core,arg);
 
         /* --- tuner ioctls ------------------------------------------ */
         case VIDIOC_G_TUNER:
@@ -1323,10 +1424,11 @@ static int video_do_ioctl(struct inode *inode, struct file *file,
                 if (UNSET == core->tuner_type)
                         return -EINVAL;
 
-                f->type = fh->radio ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
-                f->frequency = dev->freq;
+                /* f->type = fh->radio ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV; */
+                f->type = radio ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
+                f->frequency = core->freq;
 
-                cx88_call_i2c_clients(dev->core,VIDIOC_G_FREQUENCY,f);
+                cx88_call_i2c_clients(core,VIDIOC_G_FREQUENCY,f);
 
                 return 0;
         }
@@ -1338,83 +1440,26 @@ static int video_do_ioctl(struct inode *inode, struct file *file,
                         return -EINVAL;
                 if (f->tuner != 0)
                         return -EINVAL;
-                if (0 == fh->radio && f->type != V4L2_TUNER_ANALOG_TV)
+                if (0 == radio && f->type != V4L2_TUNER_ANALOG_TV)
                         return -EINVAL;
-                if (1 == fh->radio && f->type != V4L2_TUNER_RADIO)
+                if (1 == radio && f->type != V4L2_TUNER_RADIO)
                         return -EINVAL;
-                down(&dev->lock);
-                dev->freq = f->frequency;
+                down(&core->lock);
+                core->freq = f->frequency;
                 cx88_newstation(core);
-                cx88_call_i2c_clients(dev->core,VIDIOC_S_FREQUENCY,f);
+                cx88_call_i2c_clients(core,VIDIOC_S_FREQUENCY,f);
 
                 /* When changing channels it is required to reset TVAUDIO */
                 msleep (10);
                 cx88_set_tvaudio(core);
 
-                up(&dev->lock);
-                return 0;
-        }
-
-        /* --- streaming capture ------------------------------------- */
-        case VIDIOCGMBUF:
-        {
-                struct video_mbuf *mbuf = arg;
-                struct videobuf_queue *q;
-                struct v4l2_requestbuffers req;
-                unsigned int i;
-
-                q = get_queue(fh);
-                memset(&req,0,sizeof(req));
-                req.type   = q->type;
-                req.count  = 8;
-                req.memory = V4L2_MEMORY_MMAP;
-                err = videobuf_reqbufs(q,&req);
-                if (err < 0)
-                        return err;
-                memset(mbuf,0,sizeof(*mbuf));
-                mbuf->frames = req.count;
-                mbuf->size   = 0;
-                for (i = 0; i < mbuf->frames; i++) {
-                        mbuf->offsets[i]  = q->bufs[i]->boff;
-                        mbuf->size       += q->bufs[i]->bsize;
-                }
-                return 0;
-        }
-        case VIDIOC_REQBUFS:
-                return videobuf_reqbufs(get_queue(fh), arg);
-
-        case VIDIOC_QUERYBUF:
-                return videobuf_querybuf(get_queue(fh), arg);
-
-        case VIDIOC_QBUF:
-                return videobuf_qbuf(get_queue(fh), arg);
-
-        case VIDIOC_DQBUF:
-                return videobuf_dqbuf(get_queue(fh), arg,
-                                      file->f_flags & O_NONBLOCK);
-
-        case VIDIOC_STREAMON:
-        {
-                int res = get_ressource(fh);
-
-                if (!res_get(dev,fh,res))
-                        return -EBUSY;
-                return videobuf_streamon(get_queue(fh));
-        }
-        case VIDIOC_STREAMOFF:
-        {
-                int res = get_ressource(fh);
-
-                err = videobuf_streamoff(get_queue(fh));
-                if (err < 0)
-                        return err;
-                res_free(dev,fh,res);
+                up(&core->lock);
                 return 0;
         }
 
         default:
                 return v4l_compat_translate_ioctl(inode,file,cmd,arg,
-                                                  video_do_ioctl);
+                                                  driver_ioctl);
         }
         return 0;
 }
@@ -1461,7 +1506,7 @@ static int radio_do_ioctl(struct inode *inode, struct file *file,
                 memset(t,0,sizeof(*t));
                 strcpy(t->name, "Radio");
 
-                cx88_call_i2c_clients(dev->core,VIDIOC_G_TUNER,t);
+                cx88_call_i2c_clients(core,VIDIOC_G_TUNER,t);
                 return 0;
         }
         case VIDIOC_ENUMINPUT:
@@ -1501,8 +1546,8 @@ static int radio_do_ioctl(struct inode *inode, struct file *file,
                 if (v->tuner) /* Only tuner 0 */
                         return -EINVAL;
 
-                cx88_call_i2c_clients(dev->core,VIDIOCSTUNER,v);
-                return 0;
+                cx88_call_i2c_clients(core,VIDIOCSTUNER,v);
+                return 0;
         }
         case VIDIOC_S_TUNER:
         {
@@ -1511,7 +1556,7 @@ static int radio_do_ioctl(struct inode *inode, struct file *file,
                 if (0 != t->index)
                         return -EINVAL;
 
-                cx88_call_i2c_clients(dev->core,VIDIOC_S_TUNER,t);
+                cx88_call_i2c_clients(core,VIDIOC_S_TUNER,t);
 
                 return 0;
         }
@@ -1569,7 +1614,7 @@ static void cx8800_vid_timeout(unsigned long data)
         struct cx88_buffer *buf;
         unsigned long flags;
 
-        cx88_sram_channel_dump(dev->core, &cx88_sram_channels[SRAM_CH21]);
+        cx88_sram_channel_dump(core, &cx88_sram_channels[SRAM_CH21]);
 
         cx_clear(MO_VID_DMACNTRL, 0x11);
         cx_clear(VID_CAPTURE_CONTROL, 0x06);
@@ -1614,14 +1659,14 @@ static void cx8800_vid_irq(struct cx8800_dev *dev)
                 printk(KERN_WARNING "%s/0: video risc op code error\n",core->name);
                 cx_clear(MO_VID_DMACNTRL, 0x11);
                 cx_clear(VID_CAPTURE_CONTROL, 0x06);
-                cx88_sram_channel_dump(dev->core, &cx88_sram_channels[SRAM_CH21]);
+                cx88_sram_channel_dump(core, &cx88_sram_channels[SRAM_CH21]);
         }
 
         /* risc1 y */
         if (status & 0x01) {
                 spin_lock(&dev->slock);
                 count = cx_read(MO_VIDY_GPCNT);
-                cx88_wakeup(dev->core, &dev->vidq, count);
+                cx88_wakeup(core, &dev->vidq, count);
                 spin_unlock(&dev->slock);
         }
 
@@ -1629,7 +1674,7 @@ static void cx8800_vid_irq(struct cx8800_dev *dev)
         if (status & 0x08) {
                 spin_lock(&dev->slock);
                 count = cx_read(MO_VBI_GPCNT);
-                cx88_wakeup(dev->core, &dev->vbiq, count);
+                cx88_wakeup(core, &dev->vbiq, count);
                 spin_unlock(&dev->slock);
         }
 
@@ -1798,7 +1843,6 @@ static int __devinit cx8800_initdev(struct pci_dev *pci_dev,
         }
 
         /* initialize driver struct */
-        init_MUTEX(&dev->lock);
         spin_lock_init(&dev->slock);
         core->tvnorm = tvnorms;
 
@@ -1835,6 +1879,7 @@ static int __devinit cx8800_initdev(struct pci_dev *pci_dev,
                 request_module("tuner");
         if (core->tda9887_conf)
                 request_module("tda9887");
+
         /* register v4l devices */
         dev->video_dev = cx88_vdev_init(core,dev->pci,
                                         &cx8800_video_template,"video");
@@ -1878,11 +1923,11 @@ static int __devinit cx8800_initdev(struct pci_dev *pci_dev,
         pci_set_drvdata(pci_dev,dev);
 
         /* initial device configuration */
-        down(&dev->lock);
-        init_controls(dev);
-        cx88_set_tvnorm(dev->core,tvnorms);
-        video_mux(dev,0);
-        up(&dev->lock);
+        down(&core->lock);
+        init_controls(core);
+        cx88_set_tvnorm(core,tvnorms);
+        video_mux(core,0);
+        up(&core->lock);
 
         /* start tvaudio thread */
         if (core->tuner_type != TUNER_ABSENT)
@@ -1902,14 +1947,15 @@ fail_free:
 static void __devexit cx8800_finidev(struct pci_dev *pci_dev)
 {
         struct cx8800_dev *dev = pci_get_drvdata(pci_dev);
+        struct cx88_core *core = dev->core;
 
         /* stop thread */
-        if (dev->core->kthread) {
-                kthread_stop(dev->core->kthread);
-                dev->core->kthread = NULL;
+        if (core->kthread) {
+                kthread_stop(core->kthread);
+                core->kthread = NULL;
         }
 
-        cx88_shutdown(dev->core); /* FIXME */
+        cx88_shutdown(core); /* FIXME */
         pci_disable_device(pci_dev);
 
         /* unregister stuff */
@@ -1921,7 +1967,7 @@ static void __devexit cx8800_finidev(struct pci_dev *pci_dev)
         /* free memory */
         btcx_riscmem_free(dev->pci,&dev->vidq.stopper);
         list_del(&dev->devlist);
-        cx88_core_put(dev->core,dev->pci);
+        cx88_core_put(core,dev->pci);
         kfree(dev);
 }
 
@@ -1945,7 +1991,7 @@ static int cx8800_suspend(struct pci_dev *pci_dev, pm_message_t state)
         spin_unlock(&dev->slock);
 
         /* FIXME -- shutdown device */
-        cx88_shutdown(dev->core);
+        cx88_shutdown(core);
 
         pci_save_state(pci_dev);
         if (0 != pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state))) {
@@ -1968,7 +2014,7 @@ static int cx8800_resume(struct pci_dev *pci_dev)
         pci_restore_state(pci_dev);
 
         /* FIXME: re-initialize hardware */
-        cx88_reset(dev->core);
+        cx88_reset(core);
 
         /* restart video+vbi capture */
         spin_lock(&dev->slock);
@@ -2030,6 +2076,8 @@ static void cx8800_fini(void)
 module_init(cx8800_init);
 module_exit(cx8800_fini);
 
+EXPORT_SYMBOL(cx88_do_ioctl);
+
 /* ----------------------------------------------------------- */
 /*
  * Local variables: