}
 
 static const struct v4l2_subdev_video_ops adv7180_video_ops = {
+       .s_std = adv7180_s_std,
        .querystd = adv7180_querystd,
        .g_input_status = adv7180_g_input_status,
        .s_routing = adv7180_s_routing,
 };
 
 static const struct v4l2_subdev_core_ops adv7180_core_ops = {
-       .s_std = adv7180_s_std,
        .s_power = adv7180_s_power,
 };
 
 
 
 static const struct v4l2_subdev_core_ops adv7183_core_ops = {
        .log_status = adv7183_log_status,
-       .g_std = adv7183_g_std,
-       .s_std = adv7183_s_std,
        .reset = adv7183_reset,
 #ifdef CONFIG_VIDEO_ADV_DEBUG
        .g_register = adv7183_g_register,
 };
 
 static const struct v4l2_subdev_video_ops adv7183_video_ops = {
+       .g_std = adv7183_g_std,
+       .s_std = adv7183_s_std,
        .s_routing = adv7183_s_routing,
        .querystd = adv7183_querystd,
        .g_input_status = adv7183_g_input_status,
 
 
 static const struct v4l2_subdev_core_ops adv7842_core_ops = {
        .log_status = adv7842_log_status,
-       .g_std = adv7842_g_std,
-       .s_std = adv7842_s_std,
        .ioctl = adv7842_ioctl,
        .interrupt_service_routine = adv7842_isr,
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 };
 
 static const struct v4l2_subdev_video_ops adv7842_video_ops = {
+       .g_std = adv7842_g_std,
+       .s_std = adv7842_s_std,
        .s_routing = adv7842_s_routing,
        .querystd = adv7842_querystd,
        .g_input_status = adv7842_g_input_status,
 
        .s_ctrl = v4l2_subdev_s_ctrl,
        .queryctrl = v4l2_subdev_queryctrl,
        .querymenu = v4l2_subdev_querymenu,
-       .s_std = bt819_s_std,
 };
 
 static const struct v4l2_subdev_video_ops bt819_video_ops = {
+       .s_std = bt819_s_std,
        .s_routing = bt819_s_routing,
        .s_stream = bt819_s_stream,
        .querystd = bt819_querystd,
 
        .g_ext_ctrls = v4l2_subdev_g_ext_ctrls,
        .queryctrl = v4l2_subdev_queryctrl,
        .querymenu = v4l2_subdev_querymenu,
-       .s_std = cx25840_s_std,
-       .g_std = cx25840_g_std,
        .reset = cx25840_reset,
        .load_fw = cx25840_load_fw,
        .s_io_pin_config = common_s_io_pin_config,
 };
 
 static const struct v4l2_subdev_video_ops cx25840_video_ops = {
+       .s_std = cx25840_s_std,
+       .g_std = cx25840_g_std,
        .s_routing = cx25840_s_video_routing,
        .s_mbus_fmt = cx25840_s_mbus_fmt,
        .s_stream = cx25840_s_stream,
 
 
 /* ----------------------------------------------------------------------- */
 
-static const struct v4l2_subdev_core_ops ks0127_core_ops = {
-       .s_std = ks0127_s_std,
-};
-
 static const struct v4l2_subdev_video_ops ks0127_video_ops = {
+       .s_std = ks0127_s_std,
        .s_routing = ks0127_s_routing,
        .s_stream = ks0127_s_stream,
        .querystd = ks0127_querystd,
 };
 
 static const struct v4l2_subdev_ops ks0127_ops = {
-       .core = &ks0127_core_ops,
        .video = &ks0127_video_ops,
 };
 
 
 };
 
 static struct v4l2_subdev_video_ops ml86v7667_subdev_video_ops = {
+       .s_std = ml86v7667_s_std,
        .querystd = ml86v7667_querystd,
        .g_input_status = ml86v7667_g_input_status,
        .enum_mbus_fmt = ml86v7667_enum_mbus_fmt,
 };
 
 static struct v4l2_subdev_core_ops ml86v7667_subdev_core_ops = {
-       .s_std = ml86v7667_s_std,
 #ifdef CONFIG_VIDEO_ADV_DEBUG
        .g_register = ml86v7667_g_register,
        .s_register = ml86v7667_s_register,
 
        .s_ctrl = v4l2_subdev_s_ctrl,
        .queryctrl = v4l2_subdev_queryctrl,
        .querymenu = v4l2_subdev_querymenu,
-       .s_std = msp_s_std,
 };
 
 static const struct v4l2_subdev_video_ops msp_video_ops = {
+       .s_std = msp_s_std,
        .querystd = msp_querystd,
 };
 
 
 
 static const struct v4l2_subdev_core_ops saa6752hs_core_ops = {
        .init = saa6752hs_init,
-       .s_std = saa6752hs_s_std,
 };
 
 static const struct v4l2_subdev_video_ops saa6752hs_video_ops = {
+       .s_std = saa6752hs_s_std,
        .s_mbus_fmt = saa6752hs_s_mbus_fmt,
        .try_mbus_fmt = saa6752hs_try_mbus_fmt,
        .g_mbus_fmt = saa6752hs_g_mbus_fmt,
 
        .s_ctrl = v4l2_subdev_s_ctrl,
        .queryctrl = v4l2_subdev_queryctrl,
        .querymenu = v4l2_subdev_querymenu,
-       .s_std = saa7110_s_std,
 };
 
 static const struct v4l2_subdev_video_ops saa7110_video_ops = {
+       .s_std = saa7110_s_std,
        .s_routing = saa7110_s_routing,
        .s_stream = saa7110_s_stream,
        .querystd = saa7110_querystd,
 
        .s_ctrl = v4l2_subdev_s_ctrl,
        .queryctrl = v4l2_subdev_queryctrl,
        .querymenu = v4l2_subdev_querymenu,
-       .s_std = saa711x_s_std,
        .reset = saa711x_reset,
        .s_gpio = saa711x_s_gpio,
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 };
 
 static const struct v4l2_subdev_video_ops saa711x_video_ops = {
+       .s_std = saa711x_s_std,
        .s_routing = saa711x_s_routing,
        .s_crystal_freq = saa711x_s_crystal_freq,
        .s_mbus_fmt = saa711x_s_mbus_fmt,
 
        .g_register = saa717x_g_register,
        .s_register = saa717x_s_register,
 #endif
-       .s_std = saa717x_s_std,
        .g_ext_ctrls = v4l2_subdev_g_ext_ctrls,
        .try_ext_ctrls = v4l2_subdev_try_ext_ctrls,
        .s_ext_ctrls = v4l2_subdev_s_ext_ctrls,
 };
 
 static const struct v4l2_subdev_video_ops saa717x_video_ops = {
+       .s_std = saa717x_s_std,
        .s_routing = saa717x_s_video_routing,
        .s_mbus_fmt = saa717x_s_mbus_fmt,
        .s_stream = saa717x_s_stream,
 
 static const struct v4l2_subdev_core_ops saa7191_core_ops = {
        .g_ctrl = saa7191_g_ctrl,
        .s_ctrl = saa7191_s_ctrl,
-       .s_std = saa7191_s_std,
 };
 
 static const struct v4l2_subdev_video_ops saa7191_video_ops = {
+       .s_std = saa7191_s_std,
        .s_routing = saa7191_s_routing,
        .querystd = saa7191_querystd,
        .g_input_status = saa7191_g_input_status,
 
 }
 
 static struct v4l2_subdev_core_ops tw9910_subdev_core_ops = {
-       .s_std          = tw9910_s_std,
-       .g_std          = tw9910_g_std,
 #ifdef CONFIG_VIDEO_ADV_DEBUG
        .g_register     = tw9910_g_register,
        .s_register     = tw9910_s_register,
 }
 
 static struct v4l2_subdev_video_ops tw9910_subdev_video_ops = {
+       .s_std          = tw9910_s_std,
+       .g_std          = tw9910_g_std,
        .s_stream       = tw9910_s_stream,
        .g_mbus_fmt     = tw9910_g_fmt,
        .s_mbus_fmt     = tw9910_s_fmt,
 
 
 /* --------------------------------------------------------------------------*/
 
-static const struct v4l2_subdev_core_ops sony_btf_mpx_core_ops = {
-       .s_std = sony_btf_mpx_s_std,
-};
-
 static const struct v4l2_subdev_tuner_ops sony_btf_mpx_tuner_ops = {
        .s_tuner = sony_btf_mpx_s_tuner,
        .g_tuner = sony_btf_mpx_g_tuner,
 };
 
+static const struct v4l2_subdev_video_ops sony_btf_mpx_video_ops = {
+       .s_std = sony_btf_mpx_s_std,
+};
+
 static const struct v4l2_subdev_ops sony_btf_mpx_ops = {
-       .core = &sony_btf_mpx_core_ops,
        .tuner = &sony_btf_mpx_tuner_ops,
+       .video = &sony_btf_mpx_video_ops,
 };
 
 /* --------------------------------------------------------------------------*/
 
        .s_ctrl = v4l2_subdev_s_ctrl,
        .queryctrl = v4l2_subdev_queryctrl,
        .querymenu = v4l2_subdev_querymenu,
-       .s_std = tvaudio_s_std,
 };
 
 static const struct v4l2_subdev_tuner_ops tvaudio_tuner_ops = {
        .s_routing = tvaudio_s_routing,
 };
 
+static const struct v4l2_subdev_video_ops tvaudio_video_ops = {
+       .s_std = tvaudio_s_std,
+};
+
 static const struct v4l2_subdev_ops tvaudio_ops = {
        .core = &tvaudio_core_ops,
        .tuner = &tvaudio_tuner_ops,
        .audio = &tvaudio_audio_ops,
+       .video = &tvaudio_video_ops,
 };
 
 /* ----------------------------------------------------------------------- */
 
        .s_ctrl = v4l2_subdev_s_ctrl,
        .queryctrl = v4l2_subdev_queryctrl,
        .querymenu = v4l2_subdev_querymenu,
-       .s_std = tvp514x_s_std,
 };
 
 static const struct v4l2_subdev_video_ops tvp514x_video_ops = {
+       .s_std = tvp514x_s_std,
        .s_routing = tvp514x_s_routing,
        .querystd = tvp514x_querystd,
        .enum_mbus_fmt = tvp514x_enum_mbus_fmt,
 
 
 static const struct v4l2_subdev_core_ops tvp5150_core_ops = {
        .log_status = tvp5150_log_status,
-       .s_std = tvp5150_s_std,
        .reset = tvp5150_reset,
 #ifdef CONFIG_VIDEO_ADV_DEBUG
        .g_register = tvp5150_g_register,
 };
 
 static const struct v4l2_subdev_video_ops tvp5150_video_ops = {
+       .s_std = tvp5150_s_std,
        .s_routing = tvp5150_s_routing,
        .enum_mbus_fmt = tvp5150_enum_mbus_fmt,
        .s_mbus_fmt = tvp5150_mbus_fmt,
 
 };
 
 static const struct v4l2_subdev_video_ops tw2804_video_ops = {
+       .s_std = tw2804_s_std,
        .s_routing = tw2804_s_video_routing,
 };
 
 static const struct v4l2_subdev_core_ops tw2804_core_ops = {
        .log_status = tw2804_log_status,
-       .s_std = tw2804_s_std,
 };
 
 static const struct v4l2_subdev_ops tw2804_ops = {
 
 
 static const struct v4l2_subdev_core_ops tw9903_core_ops = {
        .log_status = tw9903_log_status,
-       .s_std = tw9903_s_std,
 };
 
 static const struct v4l2_subdev_video_ops tw9903_video_ops = {
+       .s_std = tw9903_s_std,
        .s_routing = tw9903_s_video_routing,
 };
 
 
 
 static const struct v4l2_subdev_core_ops tw9906_core_ops = {
        .log_status = tw9906_log_status,
-       .s_std = tw9906_s_std,
 };
 
 static const struct v4l2_subdev_video_ops tw9906_video_ops = {
+       .s_std = tw9906_s_std,
        .s_routing = tw9906_s_video_routing,
 };
 
 
 
 static const struct v4l2_subdev_core_ops vp27smpx_core_ops = {
        .log_status = vp27smpx_log_status,
-       .s_std = vp27smpx_s_std,
 };
 
 static const struct v4l2_subdev_tuner_ops vp27smpx_tuner_ops = {
        .g_tuner = vp27smpx_g_tuner,
 };
 
+static const struct v4l2_subdev_video_ops vp27smpx_video_ops = {
+       .s_std = vp27smpx_s_std,
+};
+
 static const struct v4l2_subdev_ops vp27smpx_ops = {
        .core = &vp27smpx_core_ops,
        .tuner = &vp27smpx_tuner_ops,
+       .video = &vp27smpx_video_ops,
 };
 
 /* ----------------------------------------------------------------------- */
 
        .s_ctrl = v4l2_subdev_s_ctrl,
        .queryctrl = v4l2_subdev_queryctrl,
        .querymenu = v4l2_subdev_querymenu,
-       .s_std = vpx3220_s_std,
 };
 
 static const struct v4l2_subdev_video_ops vpx3220_video_ops = {
+       .s_std = vpx3220_s_std,
        .s_routing = vpx3220_s_routing,
        .s_stream = vpx3220_s_stream,
        .querystd = vpx3220_querystd,
 
                break;
        }
        id = tvnorm->v4l2_id;
-       bttv_call_all(btv, core, s_std, id);
+       bttv_call_all(btv, video, s_std, id);
 
        return 0;
 }
 
        .log_status = cx18_av_log_status,
        .load_fw = cx18_av_load_fw,
        .reset = cx18_av_reset,
-       .s_std = cx18_av_s_std,
 #ifdef CONFIG_VIDEO_ADV_DEBUG
        .g_register = cx18_av_g_register,
        .s_register = cx18_av_s_register,
 };
 
 static const struct v4l2_subdev_video_ops cx18_av_video_ops = {
+       .s_std = cx18_av_s_std,
        .s_routing = cx18_av_s_video_routing,
        .s_stream = cx18_av_s_stream,
        .s_mbus_fmt = cx18_av_s_mbus_fmt,
 
                /* Mark that the radio is no longer in use */
                clear_bit(CX18_F_I_RADIO_USER, &cx->i_flags);
                /* Switch tuner to TV */
-               cx18_call_all(cx, core, s_std, cx->std);
+               cx18_call_all(cx, video, s_std, cx->std);
                /* Select correct audio input (i.e. TV tuner or Line in) */
                cx18_audio_set_io(cx);
                if (atomic_read(&cx->ana_capturing) > 0) {
 
 
 static const struct v4l2_subdev_core_ops gpiomux_core_ops = {
        .log_status = gpiomux_log_status,
-       .s_std = gpiomux_s_std,
 };
 
 static const struct v4l2_subdev_tuner_ops gpiomux_tuner_ops = {
        .s_routing = gpiomux_s_audio_routing,
 };
 
+static const struct v4l2_subdev_video_ops gpiomux_video_ops = {
+       .s_std = gpiomux_s_std,
+};
+
 static const struct v4l2_subdev_ops gpiomux_ops = {
        .core = &gpiomux_core_ops,
        .tuner = &gpiomux_tuner_ops,
        .audio = &gpiomux_audio_ops,
+       .video = &gpiomux_video_ops,
 };
 
 /*
 
                        (unsigned long long) cx->std);
 
        /* Tuner */
-       cx18_call_all(cx, core, s_std, cx->std);
+       cx18_call_all(cx, video, s_std, cx->std);
        return 0;
 }
 
 
 
        dev->tvnorm = norm;
 
-       call_all(dev, core, s_std, norm);
+       call_all(dev, video, s_std, norm);
 
        return 0;
 }
                fe = &dev->ts1.analog_fe;
 
        if (fe && fe->ops.tuner_ops.set_analog_params) {
-               call_all(dev, core, s_std, dev->tvnorm);
+               call_all(dev, video, s_std, dev->tvnorm);
                fe->ops.tuner_ops.set_analog_params(fe, ¶ms);
        }
        else
 
        set_tvaudio(core);
 
        // tell i2c chips
