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, tuner, s_std, *norm);
+       v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, *norm);
        return 0;
 }
 
 
        .g_ctrl = bt819_g_ctrl,
        .s_ctrl = bt819_s_ctrl,
        .queryctrl = bt819_queryctrl,
-};
-
-static const struct v4l2_subdev_tuner_ops bt819_tuner_ops = {
        .s_std = bt819_s_std,
 };
 
 
 static const struct v4l2_subdev_ops bt819_ops = {
        .core = &bt819_core_ops,
-       .tuner = &bt819_tuner_ops,
        .video = &bt819_video_ops,
 };
 
 
                break;
        }
        id = tvnorm->v4l2_id;
-       bttv_call_all(btv, tuner, s_std, id);
+       bttv_call_all(btv, core, s_std, id);
 
        return 0;
 }
 
        .queryctrl = cx18_av_queryctrl,
        .g_ctrl = cx18_av_g_ctrl,
        .s_ctrl = cx18_av_s_ctrl,
+       .s_std = cx18_av_s_std,
 #ifdef CONFIG_VIDEO_ADV_DEBUG
        .g_register = cx18_av_g_register,
        .s_register = cx18_av_s_register,
        .s_frequency = cx18_av_s_frequency,
        .g_tuner = cx18_av_g_tuner,
        .s_tuner = cx18_av_s_tuner,
-       .s_std = cx18_av_s_std,
 };
 
 static const struct v4l2_subdev_audio_ops cx18_av_audio_ops = {
 
                /* 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, tuner, s_std, cx->std);
+               cx18_call_all(cx, core, 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_std = gpiomux_s_std,
        .s_radio = gpiomux_s_radio,
 };
 
 
                        (unsigned long long) cx->std);
 
        /* Tuner */
-       cx18_call_all(cx, tuner, s_std, cx->std);
+       cx18_call_all(cx, core, s_std, cx->std);
        return 0;
 }
 
 
        dev->height = f.fmt.pix.height;
        get_scale(dev, dev->width, dev->height, &dev->hscale, &dev->vscale);
 
-       call_all(dev, tuner, s_std, dev->norm);
+       call_all(dev, core, s_std, dev->norm);
 
        mutex_unlock(&dev->lock);
 
 
 
        dev->tvnorm = norm;
 
-       call_all(dev, tuner, s_std, norm);
+       call_all(dev, core, s_std, norm);
 
        return 0;
 }
 
        .g_ctrl = cx25840_g_ctrl,
        .s_ctrl = cx25840_s_ctrl,
        .queryctrl = cx25840_queryctrl,
+       .s_std = cx25840_s_std,
        .reset = cx25840_reset,
        .load_fw = cx25840_load_fw,
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 
 static const struct v4l2_subdev_tuner_ops cx25840_tuner_ops = {
        .s_frequency = cx25840_s_frequency,
-       .s_std = cx25840_s_std,
        .s_radio = cx25840_s_radio,
        .g_tuner = cx25840_g_tuner,
        .s_tuner = cx25840_s_tuner,
 
        set_tvaudio(core);
 
        // tell i2c chips
-       call_all(core, tuner, s_std, norm);
+       call_all(core, core, s_std, norm);
 
        // done
        return 0;
 
        get_scale(dev, dev->width, dev->height, &dev->hscale, &dev->vscale);
 
        em28xx_resolution_set(dev);
-       v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_std, dev->norm);
+       v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, dev->norm);
 
        mutex_unlock(&dev->lock);
        return 0;
 
                /* 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, tuner, s_std, itv->std);
+               ivtv_call_all(itv, core, 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)
 
        .g_ctrl = subdev_g_ctrl,
        .s_ctrl = subdev_s_ctrl,
        .queryctrl = subdev_queryctrl,
+       .s_std = subdev_s_std,
 };
 
 static const struct v4l2_subdev_tuner_ops subdev_tuner_ops = {
-       .s_std = subdev_s_std,
        .s_radio = subdev_s_radio,
        .g_tuner = subdev_g_tuner,
        .s_tuner = subdev_s_tuner,
 
        IVTV_DEBUG_INFO("Switching standard to %llx.\n", (unsigned long long)itv->std);
 
        /* Tuner */
