Merge branch 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-2.6

* 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-2.6: (313 commits)
  V4L/DVB (9186): Added support for Prof 7300 DVB-S/S2 cards
  V4L/DVB (9185): S2API: Ensure we have a reasonable ROLLOFF default
  V4L/DVB (9184): cx24116: Change the default SNR units back to percentage by default.
  V4L/DVB (9183): S2API: Return error of the caller provides 0 commands.
  V4L/DVB (9182): S2API: Added support for DTV_HIERARCHY
  V4L/DVB (9181): S2API: Add support fot DTV_GUARD_INTERVAL and DTV_TRANSMISSION_MODE
  V4L/DVB (9180): S2API: Added support for DTV_CODE_RATE_HP/LP
  V4L/DVB (9179): S2API: frontend.h cleanup
  V4L/DVB (9178): cx24116: Add module parameter to return SNR as ESNO.
  V4L/DVB (9177): S2API: Change _8PSK / _16APSK to PSK_8 and APSK_16
  V4L/DVB (9176): Add support for DvbWorld USB cards with STV0288 demodulator.
  V4L/DVB (9175): Remove NULL pointer in stb6000 driver.
  V4L/DVB (9174): Allow custom inittab for ST STV0288 demodulator.
  V4L/DVB (9173): S2API: Remove the hardcoded command limit during validation
  V4L/DVB (9172): S2API: Bugfix related to DVB-S / DVB-S2 tuning for the legacy API.
  V4L/DVB (9171): S2API: Stop an OOPS if illegal commands are dumped in S2API.
  V4L/DVB (9170): cx24116: Sanity checking to data input via S2API to the cx24116 demod.
  V4L/DVB (9169): uvcvideo: Support two new Bison Electronics webcams.
  V4L/DVB (9168): Add support for MSI TV@nywhere Plus remote
  V4L/DVB: v4l2-dev: remove duplicated #include
  ...

14 files changed, 115 insertions, 117 deletions

diff --git a/drivers/media/video/ivtv/ivtv-cards.h b/drivers/media/video/ivtv/ivtv-cards.h
index 381af1bceef8..0b8fe85fb697 100644
--- a/drivers/media/video/ivtv/ivtv-cards.h
+++ b/drivers/media/video/ivtv/ivtv-cards.h
@@ -154,7 +154,7 @@
 #define IVTV_CAP_ENCODER (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_TUNER | \
                           V4L2_CAP_AUDIO | V4L2_CAP_READWRITE | V4L2_CAP_VBI_CAPTURE | \
                           V4L2_CAP_SLICED_VBI_CAPTURE)