-       call_all(core, core, s_std, norm);
+       call_all(core, video, s_std, norm);
 
        /* The chroma_agc control should be inaccessible if the video format is SECAM */
        v4l2_ctrl_grab(core->chroma_agc, cxiformat == VideoFormatSECAM);
 
                /* Mark that the radio is no longer in use */
                clear_bit(IVTV_F_I_RADIO_USER, &itv->i_flags);
                /* Switch tuner to TV */
-               ivtv_call_all(itv, core, s_std, itv->std);
+               ivtv_call_all(itv, video, s_std, itv->std);
                /* Select correct audio input (i.e. TV tuner or Line in) */
                ivtv_audio_set_io(itv);
                if (itv->hw_flags & IVTV_HW_SAA711X) {
 
                itv->vbi.sliced_decoder_line_size = itv->is_60hz ? 272 : 284;
 
        /* Tuner */
-       ivtv_call_all(itv, core, s_std, itv->std);
+       ivtv_call_all(itv, video, s_std, itv->std);
 }
 
 void ivtv_s_std_dec(struct ivtv *itv, v4l2_std_id std)
 
        saa7134_set_decoder(dev);
 
        if (card_in(dev, dev->ctl_input).tv)
-               saa_call_all(dev, core, s_std, dev->tvnorm->id);
+               saa_call_all(dev, video, s_std, dev->tvnorm->id);
        /* Set the correct norm for the saa6752hs. This function
           does nothing if there is no saa6752hs. */
