Hi,
On Fri, Oct 13, 2017 at 05:59:29PM +0300, Laurent Pinchart wrote:
> The venc private data structure is currently stored as a global
> variable. While no platform with multiple VENC encoders currently exists
> nor is planned, this doesn't comply with the kernel device model and
> should thus be fixed.
>
> Signed-off-by: Laurent Pinchart <laurent.pinchart@xxxxxxxxxxxxxxxx>
> ---
Reviewed-by: Sebastian Reichel <sebastian.reichel@xxxxxxxxxxxxxxx>
-- Sebastian
> drivers/gpu/drm/omapdrm/dss/venc.c | 425 ++++++++++++++++++++-----------------
> 1 file changed, 228 insertions(+), 197 deletions(-)
>
> diff --git a/drivers/gpu/drm/omapdrm/dss/venc.c b/drivers/gpu/drm/omapdrm/dss/venc.c
> index 179ef73a5564..7acdbfefe397 100644
> --- a/drivers/gpu/drm/omapdrm/dss/venc.c
> +++ b/drivers/gpu/drm/omapdrm/dss/venc.c
> @@ -321,7 +321,7 @@ static enum venc_videomode venc_get_videomode(const struct videomode *vm)
> return VENC_MODE_UNKNOWN;
> }
>
> -static struct {
> +struct venc_device {
> struct platform_device *pdev;
> void __iomem *base;
> struct mutex venc_lock;
> @@ -339,81 +339,87 @@ static struct {
> bool requires_tv_dac_clk;
>
> struct omap_dss_device output;
> -} venc;
> +};
> +
> +#define dssdev_to_venc(dssdev) container_of(dssdev, struct venc_device, output)
>
> -static inline void venc_write_reg(int idx, u32 val)
> +static inline void venc_write_reg(struct venc_device *venc, int idx, u32 val)
> {
> - __raw_writel(val, venc.base + idx);
> + __raw_writel(val, venc->base + idx);
> }
>
> -static inline u32 venc_read_reg(int idx)
> +static inline u32 venc_read_reg(struct venc_device *venc, int idx)
> {
> - u32 l = __raw_readl(venc.base + idx);
> + u32 l = __raw_readl(venc->base + idx);
> return l;
> }
>
> -static void venc_write_config(const struct venc_config *config)
> +static void venc_write_config(struct venc_device *venc,
> + const struct venc_config *config)
> {
> DSSDBG("write venc conf\n");
>
> - venc_write_reg(VENC_LLEN, config->llen);
> - venc_write_reg(VENC_FLENS, config->flens);
> - venc_write_reg(VENC_CC_CARR_WSS_CARR, config->cc_carr_wss_carr);
> - venc_write_reg(VENC_C_PHASE, config->c_phase);
> - venc_write_reg(VENC_GAIN_U, config->gain_u);
> - venc_write_reg(VENC_GAIN_V, config->gain_v);
> - venc_write_reg(VENC_GAIN_Y, config->gain_y);
> - venc_write_reg(VENC_BLACK_LEVEL, config->black_level);
> - venc_write_reg(VENC_BLANK_LEVEL, config->blank_level);
> - venc_write_reg(VENC_M_CONTROL, config->m_control);
> - venc_write_reg(VENC_BSTAMP_WSS_DATA, config->bstamp_wss_data |
> - venc.wss_data);
> - venc_write_reg(VENC_S_CARR, config->s_carr);
> - venc_write_reg(VENC_L21__WC_CTL, config->l21__wc_ctl);
> - venc_write_reg(VENC_SAVID__EAVID, config->savid__eavid);
> - venc_write_reg(VENC_FLEN__FAL, config->flen__fal);
> - venc_write_reg(VENC_LAL__PHASE_RESET, config->lal__phase_reset);
> - venc_write_reg(VENC_HS_INT_START_STOP_X, config->hs_int_start_stop_x);
> - venc_write_reg(VENC_HS_EXT_START_STOP_X, config->hs_ext_start_stop_x);
> - venc_write_reg(VENC_VS_INT_START_X, config->vs_int_start_x);
> - venc_write_reg(VENC_VS_INT_STOP_X__VS_INT_START_Y,
> + venc_write_reg(venc, VENC_LLEN, config->llen);
> + venc_write_reg(venc, VENC_FLENS, config->flens);
> + venc_write_reg(venc, VENC_CC_CARR_WSS_CARR, config->cc_carr_wss_carr);
> + venc_write_reg(venc, VENC_C_PHASE, config->c_phase);
> + venc_write_reg(venc, VENC_GAIN_U, config->gain_u);
> + venc_write_reg(venc, VENC_GAIN_V, config->gain_v);
> + venc_write_reg(venc, VENC_GAIN_Y, config->gain_y);
> + venc_write_reg(venc, VENC_BLACK_LEVEL, config->black_level);
> + venc_write_reg(venc, VENC_BLANK_LEVEL, config->blank_level);
> + venc_write_reg(venc, VENC_M_CONTROL, config->m_control);
> + venc_write_reg(venc, VENC_BSTAMP_WSS_DATA, config->bstamp_wss_data |
> + venc->wss_data);
> + venc_write_reg(venc, VENC_S_CARR, config->s_carr);
> + venc_write_reg(venc, VENC_L21__WC_CTL, config->l21__wc_ctl);
> + venc_write_reg(venc, VENC_SAVID__EAVID, config->savid__eavid);
> + venc_write_reg(venc, VENC_FLEN__FAL, config->flen__fal);
> + venc_write_reg(venc, VENC_LAL__PHASE_RESET, config->lal__phase_reset);
> + venc_write_reg(venc, VENC_HS_INT_START_STOP_X,
> + config->hs_int_start_stop_x);
> + venc_write_reg(venc, VENC_HS_EXT_START_STOP_X,
> + config->hs_ext_start_stop_x);
> + venc_write_reg(venc, VENC_VS_INT_START_X, config->vs_int_start_x);
> + venc_write_reg(venc, VENC_VS_INT_STOP_X__VS_INT_START_Y,
> config->vs_int_stop_x__vs_int_start_y);
> - venc_write_reg(VENC_VS_INT_STOP_Y__VS_EXT_START_X,
> + venc_write_reg(venc, VENC_VS_INT_STOP_Y__VS_EXT_START_X,
> config->vs_int_stop_y__vs_ext_start_x);
> - venc_write_reg(VENC_VS_EXT_STOP_X__VS_EXT_START_Y,
> + venc_write_reg(venc, VENC_VS_EXT_STOP_X__VS_EXT_START_Y,
> config->vs_ext_stop_x__vs_ext_start_y);
> - venc_write_reg(VENC_VS_EXT_STOP_Y, config->vs_ext_stop_y);
> - venc_write_reg(VENC_AVID_START_STOP_X, config->avid_start_stop_x);
> - venc_write_reg(VENC_AVID_START_STOP_Y, config->avid_start_stop_y);
> - venc_write_reg(VENC_FID_INT_START_X__FID_INT_START_Y,
> + venc_write_reg(venc, VENC_VS_EXT_STOP_Y, config->vs_ext_stop_y);
> + venc_write_reg(venc, VENC_AVID_START_STOP_X, config->avid_start_stop_x);
> + venc_write_reg(venc, VENC_AVID_START_STOP_Y, config->avid_start_stop_y);
> + venc_write_reg(venc, VENC_FID_INT_START_X__FID_INT_START_Y,
> config->fid_int_start_x__fid_int_start_y);
> - venc_write_reg(VENC_FID_INT_OFFSET_Y__FID_EXT_START_X,
> + venc_write_reg(venc, VENC_FID_INT_OFFSET_Y__FID_EXT_START_X,
> config->fid_int_offset_y__fid_ext_start_x);
> - venc_write_reg(VENC_FID_EXT_START_Y__FID_EXT_OFFSET_Y,
> + venc_write_reg(venc, VENC_FID_EXT_START_Y__FID_EXT_OFFSET_Y,
> config->fid_ext_start_y__fid_ext_offset_y);
>
> - venc_write_reg(VENC_DAC_B__DAC_C, venc_read_reg(VENC_DAC_B__DAC_C));
> - venc_write_reg(VENC_VIDOUT_CTRL, config->vidout_ctrl);
> - venc_write_reg(VENC_HFLTR_CTRL, config->hfltr_ctrl);
> - venc_write_reg(VENC_X_COLOR, config->x_color);
> - venc_write_reg(VENC_LINE21, config->line21);
> - venc_write_reg(VENC_LN_SEL, config->ln_sel);
> - venc_write_reg(VENC_HTRIGGER_VTRIGGER, config->htrigger_vtrigger);
> - venc_write_reg(VENC_TVDETGP_INT_START_STOP_X,
> + venc_write_reg(venc, VENC_DAC_B__DAC_C,
> + venc_read_reg(venc, VENC_DAC_B__DAC_C));
> + venc_write_reg(venc, VENC_VIDOUT_CTRL, config->vidout_ctrl);
> + venc_write_reg(venc, VENC_HFLTR_CTRL, config->hfltr_ctrl);
> + venc_write_reg(venc, VENC_X_COLOR, config->x_color);
> + venc_write_reg(venc, VENC_LINE21, config->line21);
> + venc_write_reg(venc, VENC_LN_SEL, config->ln_sel);
> + venc_write_reg(venc, VENC_HTRIGGER_VTRIGGER, config->htrigger_vtrigger);
> + venc_write_reg(venc, VENC_TVDETGP_INT_START_STOP_X,
> config->tvdetgp_int_start_stop_x);
> - venc_write_reg(VENC_TVDETGP_INT_START_STOP_Y,
> + venc_write_reg(venc, VENC_TVDETGP_INT_START_STOP_Y,
> config->tvdetgp_int_start_stop_y);
> - venc_write_reg(VENC_GEN_CTRL, config->gen_ctrl);
> - venc_write_reg(VENC_F_CONTROL, config->f_control);
> - venc_write_reg(VENC_SYNC_CTRL, config->sync_ctrl);
> + venc_write_reg(venc, VENC_GEN_CTRL, config->gen_ctrl);
> + venc_write_reg(venc, VENC_F_CONTROL, config->f_control);
> + venc_write_reg(venc, VENC_SYNC_CTRL, config->sync_ctrl);
> }
>
> -static void venc_reset(void)
> +static void venc_reset(struct venc_device *venc)
> {
> int t = 1000;
>
> - venc_write_reg(VENC_F_CONTROL, 1<<8);
> - while (venc_read_reg(VENC_F_CONTROL) & (1<<8)) {
> + venc_write_reg(venc, VENC_F_CONTROL, 1<<8);
> + while (venc_read_reg(venc, VENC_F_CONTROL) & (1<<8)) {
> if (--t == 0) {
> DSSERR("Failed to reset venc\n");
> return;
> @@ -427,24 +433,24 @@ static void venc_reset(void)
> #endif
> }
>
> -static int venc_runtime_get(void)
> +static int venc_runtime_get(struct venc_device *venc)
> {
> int r;
>
> DSSDBG("venc_runtime_get\n");
>
> - r = pm_runtime_get_sync(&venc.pdev->dev);
> + r = pm_runtime_get_sync(&venc->pdev->dev);
> WARN_ON(r < 0);
> return r < 0 ? r : 0;
> }
>
> -static void venc_runtime_put(void)
> +static void venc_runtime_put(struct venc_device *venc)
> {
> int r;
>
> DSSDBG("venc_runtime_put\n");
>
> - r = pm_runtime_put_sync(&venc.pdev->dev);
> + r = pm_runtime_put_sync(&venc->pdev->dev);
> WARN_ON(r < 0 && r != -ENOSYS);
> }
>
> @@ -460,37 +466,37 @@ static const struct venc_config *venc_timings_to_config(struct videomode *vm)
> }
> }
>
> -static int venc_power_on(struct omap_dss_device *dssdev)
> +static int venc_power_on(struct venc_device *venc)
> {
> - enum omap_channel channel = dssdev->dispc_channel;
> + enum omap_channel channel = venc->output.dispc_channel;
> u32 l;
> int r;
>
> - r = venc_runtime_get();
> + r = venc_runtime_get(venc);
> if (r)
> goto err0;
>
> - venc_reset();
> - venc_write_config(venc_timings_to_config(&venc.vm));
> + venc_reset(venc);
> + venc_write_config(venc, venc_timings_to_config(&venc->vm));
>
> - dss_set_venc_output(venc.dss, venc.type);
> - dss_set_dac_pwrdn_bgz(venc.dss, 1);
> + dss_set_venc_output(venc->dss, venc->type);
> + dss_set_dac_pwrdn_bgz(venc->dss, 1);
>
> l = 0;
>
> - if (venc.type == OMAP_DSS_VENC_TYPE_COMPOSITE)
> + if (venc->type == OMAP_DSS_VENC_TYPE_COMPOSITE)
> l |= 1 << 1;
> else /* S-Video */
> l |= (1 << 0) | (1 << 2);
>
> - if (venc.invert_polarity == false)
> + if (venc->invert_polarity == false)
> l |= 1 << 3;
>
> - venc_write_reg(VENC_OUTPUT_CONTROL, l);
> + venc_write_reg(venc, VENC_OUTPUT_CONTROL, l);
>
> - dss_mgr_set_timings(channel, &venc.vm);
> + dss_mgr_set_timings(channel, &venc->vm);
>
> - r = regulator_enable(venc.vdda_dac_reg);
> + r = regulator_enable(venc->vdda_dac_reg);
> if (r)
> goto err1;
>
> @@ -501,78 +507,81 @@ static int venc_power_on(struct omap_dss_device *dssdev)
> return 0;
>
> err2:
> - regulator_disable(venc.vdda_dac_reg);
> + regulator_disable(venc->vdda_dac_reg);
> err1:
> - venc_write_reg(VENC_OUTPUT_CONTROL, 0);
> - dss_set_dac_pwrdn_bgz(venc.dss, 0);
> + venc_write_reg(venc, VENC_OUTPUT_CONTROL, 0);
> + dss_set_dac_pwrdn_bgz(venc->dss, 0);
>
> - venc_runtime_put();
> + venc_runtime_put(venc);
> err0:
> return r;
> }
>
> -static void venc_power_off(struct omap_dss_device *dssdev)
> +static void venc_power_off(struct venc_device *venc)
> {
> - enum omap_channel channel = dssdev->dispc_channel;
> + enum omap_channel channel = venc->output.dispc_channel;
>
> - venc_write_reg(VENC_OUTPUT_CONTROL, 0);
> - dss_set_dac_pwrdn_bgz(venc.dss, 0);
> + venc_write_reg(venc, VENC_OUTPUT_CONTROL, 0);
> + dss_set_dac_pwrdn_bgz(venc->dss, 0);
>
> dss_mgr_disable(channel);
>
> - regulator_disable(venc.vdda_dac_reg);
> + regulator_disable(venc->vdda_dac_reg);
>
> - venc_runtime_put();
> + venc_runtime_put(venc);
> }
>
> static int venc_display_enable(struct omap_dss_device *dssdev)
> {
> - struct omap_dss_device *out = &venc.output;
> + struct venc_device *venc = dssdev_to_venc(dssdev);
> int r;
>
> DSSDBG("venc_display_enable\n");
>
> - mutex_lock(&venc.venc_lock);
> + mutex_lock(&venc->venc_lock);
>
> - if (!out->dispc_channel_connected) {
> + if (!dssdev->dispc_channel_connected) {
> DSSERR("Failed to enable display: no output/manager\n");
> r = -ENODEV;
> goto err0;
> }
>
> - r = venc_power_on(dssdev);
> + r = venc_power_on(venc);
> if (r)
> goto err0;
>
> - venc.wss_data = 0;
> + venc->wss_data = 0;
>
> - mutex_unlock(&venc.venc_lock);
> + mutex_unlock(&venc->venc_lock);
>
> return 0;
> err0:
> - mutex_unlock(&venc.venc_lock);
> + mutex_unlock(&venc->venc_lock);
> return r;
> }
>
> static void venc_display_disable(struct omap_dss_device *dssdev)
> {
> + struct venc_device *venc = dssdev_to_venc(dssdev);
> +
> DSSDBG("venc_display_disable\n");
>
> - mutex_lock(&venc.venc_lock);
> + mutex_lock(&venc->venc_lock);
>
> - venc_power_off(dssdev);
> + venc_power_off(venc);
>
> - mutex_unlock(&venc.venc_lock);
> + mutex_unlock(&venc->venc_lock);
> }
>
> static void venc_set_timings(struct omap_dss_device *dssdev,
> struct videomode *vm)
> {
> + struct venc_device *venc = dssdev_to_venc(dssdev);
> struct videomode actual_vm;
>
> DSSDBG("venc_set_timings\n");
>
> - mutex_lock(&venc.venc_lock);
> + mutex_lock(&venc->venc_lock);
>
> switch (venc_get_videomode(vm)) {
> default:
> @@ -586,14 +595,14 @@ static void venc_set_timings(struct omap_dss_device *dssdev,
> }
>
> /* Reset WSS data when the TV standard changes. */
> - if (memcmp(&venc.vm, &actual_vm, sizeof(actual_vm)))
> - venc.wss_data = 0;
> + if (memcmp(&venc->vm, &actual_vm, sizeof(actual_vm)))
> + venc->wss_data = 0;
>
> - venc.vm = actual_vm;
> + venc->vm = actual_vm;
>
> dispc_set_tv_pclk(13500000);
>
> - mutex_unlock(&venc.venc_lock);
> + mutex_unlock(&venc->venc_lock);
> }
>
> static int venc_check_timings(struct omap_dss_device *dssdev,
> @@ -613,128 +622,135 @@ static int venc_check_timings(struct omap_dss_device *dssdev,
> static void venc_get_timings(struct omap_dss_device *dssdev,
> struct videomode *vm)
> {
> - mutex_lock(&venc.venc_lock);
> + struct venc_device *venc = dssdev_to_venc(dssdev);
> +
> + mutex_lock(&venc->venc_lock);
>
> - *vm = venc.vm;
> + *vm = venc->vm;
>
> - mutex_unlock(&venc.venc_lock);
> + mutex_unlock(&venc->venc_lock);
> }
>
> static u32 venc_get_wss(struct omap_dss_device *dssdev)
> {
> + struct venc_device *venc = dssdev_to_venc(dssdev);
> +
> /* Invert due to VENC_L21_WC_CTL:INV=1 */
> - return (venc.wss_data >> 8) ^ 0xfffff;
> + return (venc->wss_data >> 8) ^ 0xfffff;
> }
>
> static int venc_set_wss(struct omap_dss_device *dssdev, u32 wss)
> {
> + struct venc_device *venc = dssdev_to_venc(dssdev);
> const struct venc_config *config;
> int r;
>
> DSSDBG("venc_set_wss\n");
>
> - mutex_lock(&venc.venc_lock);
> + mutex_lock(&venc->venc_lock);
>
> - config = venc_timings_to_config(&venc.vm);
> + config = venc_timings_to_config(&venc->vm);
>
> /* Invert due to VENC_L21_WC_CTL:INV=1 */
> - venc.wss_data = (wss ^ 0xfffff) << 8;
> + venc->wss_data = (wss ^ 0xfffff) << 8;
>
> - r = venc_runtime_get();
> + r = venc_runtime_get(venc);
> if (r)
> goto err;
>
> - venc_write_reg(VENC_BSTAMP_WSS_DATA, config->bstamp_wss_data |
> - venc.wss_data);
> + venc_write_reg(venc, VENC_BSTAMP_WSS_DATA, config->bstamp_wss_data |
> + venc->wss_data);
>
> - venc_runtime_put();
> + venc_runtime_put(venc);
>
> err:
> - mutex_unlock(&venc.venc_lock);
> + mutex_unlock(&venc->venc_lock);
>
> return r;
> }
>
> -static int venc_init_regulator(void)
> +static int venc_init_regulator(struct venc_device *venc)
> {
> struct regulator *vdda_dac;
>
> - if (venc.vdda_dac_reg != NULL)
> + if (venc->vdda_dac_reg != NULL)
> return 0;
>
> - vdda_dac = devm_regulator_get(&venc.pdev->dev, "vdda");
> + vdda_dac = devm_regulator_get(&venc->pdev->dev, "vdda");
> if (IS_ERR(vdda_dac)) {
> if (PTR_ERR(vdda_dac) != -EPROBE_DEFER)
> DSSERR("can't get VDDA_DAC regulator\n");
> return PTR_ERR(vdda_dac);
> }
>
> - venc.vdda_dac_reg = vdda_dac;
> + venc->vdda_dac_reg = vdda_dac;
>
> return 0;
> }
>
> static int venc_dump_regs(struct seq_file *s, void *p)
> {
> -#define DUMPREG(r) seq_printf(s, "%-35s %08x\n", #r, venc_read_reg(r))
> + struct venc_device *venc = s->private;
> +
> +#define DUMPREG(venc, r) seq_printf(s, "%-35s %08x\n", #r, venc_read_reg(venc, r))
>
> - if (venc_runtime_get())
> + if (venc_runtime_get(venc))
> return 0;
>
> - DUMPREG(VENC_F_CONTROL);
> - DUMPREG(VENC_VIDOUT_CTRL);
> - DUMPREG(VENC_SYNC_CTRL);
> - DUMPREG(VENC_LLEN);
> - DUMPREG(VENC_FLENS);
> - DUMPREG(VENC_HFLTR_CTRL);
> - DUMPREG(VENC_CC_CARR_WSS_CARR);
> - DUMPREG(VENC_C_PHASE);
> - DUMPREG(VENC_GAIN_U);
> - DUMPREG(VENC_GAIN_V);
> - DUMPREG(VENC_GAIN_Y);
> - DUMPREG(VENC_BLACK_LEVEL);
> - DUMPREG(VENC_BLANK_LEVEL);
> - DUMPREG(VENC_X_COLOR);
> - DUMPREG(VENC_M_CONTROL);
> - DUMPREG(VENC_BSTAMP_WSS_DATA);
> - DUMPREG(VENC_S_CARR);
> - DUMPREG(VENC_LINE21);
> - DUMPREG(VENC_LN_SEL);
> - DUMPREG(VENC_L21__WC_CTL);
> - DUMPREG(VENC_HTRIGGER_VTRIGGER);
> - DUMPREG(VENC_SAVID__EAVID);
> - DUMPREG(VENC_FLEN__FAL);
> - DUMPREG(VENC_LAL__PHASE_RESET);
> - DUMPREG(VENC_HS_INT_START_STOP_X);
> - DUMPREG(VENC_HS_EXT_START_STOP_X);
> - DUMPREG(VENC_VS_INT_START_X);
> - DUMPREG(VENC_VS_INT_STOP_X__VS_INT_START_Y);
> - DUMPREG(VENC_VS_INT_STOP_Y__VS_EXT_START_X);
> - DUMPREG(VENC_VS_EXT_STOP_X__VS_EXT_START_Y);
> - DUMPREG(VENC_VS_EXT_STOP_Y);
> - DUMPREG(VENC_AVID_START_STOP_X);
> - DUMPREG(VENC_AVID_START_STOP_Y);
> - DUMPREG(VENC_FID_INT_START_X__FID_INT_START_Y);
> - DUMPREG(VENC_FID_INT_OFFSET_Y__FID_EXT_START_X);
> - DUMPREG(VENC_FID_EXT_START_Y__FID_EXT_OFFSET_Y);
> - DUMPREG(VENC_TVDETGP_INT_START_STOP_X);
> - DUMPREG(VENC_TVDETGP_INT_START_STOP_Y);
> - DUMPREG(VENC_GEN_CTRL);
> - DUMPREG(VENC_OUTPUT_CONTROL);
> - DUMPREG(VENC_OUTPUT_TEST);
> -
> - venc_runtime_put();
> + DUMPREG(venc, VENC_F_CONTROL);
> + DUMPREG(venc, VENC_VIDOUT_CTRL);
> + DUMPREG(venc, VENC_SYNC_CTRL);
> + DUMPREG(venc, VENC_LLEN);
> + DUMPREG(venc, VENC_FLENS);
> + DUMPREG(venc, VENC_HFLTR_CTRL);
> + DUMPREG(venc, VENC_CC_CARR_WSS_CARR);
> + DUMPREG(venc, VENC_C_PHASE);
> + DUMPREG(venc, VENC_GAIN_U);
> + DUMPREG(venc, VENC_GAIN_V);
> + DUMPREG(venc, VENC_GAIN_Y);
> + DUMPREG(venc, VENC_BLACK_LEVEL);
> + DUMPREG(venc, VENC_BLANK_LEVEL);
> + DUMPREG(venc, VENC_X_COLOR);
> + DUMPREG(venc, VENC_M_CONTROL);
> + DUMPREG(venc, VENC_BSTAMP_WSS_DATA);
> + DUMPREG(venc, VENC_S_CARR);
> + DUMPREG(venc, VENC_LINE21);
> + DUMPREG(venc, VENC_LN_SEL);
> + DUMPREG(venc, VENC_L21__WC_CTL);
> + DUMPREG(venc, VENC_HTRIGGER_VTRIGGER);
> + DUMPREG(venc, VENC_SAVID__EAVID);
> + DUMPREG(venc, VENC_FLEN__FAL);
> + DUMPREG(venc, VENC_LAL__PHASE_RESET);
> + DUMPREG(venc, VENC_HS_INT_START_STOP_X);
> + DUMPREG(venc, VENC_HS_EXT_START_STOP_X);
> + DUMPREG(venc, VENC_VS_INT_START_X);
> + DUMPREG(venc, VENC_VS_INT_STOP_X__VS_INT_START_Y);
> + DUMPREG(venc, VENC_VS_INT_STOP_Y__VS_EXT_START_X);
> + DUMPREG(venc, VENC_VS_EXT_STOP_X__VS_EXT_START_Y);
> + DUMPREG(venc, VENC_VS_EXT_STOP_Y);
> + DUMPREG(venc, VENC_AVID_START_STOP_X);
> + DUMPREG(venc, VENC_AVID_START_STOP_Y);
> + DUMPREG(venc, VENC_FID_INT_START_X__FID_INT_START_Y);
> + DUMPREG(venc, VENC_FID_INT_OFFSET_Y__FID_EXT_START_X);
> + DUMPREG(venc, VENC_FID_EXT_START_Y__FID_EXT_OFFSET_Y);
> + DUMPREG(venc, VENC_TVDETGP_INT_START_STOP_X);
> + DUMPREG(venc, VENC_TVDETGP_INT_START_STOP_Y);
> + DUMPREG(venc, VENC_GEN_CTRL);
> + DUMPREG(venc, VENC_OUTPUT_CONTROL);
> + DUMPREG(venc, VENC_OUTPUT_TEST);
> +
> + venc_runtime_put(venc);
>
> #undef DUMPREG
> return 0;
> }
>
> -static int venc_get_clocks(struct platform_device *pdev)
> +static int venc_get_clocks(struct venc_device *venc)
> {
> struct clk *clk;
>
> - if (venc.requires_tv_dac_clk) {
> - clk = devm_clk_get(&pdev->dev, "tv_dac_clk");
> + if (venc->requires_tv_dac_clk) {
> + clk = devm_clk_get(&venc->pdev->dev, "tv_dac_clk");
> if (IS_ERR(clk)) {
> DSSERR("can't get tv_dac_clk\n");
> return PTR_ERR(clk);
> @@ -743,7 +759,7 @@ static int venc_get_clocks(struct platform_device *pdev)
> clk = NULL;
> }
>
> - venc.tv_dac_clk = clk;
> + venc->tv_dac_clk = clk;
>
> return 0;
> }
> @@ -751,10 +767,11 @@ static int venc_get_clocks(struct platform_device *pdev)
> static int venc_connect(struct omap_dss_device *dssdev,
> struct omap_dss_device *dst)
> {
> + struct venc_device *venc = dssdev_to_venc(dssdev);
> enum omap_channel channel = dssdev->dispc_channel;
> int r;
>
> - r = venc_init_regulator();
> + r = venc_init_regulator(venc);
> if (r)
> return r;
>
> @@ -803,11 +820,11 @@ static const struct omapdss_atv_ops venc_ops = {
> .get_wss = venc_get_wss,
> };
>
> -static void venc_init_output(struct platform_device *pdev)
> +static void venc_init_output(struct venc_device *venc)
> {
> - struct omap_dss_device *out = &venc.output;
> + struct omap_dss_device *out = &venc->output;
>
> - out->dev = &pdev->dev;
> + out->dev = &venc->pdev->dev;
> out->id = OMAP_DSS_OUTPUT_VENC;
> out->output_type = OMAP_DISPLAY_TYPE_VENC;
> out->name = "venc.0";
> @@ -818,16 +835,14 @@ static void venc_init_output(struct platform_device *pdev)
> omapdss_register_output(out);
> }
>
> -static void venc_uninit_output(struct platform_device *pdev)
> +static void venc_uninit_output(struct venc_device *venc)
> {
> - struct omap_dss_device *out = &venc.output;
> -
> - omapdss_unregister_output(out);
> + omapdss_unregister_output(&venc->output);
> }
>
> -static int venc_probe_of(struct platform_device *pdev)
> +static int venc_probe_of(struct venc_device *venc)
> {
> - struct device_node *node = pdev->dev.of_node;
> + struct device_node *node = venc->pdev->dev.of_node;
> struct device_node *ep;
> u32 channels;
> int r;
> @@ -836,24 +851,25 @@ static int venc_probe_of(struct platform_device *pdev)
> if (!ep)
> return 0;
>
> - venc.invert_polarity = of_property_read_bool(ep, "ti,invert-polarity");
> + venc->invert_polarity = of_property_read_bool(ep, "ti,invert-polarity");
>
> r = of_property_read_u32(ep, "ti,channels", &channels);
> if (r) {
> - dev_err(&pdev->dev,
> + dev_err(&venc->pdev->dev,
> "failed to read property 'ti,channels': %d\n", r);
> goto err;
> }
>
> switch (channels) {
> case 1:
> - venc.type = OMAP_DSS_VENC_TYPE_COMPOSITE;
> + venc->type = OMAP_DSS_VENC_TYPE_COMPOSITE;
> break;
> case 2:
> - venc.type = OMAP_DSS_VENC_TYPE_SVIDEO;
> + venc->type = OMAP_DSS_VENC_TYPE_SVIDEO;
> break;
> default:
> - dev_err(&pdev->dev, "bad channel propert '%d'\n", channels);
> + dev_err(&venc->pdev->dev, "bad channel propert '%d'\n",
> + channels);
> r = -EINVAL;
> goto err;
> }
> @@ -878,68 +894,80 @@ static int venc_bind(struct device *dev, struct device *master, void *data)
> {
> struct platform_device *pdev = to_platform_device(dev);
> struct dss_device *dss = dss_get_device(master);
> + struct venc_device *venc;
> u8 rev_id;
> struct resource *venc_mem;
> int r;
>
> - venc.pdev = pdev;
> - venc.dss = dss;
> + venc = kzalloc(sizeof(*venc), GFP_KERNEL);
> + if (!venc)
> + return -ENOMEM;
> +
> + venc->pdev = pdev;
> + venc->dss = dss;
> + dev_set_drvdata(dev, venc);
>
> /* The OMAP34xx, OMAP35xx and AM35xx VENC require the TV DAC clock. */
> if (soc_device_match(venc_soc_devices))
> - venc.requires_tv_dac_clk = true;
> + venc->requires_tv_dac_clk = true;
>
> - mutex_init(&venc.venc_lock);
> + mutex_init(&venc->venc_lock);
>
> - venc.wss_data = 0;
> + venc->wss_data = 0;
>
> - venc_mem = platform_get_resource(venc.pdev, IORESOURCE_MEM, 0);
> - venc.base = devm_ioremap_resource(&pdev->dev, venc_mem);
> - if (IS_ERR(venc.base))
> - return PTR_ERR(venc.base);
> + venc_mem = platform_get_resource(venc->pdev, IORESOURCE_MEM, 0);
> + venc->base = devm_ioremap_resource(&pdev->dev, venc_mem);
> + if (IS_ERR(venc->base)) {
> + r = PTR_ERR(venc->base);
> + goto err_free;
> + }
>
> - r = venc_get_clocks(pdev);
> + r = venc_get_clocks(venc);
> if (r)
> - return r;
> + goto err_free;
>
> pm_runtime_enable(&pdev->dev);
>
> - r = venc_runtime_get();
> + r = venc_runtime_get(venc);
> if (r)
> goto err_runtime_get;
>
> - rev_id = (u8)(venc_read_reg(VENC_REV_ID) & 0xff);
> + rev_id = (u8)(venc_read_reg(venc, VENC_REV_ID) & 0xff);
> dev_dbg(&pdev->dev, "OMAP VENC rev %d\n", rev_id);
>
> - venc_runtime_put();
> + venc_runtime_put(venc);
>
> - r = venc_probe_of(pdev);
> + r = venc_probe_of(venc);
> if (r) {
> DSSERR("Invalid DT data\n");
> goto err_probe_of;
> }
>
> - venc.debugfs = dss_debugfs_create_file("venc", venc_dump_regs, &venc);
> + venc->debugfs = dss_debugfs_create_file("venc", venc_dump_regs, venc);
>
> - venc_init_output(pdev);
> + venc_init_output(venc);
>
> return 0;
>
> err_probe_of:
> err_runtime_get:
> pm_runtime_disable(&pdev->dev);
> +err_free:
> + kfree(venc);
> return r;
> }
>
> static void venc_unbind(struct device *dev, struct device *master, void *data)
> {
> - struct platform_device *pdev = to_platform_device(dev);
> + struct venc_device *venc = dev_get_drvdata(dev);
>
> - dss_debugfs_remove_file(venc.debugfs);
> + dss_debugfs_remove_file(venc->debugfs);
>
> - venc_uninit_output(pdev);
> + venc_uninit_output(venc);
>
> - pm_runtime_disable(&pdev->dev);
> + pm_runtime_disable(dev);
> +
> + kfree(venc);
> }
>
> static const struct component_ops venc_component_ops = {
> @@ -960,8 +988,10 @@ static int venc_remove(struct platform_device *pdev)
>
> static int venc_runtime_suspend(struct device *dev)
> {
> - if (venc.tv_dac_clk)
> - clk_disable_unprepare(venc.tv_dac_clk);
> + struct venc_device *venc = dev_get_drvdata(dev);
> +
> + if (venc->tv_dac_clk)
> + clk_disable_unprepare(venc->tv_dac_clk);
>
> dispc_runtime_put();
>
> @@ -970,14 +1000,15 @@ static int venc_runtime_suspend(struct device *dev)
>
> static int venc_runtime_resume(struct device *dev)
> {
> + struct venc_device *venc = dev_get_drvdata(dev);
> int r;
>
> r = dispc_runtime_get();
> if (r < 0)
> return r;
>
> - if (venc.tv_dac_clk)
> - clk_prepare_enable(venc.tv_dac_clk);
> + if (venc->tv_dac_clk)
> + clk_prepare_enable(venc->tv_dac_clk);
>
> return 0;
> }
> --
> Regards,
>
> Laurent Pinchart
>
> _______________________________________________
> dri-devel mailing list
> dri-devel@xxxxxxxxxxxxxxxxxxxxx
> https://lists.freedesktop.org/mailman/listinfo/dri-devel
Attachment:
signature.asc
Description: PGP signature
_______________________________________________ dri-devel mailing list dri-devel@xxxxxxxxxxxxxxxxxxxxx https://lists.freedesktop.org/mailman/listinfo/dri-devel