-#define IVTV_CAP_DECODER (V4L2_CAP_VBI_OUTPUT | V4L2_CAP_VIDEO_OUTPUT | \
+#define IVTV_CAP_DECODER (V4L2_CAP_VIDEO_OUTPUT | \
                           V4L2_CAP_SLICED_VBI_OUTPUT | V4L2_CAP_VIDEO_OUTPUT_OVERLAY)
 
 struct ivtv_card_video_input {
diff --git a/drivers/media/video/ivtv/ivtv-driver.c b/drivers/media/video/ivtv/ivtv-driver.c
index 4afc7ea07e86..aeaa13f6cb36 100644
--- a/drivers/media/video/ivtv/ivtv-driver.c
+++ b/drivers/media/video/ivtv/ivtv-driver.c
@@ -61,14 +61,14 @@
 #include "tuner-xc2028.h"
 
 /* var to keep track of the number of array elements in use */
-int ivtv_cards_active = 0;
+int ivtv_cards_active;
 
 /* If you have already X v4l cards, then set this to X. This way
    the device numbers stay matched. Example: you have a WinTV card
    without radio and a PVR-350 with. Normally this would give a
    video1 device together with a radio0 device for the PVR. By
    setting this to 1 you ensure that radio0 is now also radio1. */
-int ivtv_first_minor = 0;
+int ivtv_first_minor;
 
 /* Master variable for all ivtv info */
 struct ivtv *ivtv_cards[IVTV_MAX_CARDS];
@@ -251,7 +251,7 @@ MODULE_PARM_DESC(newi2c,
                  "\t\t\t-1 is autodetect, 0 is off, 1 is on\n"
                  "\t\t\tDefault is autodetect");
 
-MODULE_PARM_DESC(ivtv_first_minor, "Set minor assigned to first card");
+MODULE_PARM_DESC(ivtv_first_minor, "Set kernel number assigned to first card");
 
 MODULE_AUTHOR("Kevin Thayer, Chris Kennedy, Hans Verkuil");
 MODULE_DESCRIPTION("CX23415/CX23416 driver");
@@ -655,9 +655,9 @@ done:
 
         if (itv->card == NULL) {
                 itv->card = ivtv_get_card(IVTV_CARD_PVR_150);
-                IVTV_ERR("Unknown card: vendor/device: %04x/%04x\n",
+                IVTV_ERR("Unknown card: vendor/device: [%04x:%04x]\n",
                      itv->dev->vendor, itv->dev->device);
-                IVTV_ERR("              subsystem vendor/device: %04x/%04x\n",
+                IVTV_ERR("              subsystem vendor/device: [%04x:%04x]\n",
                      itv->dev->subsystem_vendor, itv->dev->subsystem_device);
                 IVTV_ERR("              %s based\n", chipname);
                 IVTV_ERR("Defaulting to %s card\n", itv->card->name);
@@ -720,7 +720,7 @@ static int __devinit ivtv_init_struct1(struct ivtv *itv)
         itv->speed = 1000;
 
         /* VBI */
-        itv->vbi.in.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
+        itv->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
         itv->vbi.sliced_in = &itv->vbi.in.fmt.sliced;
 
         /* Init the sg table for osd/yuv output */
diff --git a/drivers/media/video/ivtv/ivtv-driver.h b/drivers/media/video/ivtv/ivtv-driver.h
index 2ceb5227637c..bc29436e8a3c 100644
--- a/drivers/media/video/ivtv/ivtv-driver.h
+++ b/drivers/media/video/ivtv/ivtv-driver.h
@@ -49,7 +49,6 @@
 #include <linux/i2c-algo-bit.h>
 #include <linux/list.h>
 #include <linux/unistd.h>
-#include <linux/byteorder/swab.h>
 #include <linux/pagemap.h>
 #include <linux/scatterlist.h>
 #include <linux/workqueue.h>
@@ -507,6 +506,8 @@ struct yuv_playback_info
         struct v4l2_rect main_rect;
         u32 v4l2_src_w;
         u32 v4l2_src_h;
+
+        u8 running; /* Have any frames been displayed */
 };
 
 #define IVTV_VBI_FRAMES 32
@@ -751,6 +752,12 @@ void ivtv_read_eeprom(struct ivtv *itv, struct tveeprom *tv);
 /* First-open initialization: load firmware, init cx25840, etc. */
 int ivtv_init_on_first_open(struct ivtv *itv);
 
+/* Test if the current VBI mode is raw (1) or sliced (0) */
+static inline int ivtv_raw_vbi(const struct ivtv *itv)
+{
+        return itv->vbi.in.type == V4L2_BUF_TYPE_VBI_CAPTURE;
+}
+
 /* This is a PCI post thing, where if the pci register is not read, then
    the write doesn't always take effect right away. By reading back the
    register any pending PCI writes will be performed (in order), and so
diff --git a/drivers/media/video/ivtv/ivtv-fileops.c b/drivers/media/video/ivtv/ivtv-fileops.c
index 7ec5c99f9ad1..b7457fc60ba5 100644
--- a/drivers/media/video/ivtv/ivtv-fileops.c
+++ b/drivers/media/video/ivtv/ivtv-fileops.c
@@ -39,7 +39,7 @@
    associated VBI streams are also automatically claimed.
    Possible error returns: -EBUSY if someone else has claimed
    the stream or 0 on success. */
-int ivtv_claim_stream(struct ivtv_open_id *id, int type)
+static int ivtv_claim_stream(struct ivtv_open_id *id, int type)
 {
         struct ivtv *itv = id->itv;
         struct ivtv_stream *s = &itv->streams[type];
@@ -78,7 +78,7 @@ int ivtv_claim_stream(struct ivtv_open_id *id, int type)
         if (type == IVTV_DEC_STREAM_TYPE_MPG) {
                 vbi_type = IVTV_DEC_STREAM_TYPE_VBI;
         } else if (type == IVTV_ENC_STREAM_TYPE_MPG &&
-                   itv->vbi.insert_mpeg && itv->vbi.sliced_in->service_set) {
+                   itv->vbi.insert_mpeg && !ivtv_raw_vbi(itv)) {
                 vbi_type = IVTV_ENC_STREAM_TYPE_VBI;
         } else {
                 return 0;
@@ -305,7 +305,7 @@ static size_t ivtv_copy_buf_to_user(struct ivtv_stream *s, struct ivtv_buffer *b
 
         if (len > ucount) len = ucount;
         if (itv->vbi.insert_mpeg && s->type == IVTV_ENC_STREAM_TYPE_MPG &&
-            itv->vbi.sliced_in->service_set && buf != &itv->vbi.sliced_mpeg_buf) {
+            !ivtv_raw_vbi(itv) && buf != &itv->vbi.sliced_mpeg_buf) {
                 const char *start = buf->buf + buf->readpos;
                 const char *p = start + 1;
                 const u8 *q;
@@ -372,7 +372,7 @@ static ssize_t ivtv_read(struct ivtv_stream *s, char __user *ubuf, size_t tot_co
         /* Each VBI buffer is one frame, the v4l2 API says that for VBI the frames should
            arrive one-by-one, so make sure we never output more than one VBI frame at a time */
         if (s->type == IVTV_DEC_STREAM_TYPE_VBI ||
-                        (s->type == IVTV_ENC_STREAM_TYPE_VBI && itv->vbi.sliced_in->service_set))
+            (s->type == IVTV_ENC_STREAM_TYPE_VBI && !ivtv_raw_vbi(itv)))
                 single_frame = 1;
 
         for (;;) {
diff --git a/drivers/media/video/ivtv/ivtv-fileops.h b/drivers/media/video/ivtv/ivtv-fileops.h
index 2c8d5186c9c3..df81e790147f 100644
--- a/drivers/media/video/ivtv/ivtv-fileops.h
+++ b/drivers/media/video/ivtv/ivtv-fileops.h
@@ -38,11 +38,6 @@ void ivtv_unmute(struct ivtv *itv);
 
 /* Utilities */
 
-/* Try to claim a stream for the filehandle. Return 0 on success,
-   -EBUSY if stream already claimed. Once a stream is claimed, it
-   remains claimed until the associated filehandle is closed. */
-int ivtv_claim_stream(struct ivtv_open_id *id, int type);
-
 /* Release a previously claimed stream. */
 void ivtv_release_stream(struct ivtv_stream *s);
 
diff --git a/drivers/media/video/ivtv/ivtv-gpio.c b/drivers/media/video/ivtv/ivtv-gpio.c
index bc22905ea20f..74a44844ccaf 100644
--- a/drivers/media/video/ivtv/ivtv-gpio.c
+++ b/drivers/media/video/ivtv/ivtv-gpio.c
@@ -124,7 +124,7 @@ void ivtv_reset_ir_gpio(struct ivtv *itv)
 }
 
 /* Xceive tuner reset function */
-int ivtv_reset_tuner_gpio(void *dev, int cmd, int value)
+int ivtv_reset_tuner_gpio(void *dev, int component, int cmd, int value)
 {
         struct i2c_algo_bit_data *algo = dev;
         struct ivtv *itv = algo->data;
diff --git a/drivers/media/video/ivtv/ivtv-gpio.h b/drivers/media/video/ivtv/ivtv-gpio.h
index 964a265d91a9..48b6291613a2 100644
--- a/drivers/media/video/ivtv/ivtv-gpio.h
+++ b/drivers/media/video/ivtv/ivtv-gpio.h
@@ -24,7 +24,7 @@
 /* GPIO stuff */
 void ivtv_gpio_init(struct ivtv *itv);
 void ivtv_reset_ir_gpio(struct ivtv *itv);
-int ivtv_reset_tuner_gpio(void *dev, int cmd, int value);
+int ivtv_reset_tuner_gpio(void *dev, int component, int cmd, int value);
 int ivtv_gpio(struct ivtv *itv, unsigned int command, void *arg);
 
 #endif
diff --git a/drivers/media/video/ivtv/ivtv-i2c.c b/drivers/media/video/ivtv/ivtv-i2c.c
index af154238fb9a..24700c211d52 100644
--- a/drivers/media/video/ivtv/ivtv-i2c.c
+++ b/drivers/media/video/ivtv/ivtv-i2c.c
@@ -64,8 +64,6 @@
 #include "ivtv-gpio.h"
 #include "ivtv-i2c.h"
 
-#include <media/ir-kbd-i2c.h>
-
 /* i2c implementation for cx23415/6 chip, ivtv project.
  * Author: Kevin Thayer (nufan_wfk at yahoo.com)
  */
diff --git a/drivers/media/video/ivtv/ivtv-ioctl.c b/drivers/media/video/ivtv/ivtv-ioctl.c
index 61030309d0ad..8696527ab134 100644
--- a/drivers/media/video/ivtv/ivtv-ioctl.c
+++ b/drivers/media/video/ivtv/ivtv-ioctl.c
@@ -101,18 +101,15 @@ void ivtv_expand_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
         }
 }
 
-static int check_service_set(struct v4l2_sliced_vbi_format *fmt, int is_pal)
+static void 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++) {
                         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 != 0;
 }
 
 u16 ivtv_get_service_set(struct v4l2_sliced_vbi_format *fmt)
@@ -474,7 +471,7 @@ static int ivtv_try_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format
         int h = fmt->fmt.pix.height;
 
         w = min(w, 720);
-        w = max(w, 1);
+        w = max(w, 2);
         h = min(h, itv->is_50hz ? 576 : 480);
         h = max(h, 2);
         ivtv_g_fmt_vid_cap(file, fh, fmt);
@@ -512,27 +509,20 @@ static int ivtv_try_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_
 static int ivtv_try_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *fmt)
 {
         struct ivtv_open_id *id = fh;
-        s32 w, h;
-        int field;
-        int ret;
+        struct ivtv *itv = id->itv;
+        s32 w = fmt->fmt.pix.width;
+        s32 h = fmt->fmt.pix.height;
+        int field = fmt->fmt.pix.field;
+        int ret = ivtv_g_fmt_vid_out(file, fh, fmt);
 
-        w = fmt->fmt.pix.width;
-        h = fmt->fmt.pix.height;
-        field = fmt->fmt.pix.field;
-        ret = ivtv_g_fmt_vid_out(file, fh, fmt);
+        w = min(w, 720);
+        w = max(w, 2);
+        h = min(h, itv->is_out_50hz ? 576 : 480);
+        h = max(h, 2);
+        if (id->type == IVTV_DEC_STREAM_TYPE_YUV)
+                fmt->fmt.pix.field = field;
         fmt->fmt.pix.width = w;
         fmt->fmt.pix.height = h;
-        if (!ret && id->type == IVTV_DEC_STREAM_TYPE_YUV) {
-                fmt->fmt.pix.field = field;
-                if (fmt->fmt.pix.width < 2)
-                        fmt->fmt.pix.width = 2;
-                if (fmt->fmt.pix.width > 720)
-                        fmt->fmt.pix.width = 720;
-                if (fmt->fmt.pix.height < 2)
-                        fmt->fmt.pix.height = 2;
-                if (fmt->fmt.pix.height > 576)
-                        fmt->fmt.pix.height = 576;
-        }
         return ret;
 }
 
@@ -560,9 +550,9 @@ static int ivtv_s_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *f
         struct ivtv_open_id *id = fh;
         struct ivtv *itv = id->itv;
         struct cx2341x_mpeg_params *p = &itv->params;
+        int ret = ivtv_try_fmt_vid_cap(file, fh, fmt);
         int w = fmt->fmt.pix.width;
         int h = fmt->fmt.pix.height;
-        int ret = ivtv_try_fmt_vid_cap(file, fh, fmt);
 
         if (ret)
                 return ret;
@@ -585,8 +575,11 @@ static int ivtv_s_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *f
 {
         struct ivtv *itv = ((struct ivtv_open_id *)fh)->itv;
 
+        if (!ivtv_raw_vbi(itv) && atomic_read(&itv->capturing) > 0)
+                return -EBUSY;
         itv->vbi.sliced_in->service_set = 0;
-        itv->video_dec_func(itv, VIDIOC_S_FMT, &itv->vbi.in);
+        itv->vbi.in.type = V4L2_BUF_TYPE_VBI_CAPTURE;
+        itv->video_dec_func(itv, VIDIOC_S_FMT, fmt);
         return ivtv_g_fmt_vbi_cap(file, fh, fmt);
 }
 
@@ -600,10 +593,10 @@ static int ivtv_s_fmt_sliced_vbi_cap(struct file *file, void *fh, struct v4l2_fo
         if (ret || id->type == IVTV_DEC_STREAM_TYPE_VBI)
                 return ret;
 
-        if (check_service_set(vbifmt, itv->is_50hz) == 0)
-                return -EINVAL;
-        if (atomic_read(&itv->capturing) > 0)
+        check_service_set(vbifmt, itv->is_50hz);
+        if (ivtv_raw_vbi(itv) && atomic_read(&itv->capturing) > 0)
                 return -EBUSY;
+        itv->vbi.in.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
         itv->video_dec_func(itv, VIDIOC_S_FMT, fmt);
         memcpy(itv->vbi.sliced_in, vbifmt, sizeof(*itv->vbi.sliced_in));
         return 0;
@@ -651,8 +644,6 @@ static int ivtv_s_fmt_vid_out(struct file *file, void *fh, struct v4l2_format *f
                 itv->dma_data_req_size =
                         1080 * ((yi->v4l2_src_h + 31) & ~31);
 
-        /* Force update of yuv registers */
-        yi->yuv_forced_update = 1;
         return 0;
 }
 
@@ -761,7 +752,7 @@ static int ivtv_querycap(struct file *file, void *fh, struct v4l2_capability *vc
 
         strlcpy(vcap->driver, IVTV_DRIVER_NAME, sizeof(vcap->driver));
         strlcpy(vcap->card, itv->card_name, sizeof(vcap->card));
-        strlcpy(vcap->bus_info, pci_name(itv->dev), sizeof(vcap->bus_info));
+        snprintf(vcap->bus_info, sizeof(vcap->bus_info), "PCI:%s", pci_name(itv->dev));
         vcap->version = IVTV_DRIVER_VERSION;        /* version */
         vcap->capabilities = itv->v4l2_cap;         /* capabilities */
         return 0;
@@ -1370,6 +1361,9 @@ static int ivtv_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
         if (itv->osd_global_alpha_state)
                 fb->flags |= V4L2_FBUF_FLAG_GLOBAL_ALPHA;
 
+        if (yi->track_osd)
+                fb->flags |= V4L2_FBUF_FLAG_OVERLAY;
+
         pixfmt &= 7;
 
         /* no local alpha for RGB565 or unknown formats */
@@ -1389,8 +1383,6 @@ static int ivtv_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
                 else
                         fb->flags |= V4L2_FBUF_FLAG_LOCAL_ALPHA;
         }
-        if (yi->track_osd)
-                fb->flags |= V4L2_FBUF_FLAG_OVERLAY;
 
         return 0;
 }
diff --git a/drivers/media/video/ivtv/ivtv-irq.c b/drivers/media/video/ivtv/ivtv-irq.c
index 34f3ab827858..f5d00ec5da73 100644
--- a/drivers/media/video/ivtv/ivtv-irq.c
+++ b/drivers/media/video/ivtv/ivtv-irq.c
@@ -753,7 +753,7 @@ static void ivtv_irq_vsync(struct ivtv *itv)
          */
         unsigned int frame = read_reg(0x28c0) & 1;
         struct yuv_playback_info *yi = &itv->yuv_info;
-        int last_dma_frame = atomic_read(&itv->yuv_info.next_dma_frame);
+        int last_dma_frame = atomic_read(&yi->next_dma_frame);
         struct yuv_frame_info *f = &yi->new_frame_info[last_dma_frame];
 
         if (0) IVTV_DEBUG_IRQ("DEC VSYNC\n");
@@ -772,6 +772,7 @@ static void ivtv_irq_vsync(struct ivtv *itv)
                                 next_dma_frame = (next_dma_frame + 1) % IVTV_YUV_BUFFERS;
                                 atomic_set(&yi->next_dma_frame, next_dma_frame);
                                 yi->fields_lapsed = -1;
+                                yi->running = 1;
                         }
                 }
         }
@@ -804,9 +805,11 @@ static void ivtv_irq_vsync(struct ivtv *itv)
                 }
 
                 /* Check if we need to update the yuv registers */