-       saa_call_empress(dev, core, s_std, dev->tvnorm->id);
+       saa_call_empress(dev, video, s_std, dev->tvnorm->id);
 }
 
 static void set_h_prescale(struct saa7134_dev *dev, int task, int prescale)
 
        tea6420_route(mxb, 6);
 
        /* select video mode in saa7111a */
-       saa7111a_call(mxb, core, s_std, std);
+       saa7111a_call(mxb, video, s_std, std);
 
        /* select tuner-output on saa7111a */
        i = 0;
        /* These two gpio calls set the GPIO pins that control the tda9820 */
        saa7146_write(dev, GPIO_CTRL, 0x00404050);
        saa7111a_call(mxb, core, s_gpio, 1);
-       saa7111a_call(mxb, core, s_std, std);
-       tuner_call(mxb, core, s_std, std);
+       saa7111a_call(mxb, video, s_std, std);
+       tuner_call(mxb, video, s_std, std);
 
        /* switch to tuner-channel on tea6415c */
        tea6415c_call(mxb, video, s_routing, 3, 17, 0);
                /* These two gpio calls set the GPIO pins that control the tda9820 */
                saa7146_write(dev, GPIO_CTRL, 0x00404050);
                saa7111a_call(mxb, core, s_gpio, 0);
-               saa7111a_call(mxb, core, s_std, std);
+               saa7111a_call(mxb, video, s_std, std);
                if (mxb->cur_input == 0)
