go->hpi_ops->read_interrupt(go);
        if (wait_event_timeout(go->interrupt_waitq,
                                go->interrupt_available, 5*HZ) < 0) {
-               v4l2_err(go->video_dev, "timeout waiting for read interrupt\n");
+               v4l2_err(&go->v4l2_dev, "timeout waiting for read interrupt\n");
                return -1;
        }
        if (!go->interrupt_available)
 
        if (go7007_send_firmware(go, fw, fw_len) < 0 ||
                        go7007_read_interrupt(go, &intr_val, &intr_data) < 0) {
-               v4l2_err(go->video_dev, "error transferring firmware\n");
+               v4l2_err(&go->v4l2_dev, "error transferring firmware\n");
                rv = -1;
                goto start_error;
        }
        go->parse_length = 0;
        go->seen_frame = 0;
        if (go7007_stream_start(go) < 0) {
-               v4l2_err(go->video_dev, "error starting stream transfer\n");
+               v4l2_err(&go->v4l2_dev, "error starting stream transfer\n");
                rv = -1;
                goto start_error;
        }
        for (i = 0; i < length; ++i) {
                if (go->active_buf != NULL &&
                            go->active_buf->bytesused >= GO7007_BUF_SIZE - 3) {
-                       v4l2_info(go->video_dev, "dropping oversized frame\n");
+                       v4l2_info(&go->v4l2_dev, "dropping oversized frame\n");
                        go->active_buf->offset -= go->active_buf->bytesused;
                        go->active_buf->bytesused = 0;
                        go->active_buf->modet_active = 0;
                if (i2c_del_adapter(&go->i2c_adapter) == 0)
                        go->i2c_adapter_online = 0;
                else
-                       v4l2_err(go->video_dev,
+                       v4l2_err(&go->v4l2_dev,
                                "error removing I2C adapter!\n");
        }
 
 
  * user-space applications.
  */
 
+#include <media/v4l2-device.h>
+
 struct go7007;
 
 /* IDs to activate board-specific support code */
        int channel_number; /* for multi-channel boards like Adlink PCI-MPG24 */
        char name[64];
        struct video_device *video_dev;
+       struct v4l2_device v4l2_dev;
        int ref_count;
        enum { STATUS_INIT, STATUS_ONLINE, STATUS_SHUTDOWN } status;
        spinlock_t spinlock;
        unsigned short interrupt_data;
 };
 
+static inline struct go7007 *to_go7007(struct v4l2_device *v4l2_dev)
+{
+       return container_of(v4l2_dev, struct go7007, v4l2_dev);
+}
+
 /* All of these must be called with the hpi_lock mutex held! */
 #define go7007_interface_reset(go) \
                        ((go)->hpi_ops->interface_reset(go))
 
                        usb_rcvintpipe(usb->usbdev, 4),
                        usb->intr_urb->transfer_buffer, 2*sizeof(u16),
                        go7007_usb_readinterrupt_complete, go, 8);
-       usb_set_intfdata(intf, go);
+       usb_set_intfdata(intf, &go->v4l2_dev);
 
        /* Boot the GO7007 */
        if (go7007_boot_encoder(go, go->board_info->flags &
 
 static void go7007_usb_disconnect(struct usb_interface *intf)
 {
-       struct go7007 *go = usb_get_intfdata(intf);
+       struct go7007 *go = to_go7007(usb_get_intfdata(intf));
        struct go7007_usb *usb = go->hpi_context;
        struct urb *vurb, *aurb;
        int i;
 
        go->video_dev = video_device_alloc();
        if (go->video_dev == NULL)
                return -ENOMEM;
-       memcpy(go->video_dev, &go7007_template, sizeof(go7007_template));
+       *go->video_dev = go7007_template;
        go->video_dev->parent = go->dev;
        rv = video_register_device(go->video_dev, VFL_TYPE_GRABBER, -1);
        if (rv < 0) {
                go->video_dev = NULL;
                return rv;
        }
+       rv = v4l2_device_register(go->dev, &go->v4l2_dev);
+       if (rv < 0) {
+               video_device_release(go->video_dev);
+               go->video_dev = NULL;
+               return rv;
+       }
        video_set_drvdata(go->video_dev, go);
        ++go->ref_count;
        printk(KERN_INFO "%s: registered device video%d [v4l2]\n",
        mutex_unlock(&go->hw_lock);
        if (go->video_dev)
                video_unregister_device(go->video_dev);
+       v4l2_device_unregister(&go->v4l2_dev);
 }