-       ivtv_call_all(itv, tuner, s_std, itv->std);
+       ivtv_call_all(itv, core, s_std, itv->std);
 
        if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
                /* set display standard */
 
 
 static const struct v4l2_subdev_core_ops ks0127_core_ops = {
        .g_chip_ident = ks0127_g_chip_ident,
-};
-
-static const struct v4l2_subdev_tuner_ops ks0127_tuner_ops = {
        .s_std = ks0127_s_std,
 };
 
 
 static const struct v4l2_subdev_ops ks0127_ops = {
        .core = &ks0127_core_ops,
-       .tuner = &ks0127_tuner_ops,
        .video = &ks0127_video_ops,
 };
 
 
        .g_ctrl = msp_g_ctrl,
        .s_ctrl = msp_s_ctrl,
        .queryctrl = msp_queryctrl,
+       .s_std = msp_s_std,
 };
 
 static const struct v4l2_subdev_tuner_ops msp_tuner_ops = {
        .g_tuner = msp_g_tuner,
        .s_tuner = msp_s_tuner,
        .s_radio = msp_s_radio,
-       .s_std = msp_s_std,
 };
 
 static const struct v4l2_subdev_audio_ops msp_audio_ops = {
 
        int i = 0, err = 0;
 
        /* select video mode in saa7111a */
-       saa7111a_call(mxb, tuner, s_std, std);
+       saa7111a_call(mxb, core, s_std, std);
 
        /* select tuner-output on saa7111a */
        i = 0;
        tuner_call(mxb, tuner, s_frequency, &mxb->cur_freq);
 
        /* set a default video standard */
-       tuner_call(mxb, tuner, s_std, std);
+       tuner_call(mxb, core, s_std, std);
 
        /* mute audio on tea6420s */
        tea6420_1_call(mxb, audio, s_routing, &TEA6420_line[6][0]);
                saa7146_write(dev, GPIO_CTRL, 0x00404050);
                /* unset the 7111 gpio register -- I don't know what this does exactly */
                saa7111a_call(mxb, core, s_gpio, 0);
-               tuner_call(mxb, tuner, s_std, std);
+               tuner_call(mxb, core, s_std, std);
        } else {
                v4l2_std_id std = V4L2_STD_PAL_BG;
 
                saa7146_write(dev, GPIO_CTRL, 0x00404050);
                /* set the 7111 gpio register -- I don't know what this does exactly */
                saa7111a_call(mxb, core, s_gpio, 1);
-               tuner_call(mxb, tuner, s_std, std);
+               tuner_call(mxb, core, s_std, std);
        }
        return 0;
 }
 
                        v4l2_std_id vs;
                        vs = hdw->std_mask_cur;
                        v4l2_device_call_all(&hdw->v4l2_dev, 0,
-                                            tuner, s_std, vs);
+                                            core, s_std, vs);
                }
                hdw->tuner_signal_stale = !0;
                hdw->cropcap_stale = !0;
 
        .g_ctrl = saa7110_g_ctrl,
        .s_ctrl = saa7110_s_ctrl,
        .queryctrl = saa7110_queryctrl,
-};
-
-static const struct v4l2_subdev_tuner_ops saa7110_tuner_ops = {
        .s_std = saa7110_s_std,
 };
 
 
 static const struct v4l2_subdev_ops saa7110_ops = {
        .core = &saa7110_core_ops,
-       .tuner = &saa7110_tuner_ops,
        .video = &saa7110_video_ops,
 };
 
 
        .g_ctrl = saa711x_g_ctrl,
        .s_ctrl = saa711x_s_ctrl,
        .queryctrl = saa711x_queryctrl,