-                       tuner_call(mxb, core, s_std, std);
+                       tuner_call(mxb, video, s_std, std);
        } else {
                v4l2_std_id std = V4L2_STD_PAL_BG;
 
                /* These two gpio calls set the GPIO pins that control the tda9820 */
                saa7146_write(dev, GPIO_CTRL, 0x00404050);
                saa7111a_call(mxb, core, s_gpio, 1);
-               saa7111a_call(mxb, core, s_std, std);
+               saa7111a_call(mxb, video, s_std, std);
                if (mxb->cur_input == 0)
-                       tuner_call(mxb, core, s_std, std);
+                       tuner_call(mxb, video, s_std, std);
        }
        return 0;
 }
 
        int status;
 
        if (V4L2_STD_ALL == std) {
-               v4l2_subdev_call(vip->decoder, core, s_std, std);
+               v4l2_subdev_call(vip->decoder, video, s_std, std);
                ssleep(2);
                v4l2_subdev_call(vip->decoder, video, querystd, &newstd);
                v4l2_subdev_call(vip->decoder, video, g_input_status, &status);
                        vip->format = formats_50[0];
        }
 
-       return v4l2_subdev_call(vip->decoder, core, s_std, std);
+       return v4l2_subdev_call(vip->decoder, video, s_std, std);
 }
 
 /**
 
        }
 
        decoder_call(zr, core, init, 0);
-       decoder_call(zr, core, s_std, zr->norm);
+       decoder_call(zr, video, s_std, zr->norm);
        decoder_call(zr, video, s_routing,
                zr->card.input[zr->input].muxsel, 0, 0);
 
 
        if (on)
                zr36057_overlay(zr, 0);
 
-       decoder_call(zr, core, s_std, norm);
+       decoder_call(zr, video, s_std, norm);
        encoder_call(zr, video, s_std_output, norm);
 
        if (on)
 
        if (vb2_is_busy(&bcap_dev->buffer_queue))
                return -EBUSY;
 
-       ret = v4l2_subdev_call(bcap_dev->sd, core, s_std, std);
+       ret = v4l2_subdev_call(bcap_dev->sd, video, s_std, std);
        if (ret < 0)
                return ret;
 
        /* now we can probe the default state */
        if (config->inputs[0].capabilities & V4L2_IN_CAP_STD) {
                v4l2_std_id std;
-               ret = v4l2_subdev_call(bcap_dev->sd, core, g_std, &std);
+               ret = v4l2_subdev_call(bcap_dev->sd, video, g_std, &std);
                if (ret) {
                        v4l2_err(&bcap_dev->v4l2_dev,
                                        "Unable to get std\n");
 
        }
 
        ret = v4l2_device_call_until_err(&vpfe_dev->v4l2_dev, sdinfo->grp_id,
-                                        core, s_std, std_id);
+                                        video, s_std, std_id);
        if (ret < 0) {
                v4l2_err(&vpfe_dev->v4l2_dev, "Failed to set standard\n");
                goto unlock_out;
 
        vpif_config_format(ch);
 
        /* set standard in the sub device */
-       ret = v4l2_subdev_call(ch->sd, core, s_std, std_id);
+       ret = v4l2_subdev_call(ch->sd, video, s_std, std_id);
        if (ret && ret != -ENOIOCTLCMD && ret != -ENODEV) {
                vpif_dbg(1, debug, "Failed to set standard for sub devices\n");
                return ret;
 
                return ret;
        }
 
-       ret = v4l2_device_call_until_err(&vpif_obj.v4l2_dev, 1, core,
+       ret = v4l2_device_call_until_err(&vpif_obj.v4l2_dev, 1, video,
                                                        s_std, std_id);
        if (ret < 0)
                vpif_err("Failed to set standard for sub devices\n");
 
        struct viu_fh *fh = priv;
 
        fh->dev->std = id;
-       decoder_call(fh->dev, core, s_std, id);
+       decoder_call(fh->dev, video, s_std, id);
        return 0;
 }
 
 
        struct soc_camera_device *icd = file->private_data;
        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
 
-       return v4l2_subdev_call(sd, core, s_std, a);
+       return v4l2_subdev_call(sd, video, s_std, a);
 }
 
 static int soc_camera_g_std(struct file *file, void *priv, v4l2_std_id *a)
        struct soc_camera_device *icd = file->private_data;
        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
 