-                if ((yi->yuv_forced_update || f->update) && last_dma_frame != -1) {
+                if (yi->running && (yi->yuv_forced_update || f->update)) {
                         if (!f->update) {
-                                last_dma_frame = (u8)(last_dma_frame - 1) % IVTV_YUV_BUFFERS;
+                                last_dma_frame =
+                                        (u8)(atomic_read(&yi->next_dma_frame) -
+                                                 1) % IVTV_YUV_BUFFERS;
                                 f = &yi->new_frame_info[last_dma_frame];
                         }
 
diff --git a/drivers/media/video/ivtv/ivtv-streams.c b/drivers/media/video/ivtv/ivtv-streams.c
index 730e85d86fc8..5bbf31e39304 100644
--- a/drivers/media/video/ivtv/ivtv-streams.c
+++ b/drivers/media/video/ivtv/ivtv-streams.c
@@ -75,7 +75,7 @@ static const struct file_operations ivtv_v4l2_dec_fops = {
 static struct {
         const char *name;
         int vfl_type;
-        int minor_offset;
+        int num_offset;
         int dma, pio;
         enum v4l2_buf_type buf_type;
         const struct file_operations *fops;
@@ -171,8 +171,8 @@ static void ivtv_stream_init(struct ivtv *itv, int type)
 static int ivtv_prep_dev(struct ivtv *itv, int type)
 {
         struct ivtv_stream *s = &itv->streams[type];
-        int minor_offset = ivtv_stream_info[type].minor_offset;
-        int minor;
+        int num_offset = ivtv_stream_info[type].num_offset;
+        int num = itv->num + ivtv_first_minor + num_offset;
 
         /* These four fields are always initialized. If v4l2dev == NULL, then
            this stream is not in use. In that case no other fields but these
@@ -188,9 +188,6 @@ static int ivtv_prep_dev(struct ivtv *itv, int type)
         if (type >= IVTV_DEC_STREAM_TYPE_MPG && !(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT))
                 return 0;
 
-        /* card number + user defined offset + device offset */
-        minor = itv->num + ivtv_first_minor + minor_offset;
-
         /* User explicitly selected 0 buffers for these streams, so don't
            create them. */
         if (ivtv_stream_info[type].dma != PCI_DMA_NONE &&
@@ -211,7 +208,7 @@ static int ivtv_prep_dev(struct ivtv *itv, int type)
         snprintf(s->v4l2dev->name, sizeof(s->v4l2dev->name), "ivtv%d %s",
                         itv->num, s->name);
 
-        s->v4l2dev->minor = minor;
+        s->v4l2dev->num = num;
         s->v4l2dev->parent = &itv->dev->dev;
         s->v4l2dev->fops = ivtv_stream_info[type].fops;
         s->v4l2dev->release = video_device_release;
@@ -250,39 +247,46 @@ static int ivtv_reg_dev(struct ivtv *itv, int type)
 {
         struct ivtv_stream *s = &itv->streams[type];
         int vfl_type = ivtv_stream_info[type].vfl_type;
-        int minor;
+        int num;
 
         if (s->v4l2dev == NULL)
                 return 0;
 
-        minor = s->v4l2dev->minor;
+        num = s->v4l2dev->num;
+        /* card number + user defined offset + device offset */
+        if (type != IVTV_ENC_STREAM_TYPE_MPG) {
+                struct ivtv_stream *s_mpg = &itv->streams[IVTV_ENC_STREAM_TYPE_MPG];
+
+                if (s_mpg->v4l2dev)
+                        num = s_mpg->v4l2dev->num + ivtv_stream_info[type].num_offset;
+        }
+
         /* Register device. First try the desired minor, then any free one. */
-        if (video_register_device(s->v4l2dev, vfl_type, minor) &&
-                        video_register_device(s->v4l2dev, vfl_type, -1)) {
-                IVTV_ERR("Couldn't register v4l2 device for %s minor %d\n",
-                                s->name, minor);
+        if (video_register_device(s->v4l2dev, vfl_type, num)) {
+                IVTV_ERR("Couldn't register v4l2 device for %s kernel number %d\n",
+                                s->name, num);
                 video_device_release(s->v4l2dev);
                 s->v4l2dev = NULL;
                 return -ENOMEM;
         }
+        num = s->v4l2dev->num;
 
         switch (vfl_type) {
         case VFL_TYPE_GRABBER:
                 IVTV_INFO("Registered device video%d for %s (%d kB)\n",
-                        s->v4l2dev->minor, s->name, itv->options.kilobytes[type]);
+                        num, s->name, itv->options.kilobytes[type]);
                 break;
         case VFL_TYPE_RADIO:
                 IVTV_INFO("Registered device radio%d for %s\n",
-                        s->v4l2dev->minor - MINOR_VFL_TYPE_RADIO_MIN, s->name);
+                        num, s->name);
                 break;
         case VFL_TYPE_VBI:
                 if (itv->options.kilobytes[type])
                         IVTV_INFO("Registered device vbi%d for %s (%d kB)\n",
-                                s->v4l2dev->minor - MINOR_VFL_TYPE_VBI_MIN,
-                                s->name, itv->options.kilobytes[type]);
+                                num, s->name, itv->options.kilobytes[type]);
                 else
                         IVTV_INFO("Registered device vbi%d for %s\n",
-                                s->v4l2dev->minor - MINOR_VFL_TYPE_VBI_MIN, s->name);
+                                num, s->name);
                 break;
         }
         return 0;
@@ -330,7 +334,7 @@ void ivtv_streams_cleanup(struct ivtv *itv, int unregister)
 
 static void ivtv_vbi_setup(struct ivtv *itv)
 {
-        int raw = itv->vbi.sliced_in->service_set == 0;
+        int raw = ivtv_raw_vbi(itv);
         u32 data[CX2341X_MBOX_MAX_DATA];
         int lines;
         int i;
diff --git a/drivers/media/video/ivtv/ivtv-vbi.c b/drivers/media/video/ivtv/ivtv-vbi.c
index 1ce9deb1104f..4a37a7d2e69d 100644
--- a/drivers/media/video/ivtv/ivtv-vbi.c
+++ b/drivers/media/video/ivtv/ivtv-vbi.c
@@ -334,7 +334,7 @@ void ivtv_process_vbi_data(struct ivtv *itv, struct ivtv_buffer *buf,
         int y;
 
         /* Raw VBI data */
-        if (streamtype == IVTV_ENC_STREAM_TYPE_VBI && itv->vbi.sliced_in->service_set == 0) {
+        if (streamtype == IVTV_ENC_STREAM_TYPE_VBI && ivtv_raw_vbi(itv)) {
                 u8 type;
 
                 ivtv_buf_swap(buf);
diff --git a/drivers/media/video/ivtv/ivtv-yuv.c b/drivers/media/video/ivtv/ivtv-yuv.c
index 3092ff1d00a0..ee91107376c7 100644
--- a/drivers/media/video/ivtv/ivtv-yuv.c
+++ b/drivers/media/video/ivtv/ivtv-yuv.c
@@ -1147,6 +1147,7 @@ void ivtv_yuv_close(struct ivtv *itv)
         IVTV_DEBUG_YUV("ivtv_yuv_close\n");
         ivtv_waitq(&itv->vsync_waitq);
 
+        yi->running = 0;
         atomic_set(&yi->next_dma_frame, -1);
         atomic_set(&yi->next_fill_frame, 0);
 
diff --git a/drivers/media/video/ivtv/ivtvfb.c b/drivers/media/video/ivtv/ivtvfb.c
index bdfda48e56bf..8a4a150b12fb 100644
--- a/drivers/media/video/ivtv/ivtvfb.c
+++ b/drivers/media/video/ivtv/ivtvfb.c
@@ -275,7 +275,6 @@ static int ivtvfb_prep_dec_dma_to_device(struct ivtv *itv,
                                   int size_in_bytes)
 {
         DEFINE_WAIT(wait);
-        int ret = 0;
         int got_sig = 0;
 
         mutex_lock(&itv->udma.lock);
@@ -316,7 +315,7 @@ static int ivtvfb_prep_dec_dma_to_device(struct ivtv *itv,
                 return -EINTR;
         }
 
-        return ret;
+        return 0;
 }
 
 static int ivtvfb_prep_frame(struct ivtv *itv, int cmd, void __user *source,
@@ -368,11 +367,12 @@ static int ivtvfb_prep_frame(struct ivtv *itv, int cmd, void __user *source,
 }
 
 static ssize_t ivtvfb_write(struct fb_info *info, const char __user *buf,
-                     size_t count, loff_t *ppos)
+                                                size_t count, loff_t *ppos)
 {
         unsigned long p = *ppos;
         void *dst;
         int err = 0;
+        int dma_err;
         unsigned long total_size;
         struct ivtv *itv = (struct ivtv *) info->par;
         unsigned long dma_offset =
@@ -399,7 +399,6 @@ static ssize_t ivtvfb_write(struct fb_info *info, const char __user *buf,
         if (count + p > total_size) {
                 if (!err)
                         err = -ENOSPC;
-
                 count = total_size - p;
         }
 
@@ -408,39 +407,34 @@ static ssize_t ivtvfb_write(struct fb_info *info, const char __user *buf,
         if (info->fbops->fb_sync)
                 info->fbops->fb_sync(info);
 
-        if (!access_ok(VERIFY_READ, buf, count)) {
-                IVTVFB_WARN("Invalid userspace pointer 0x%08lx\n",
-                        (unsigned long)buf);
-                err = -EFAULT;
-        }
-
-        if (!err) {
-                /* If transfer size > threshold and both src/dst
-                addresses are aligned, use DMA */
-                if (count >= 4096 &&
-                    ((unsigned long)buf & 3) == ((unsigned long)dst & 3)) {
-                        /* Odd address = can't DMA. Align */
-                        if ((unsigned long)dst & 3) {
-                                lead = 4 - ((unsigned long)dst & 3);
-                                memcpy(dst, buf, lead);
-                                buf += lead;
-                                dst += lead;
-                        }
-                        /* DMA resolution is 32 bits */
-                        if ((count - lead) & 3)
-                                tail = (count - lead) & 3;
-                        /* DMA the data */
-                        dma_size = count - lead - tail;
-                        err = ivtvfb_prep_dec_dma_to_device(itv,
-                               p + lead + dma_offset, (void *)buf, dma_size);
-                        dst += dma_size;
-                        buf += dma_size;
-                        /* Copy any leftover data */
-                        if (tail)
-                                memcpy(dst, buf, tail);
-                } else {
-                        memcpy(dst, buf, count);
+        /* If transfer size > threshold and both src/dst
+        addresses are aligned, use DMA */
+        if (count >= 4096 &&
+            ((unsigned long)buf & 3) == ((unsigned long)dst & 3)) {
+                /* Odd address = can't DMA. Align */
+                if ((unsigned long)dst & 3) {
+                        lead = 4 - ((unsigned long)dst & 3);
+                        if (copy_from_user(dst, buf, lead))
+                                return -EFAULT;
+                        buf += lead;
+                        dst += lead;
                 }
+                /* DMA resolution is 32 bits */
+                if ((count - lead) & 3)
+                        tail = (count - lead) & 3;
+                /* DMA the data */
+                dma_size = count - lead - tail;
+                dma_err = ivtvfb_prep_dec_dma_to_device(itv,
+                       p + lead + dma_offset, (void __user *)buf, dma_size);
+                if (dma_err)
+                        return dma_err;
+                dst += dma_size;
+                buf += dma_size;
+                /* Copy any leftover data */
+                if (tail && copy_from_user(dst, buf, tail))
+                        return -EFAULT;
+        } else if (copy_from_user(dst, buf, count)) {
+                return -EFAULT;
         }
 
         if  (!err)
@@ -463,9 +457,12 @@ static int ivtvfb_ioctl(struct fb_info *info, unsigned int cmd, unsigned long ar
                         vblank.flags = FB_VBLANK_HAVE_COUNT |FB_VBLANK_HAVE_VCOUNT |
                                         FB_VBLANK_HAVE_VSYNC;
                         trace = read_reg(0x028c0) >> 16;
-                        if (itv->is_50hz && trace > 312) trace -= 312;
-                        else if (itv->is_60hz && trace > 262) trace -= 262;
-                        if (trace == 1) vblank.flags |= FB_VBLANK_VSYNCING;
+                        if (itv->is_50hz && trace > 312)
+                                trace -= 312;
+                        else if (itv->is_60hz && trace > 262)
+                                trace -= 262;
+                        if (trace == 1)
+                                vblank.flags |= FB_VBLANK_VSYNCING;
                         vblank.count = itv->last_vsync_field;
                         vblank.vcount = trace;
                         vblank.hcount = 0;
@@ -476,7 +473,8 @@ static int ivtvfb_ioctl(struct fb_info *info, unsigned int cmd, unsigned long ar
 
                 case FBIO_WAITFORVSYNC:
                         prepare_to_wait(&itv->vsync_waitq, &wait, TASK_INTERRUPTIBLE);
-                        if (!schedule_timeout(msecs_to_jiffies(50))) rc = -ETIMEDOUT;
+                        if (!schedule_timeout(msecs_to_jiffies(50)))
+                                rc = -ETIMEDOUT;
                         finish_wait(&itv->vsync_waitq, &wait);
                         return rc;