+       .s_std = saa711x_s_std,
        .reset = saa711x_reset,
        .s_gpio = saa711x_s_gpio,
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 };
 
 static const struct v4l2_subdev_tuner_ops saa711x_tuner_ops = {
-       .s_std = saa711x_s_std,
        .s_radio = saa711x_s_radio,
        .g_tuner = saa711x_g_tuner,
 };
 
        .g_ext_ctrls = saa6752hs_g_ext_ctrls,
        .s_ext_ctrls = saa6752hs_s_ext_ctrls,
        .try_ext_ctrls = saa6752hs_try_ext_ctrls,
-};
-
-static const struct v4l2_subdev_tuner_ops saa6752hs_tuner_ops = {
        .s_std = saa6752hs_s_std,
 };
 
 
 static const struct v4l2_subdev_ops saa6752hs_ops = {
        .core = &saa6752hs_core_ops,
-       .tuner = &saa6752hs_tuner_ops,
        .video = &saa6752hs_video_ops,
 };
 
 
        saa7134_set_decoder(dev);
 
        if (card_in(dev, dev->ctl_input).tv)
-               saa_call_all(dev, tuner, s_std, dev->tvnorm->id);
+               saa_call_all(dev, core, 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, tuner, s_std, dev->tvnorm->id);
+       saa_call_empress(dev, core, s_std, dev->tvnorm->id);
 }
 
 static void set_h_prescale(struct saa7134_dev *dev, int task, int prescale)
 
        .queryctrl = saa717x_queryctrl,
        .g_ctrl = saa717x_g_ctrl,
        .s_ctrl = saa717x_s_ctrl,
+       .s_std = saa717x_s_std,
 };
 
 static const struct v4l2_subdev_tuner_ops saa717x_tuner_ops = {
        .g_tuner = saa717x_g_tuner,
        .s_tuner = saa717x_s_tuner,
-       .s_std = saa717x_s_std,
        .s_radio = saa717x_s_radio,
 };
 
 
        .g_chip_ident = saa7191_g_chip_ident,
        .g_ctrl = saa7191_g_ctrl,
        .s_ctrl = saa7191_s_ctrl,
-};
-
-static const struct v4l2_subdev_tuner_ops saa7191_tuner_ops = {
        .s_std = saa7191_s_std,
 };
 
 static const struct v4l2_subdev_ops saa7191_ops = {
        .core = &saa7191_core_ops,
        .video = &saa7191_video_ops,
-       .tuner = &saa7191_tuner_ops,
 };
 
 static int saa7191_probe(struct i2c_client *client,
 
 
 static const struct v4l2_subdev_core_ops tuner_core_ops = {
        .log_status = tuner_log_status,
+       .s_std = tuner_s_std,
 };
 
 static const struct v4l2_subdev_tuner_ops tuner_tuner_ops = {
-       .s_std = tuner_s_std,
        .s_radio = tuner_s_radio,
        .g_tuner = tuner_g_tuner,
        .s_tuner = tuner_s_tuner,
 
        .queryctrl = tvaudio_queryctrl,
        .g_ctrl = tvaudio_g_ctrl,
        .s_ctrl = tvaudio_s_ctrl,
+       .s_std = tvaudio_s_std,
 };
 
 static const struct v4l2_subdev_tuner_ops tvaudio_tuner_ops = {
        .s_radio = tvaudio_s_radio,
        .s_frequency = tvaudio_s_frequency,
-       .s_std = tvaudio_s_std,
        .s_tuner = tvaudio_s_tuner,
        .s_tuner = tvaudio_g_tuner,
 };
 
        .g_ctrl = tvp5150_g_ctrl,
        .s_ctrl = tvp5150_s_ctrl,
        .queryctrl = tvp5150_queryctrl,
+       .s_std = tvp5150_s_std,
        .reset = tvp5150_reset,
        .g_chip_ident = tvp5150_g_chip_ident,
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 };
 
 static const struct v4l2_subdev_tuner_ops tvp5150_tuner_ops = {
-       .s_std = tvp5150_s_std,
        .g_tuner = tvp5150_g_tuner,
 };
 
 
        usbvision->tvnormId=*id;
 
        mutex_lock(&usbvision->lock);