-       return v4l2_subdev_call(sd, core, g_std, a);
+       return v4l2_subdev_call(sd, video, g_std, a);
 }
 
 static int soc_camera_enum_framesizes(struct file *file, void *fh,
 
        mutex_lock(&lw->lock);
 
        if (TIMBLOGIW_HAS_DECODER(lw))
-               err = v4l2_subdev_call(lw->sd_enc, core, s_std, std);
+               err = v4l2_subdev_call(lw->sd_enc, video, s_std, std);
 
        if (!err)
                fh->cur_norm = timblogiw_get_norm(std);
 
                        }
                        if (data_norm == 3)
                                data_norm = VINO_DATA_NORM_PAL;
-                       ret = decoder_call(core, s_std, norm);
+                       ret = decoder_call(video, s_std, norm);
                }
 
                spin_lock_irqsave(&vino_drvdata->input_lock, flags);
                                }
                                if (data_norm == 3)
                                        data_norm = VINO_DATA_NORM_PAL;
-                               ret = decoder_call(core, s_std, norm);
+                               ret = decoder_call(video, s_std, norm);
                        }
 
                        spin_lock_irqsave(&vino_drvdata->input_lock, flags);
                 * as it may take a while... */
 
                norm = vino_data_norms[data_norm].std;
-               err = decoder_call(core, s_std, norm);
+               err = decoder_call(video, s_std, norm);
 
                spin_lock_irqsave(&vino_drvdata->input_lock, *flags);
 
 
        /* If we've never sent the standard in tuner core, do so now.
           We don't do this at device probe because we don't want to
           incur the cost of a firmware load */
-       v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, dev->std);
+       v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_std, dev->std);
        v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, &f);
        i2c_gate_ctrl(dev, 0);
 }
           have to make the au0828 bridge adjust the size of its capture
           buffer, which is currently hardcoded at 720x480 */
 
-       v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, norm);
+       v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_std, norm);
 
        i2c_gate_ctrl(dev, 0);
 
 
                dev->ts1.height = 576;
                cx2341x_handler_set_50hz(&dev->mpeg_ctrl_handler, true);
        }
-       call_all(dev, core, s_std, dev->norm);
+       call_all(dev, video, s_std, dev->norm);
        /* do mode control overrides */
        cx231xx_do_mode_ctrl_overrides(dev);
 
 
        dev->width = 720;
        dev->height = (dev->norm & V4L2_STD_625_50) ? 576 : 480;
 
-       call_all(dev, core, s_std, dev->norm);
+       call_all(dev, video, s_std, dev->norm);
 
        /* We need to reset basic properties in the decoder related to
           resolution (since a standard change effects things like the number
                /* There's a tuner, so reset the standard and put it on the
                   last known frequency (since it was probably powered down
                   until now */
-               call_all(dev, core, s_std, dev->norm);
+               call_all(dev, video, s_std, dev->norm);
        }
 
        return 0;
        /* Set the initial input */
        video_mux(dev, dev->video_input);
 