-       call_all(usbvision, tuner, s_std, usbvision->tvnormId);
+       call_all(usbvision, core, s_std, usbvision->tvnormId);
        mutex_unlock(&usbvision->lock);
        /* propagate the change to the decoder */
        usbvision_muxsel(usbvision, usbvision->ctl_input);
 
                        }
                        if (data_norm == 3)
                                data_norm = VINO_DATA_NORM_PAL;
-                       ret = decoder_call(tuner, s_std, norm);
+                       ret = decoder_call(core, s_std, norm);
                }
 
                spin_lock_irqsave(&vino_drvdata->input_lock, flags);
                                }
                                if (data_norm == 3)
                                        data_norm = VINO_DATA_NORM_PAL;
-                               ret = decoder_call(tuner, s_std, norm);
+                               ret = decoder_call(core, 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(tuner, s_std, norm);
+               err = decoder_call(core, s_std, norm);
 
                spin_lock_irqsave(&vino_drvdata->input_lock, *flags);
 
 
 static const struct v4l2_subdev_core_ops vp27smpx_core_ops = {
        .log_status = vp27smpx_log_status,
        .g_chip_ident = vp27smpx_g_chip_ident,
+       .s_std = vp27smpx_s_std,
 };
 
 static const struct v4l2_subdev_tuner_ops vp27smpx_tuner_ops = {
        .s_radio = vp27smpx_s_radio,
-       .s_std = vp27smpx_s_std,
        .s_tuner = vp27smpx_s_tuner,
        .g_tuner = vp27smpx_g_tuner,
 };
 
        .g_ctrl = vpx3220_g_ctrl,
        .s_ctrl = vpx3220_s_ctrl,
        .queryctrl = vpx3220_queryctrl,
-};
-
-static const struct v4l2_subdev_tuner_ops vpx3220_tuner_ops = {
        .s_std = vpx3220_s_std,
 };
 
 
 static const struct v4l2_subdev_ops vpx3220_ops = {
        .core = &vpx3220_core_ops,
-       .tuner = &vpx3220_tuner_ops,
        .video = &vpx3220_video_ops,
 };
 
 
        route.input = zr->card.input[zr->input].muxsel;
 
        decoder_call(zr, core, init, 0);
-       decoder_call(zr, tuner, s_std, zr->norm);
+       decoder_call(zr, core, s_std, zr->norm);
        decoder_call(zr, video, s_routing, &route);
 
        encoder_call(zr, core, init, 0);
 
                v4l2_std_id std = 0;
 
                decoder_call(zr, video, querystd, &std);
-               decoder_call(zr, tuner, s_std, std);
+               decoder_call(zr, core, s_std, std);
 
                /* let changes come into effect */
                ssleep(2);
                                "%s: %s - no norm detected\n",
                                ZR_DEVNAME(zr), __func__);
                        /* reset norm */
-                       decoder_call(zr, tuner, s_std, zr->norm);
+                       decoder_call(zr, core, s_std, zr->norm);
                        return -EIO;
                }
 
        if (on)
                zr36057_overlay(zr, 0);
 
-       decoder_call(zr, tuner, s_std, norm);
+       decoder_call(zr, core, s_std, norm);
        encoder_call(zr, video, s_std_output, norm);
 
        if (on)
 
        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 (*s_std)(struct v4l2_subdev *sd, v4l2_std_id norm);
        long (*ioctl)(struct v4l2_subdev *sd, unsigned int cmd, void *arg);
 #ifdef CONFIG_VIDEO_ADV_DEBUG
        int (*g_register)(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg);
        int (*g_frequency)(struct v4l2_subdev *sd, struct v4l2_frequency *freq);
        int (*g_tuner)(struct v4l2_subdev *sd, struct v4l2_tuner *vt);
        int (*s_tuner)(struct v4l2_subdev *sd, struct v4l2_tuner *vt);
-       int (*s_std)(struct v4l2_subdev *sd, v4l2_std_id norm);
        int (*s_type_addr)(struct v4l2_subdev *sd, struct tuner_setup *type);
        int (*s_config)(struct v4l2_subdev *sd, const struct v4l2_priv_tun_config *config);
        int (*s_standby)(struct v4l2_subdev *sd);