-       call_all(dev, core, s_std, dev->norm);
+       call_all(dev, video, s_std, dev->norm);
 
        v4l2_ctrl_handler_init(&dev->ctrl_handler, 10);
        v4l2_ctrl_handler_init(&dev->radio_ctrl_handler, 5);
 
                           &v4l2->hscale, &v4l2->vscale);
 
        em28xx_resolution_set(dev);
-       v4l2_device_call_all(&v4l2->v4l2_dev, 0, core, s_std, v4l2->norm);
+       v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_std, v4l2->norm);
 
        return 0;
 }
 
        /* set default norm */
        v4l2->norm = V4L2_STD_PAL;
-       v4l2_device_call_all(&v4l2->v4l2_dev, 0, core, s_std, v4l2->norm);
+       v4l2_device_call_all(&v4l2->v4l2_dev, 0, video, s_std, v4l2->norm);
        v4l2->interlaced_fieldmode = EM28XX_INTERLACED_DEFAULT;
 
        /* Analog specific initialization */
 
                        v4l2_std_id vs;
                        vs = hdw->std_mask_cur;
                        v4l2_device_call_all(&hdw->v4l2_dev, 0,
-                                            core, s_std, vs);
+                                            video, s_std, vs);
                        pvr2_hdw_cx25840_vbi_hack(hdw);
                }
                hdw->tuner_signal_stale = !0;
 
 
        stk1160_set_std(dev);
 
-       v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std,
+       v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_std,
                        dev->norm);
 
        return 0;
        dev->fmt = &format[0];
        stk1160_set_std(dev);
 
-       v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std,
+       v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_std,
                        dev->norm);
 
        video_set_drvdata(&dev->vdev, dev);
 
        tm6000_config_tuner(dev);
 
        /* Set video standard */
-       v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, dev->norm);
+       v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_std, dev->norm);
 
        /* Set tuner frequency - also loads firmware on xc2028/xc3028 */
        f.tuner = 0;
 
        if (rc < 0)
                return rc;
 
-       v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, dev->norm);
+       v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_std, dev->norm);
 
        return 0;
 }
 
 
        usbvision->tvnorm_id = id;
 
-       call_all(usbvision, core, s_std, usbvision->tvnorm_id);
+       call_all(usbvision, video, s_std, usbvision->tvnorm_id);
        /* propagate the change to the decoder */
        usbvision_muxsel(usbvision, usbvision->ctl_input);
 
 
 
 static const struct v4l2_subdev_core_ops tuner_core_ops = {
        .log_status = tuner_log_status,
-       .s_std = tuner_s_std,
        .s_power = tuner_s_power,
 };
 
        .s_config = tuner_s_config,
 };
 
+static const struct v4l2_subdev_video_ops tuner_video_ops = {
+       .s_std = tuner_s_std,
+};
+
 static const struct v4l2_subdev_ops tuner_ops = {
        .core = &tuner_core_ops,
        .tuner = &tuner_tuner_ops,
+       .video = &tuner_video_ops,
 };
 
 /*
 
                goto unlock_out;
        }
        ret = v4l2_device_call_until_err(&vpfe_dev->v4l2_dev, sdinfo->grp_id,
-                                        core, s_std, std_id);
+                                        video, s_std, std_id);
        if (ret < 0) {
                v4l2_err(&vpfe_dev->v4l2_dev, "Failed to set standard\n");
                video->stdid = V4L2_STD_UNKNOWN;
 
                go->sensor_framerate = 30000;
        }
 
-       call_all(&go->v4l2_dev, core, s_std, go->std);
+       call_all(&go->v4l2_dev, video, s_std, go->std);
        set_capture_size(go, NULL, 0);
        return 0;
 }
 
 
 static const struct v4l2_subdev_core_ops s2250_core_ops = {
        .log_status = s2250_log_status,
-       .s_std = s2250_s_std,
 };
 
 static const struct v4l2_subdev_audio_ops s2250_audio_ops = {
 };
 
 static const struct v4l2_subdev_video_ops s2250_video_ops = {
+       .s_std = s2250_s_std,
        .s_routing = s2250_s_video_routing,
        .s_mbus_fmt = s2250_s_mbus_fmt,
 };
 
        .g_ctrl = saa7134_go7007_g_ctrl,
        .s_ctrl = saa7134_go7007_s_ctrl,
        .queryctrl = saa7134_go7007_queryctrl,
+};
+
+static const struct v4l2_subdev_video_ops saa7134_go7007_video_ops = {
        .s_std = saa7134_go7007_s_std,
 };
 
 static const struct v4l2_subdev_ops saa7134_go7007_sd_ops = {
        .core = &saa7134_go7007_core_ops,
+       .video = &saa7134_go7007_video_ops,
 };
 
 /* --------------------------------------------------------------------------*/
 
        int (*s_ext_ctrls)(struct v4l2_subdev *sd, struct v4l2_ext_controls *ctrls);
        int (*try_ext_ctrls)(struct v4l2_subdev *sd, struct v4l2_ext_controls *ctrls);
        int (*querymenu)(struct v4l2_subdev *sd, struct v4l2_querymenu *qm);
-       int (*g_std)(struct v4l2_subdev *sd, v4l2_std_id *norm);
-       int (*s_std)(struct v4l2_subdev *sd, v4l2_std_id norm);
        long (*ioctl)(struct v4l2_subdev *sd, unsigned int cmd, void *arg);
 #ifdef CONFIG_COMPAT
        long (*compat_ioctl32)(struct v4l2_subdev *sd, unsigned int cmd,
 struct v4l2_subdev_video_ops {
        int (*s_routing)(struct v4l2_subdev *sd, u32 input, u32 output, u32 config);
        int (*s_crystal_freq)(struct v4l2_subdev *sd, u32 freq, u32 flags);
+       int (*g_std)(struct v4l2_subdev *sd, v4l2_std_id *norm);
+       int (*s_std)(struct v4l2_subdev *sd, v4l2_std_id norm);
        int (*s_std_output)(struct v4l2_subdev *sd, v4l2_std_id std);
        int (*g_std_output)(struct v4l2_subdev *sd, v4l2_std_id *std);
        int (*querystd)(struct v4l2_subdev *sd, v4l2_std_id *std);
 /* Call an ops of a v4l2_subdev, doing the right checks against
    NULL pointers.
 
-   Example: err = v4l2_subdev_call(sd, core, s_std, norm);
+   Example: err = v4l2_subdev_call(sd, video, s_std, norm);
  */
 #define v4l2_subdev_call(sd, o, f, args...)                            \
        (!(sd) ? -ENODEV : (((sd)->ops->o && (sd)->ops->o->f) ? \