Skip to content

L
linux
Commit 663ac57b authored by Laurent Pinchart's avatar Laurent Pinchart Committed by Tomi Valkeinen
Browse files
Options

drm: omapdrm: venc: Allocate the venc private data structure dynamically 

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: default avatarLaurent Pinchart <laurent.pinchart@ideasonboard.com>
Reviewed-by: default avatarSebastian Reichel <sebastian.reichel@collabora.co.uk>
parent 24aac601
Hide whitespace changes
Inline Side-by-side
Showing with 238 additions and 204 deletions
drivers/gpu/drm/omapdrm/dss/venc.c
View file @ 663ac57b
...@@ -319,7 +319,7 @@ static enum venc_videomode venc_get_videomode(const struct videomode *vm) ...@@ -319,7 +319,7 @@ static enum venc_videomode venc_get_videomode(const struct videomode *vm)
return VENC_MODE_UNKNOWN; return VENC_MODE_UNKNOWN;
} }
static struct { struct venc_device {
struct platform_device *pdev; struct platform_device *pdev;
void __iomem *base; void __iomem *base;
struct mutex venc_lock; struct mutex venc_lock;
...@@ -337,81 +337,87 @@ static struct { ...@@ -337,81 +337,87 @@ static struct {
bool requires_tv_dac_clk; bool requires_tv_dac_clk;
struct omap_dss_device output; 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; 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"); DSSDBG("write venc conf\n");
venc_write_reg(VENC_LLEN, config->llen); venc_write_reg(venc, VENC_LLEN, config->llen);
venc_write_reg(VENC_FLENS, config->flens); venc_write_reg(venc, VENC_FLENS, config->flens);
venc_write_reg(VENC_CC_CARR_WSS_CARR, config->cc_carr_wss_carr); venc_write_reg(venc, VENC_CC_CARR_WSS_CARR, config->cc_carr_wss_carr);
venc_write_reg(VENC_C_PHASE, config->c_phase); venc_write_reg(venc, VENC_C_PHASE, config->c_phase);
venc_write_reg(VENC_GAIN_U, config->gain_u); venc_write_reg(venc, VENC_GAIN_U, config->gain_u);
venc_write_reg(VENC_GAIN_V, config->gain_v); venc_write_reg(venc, VENC_GAIN_V, config->gain_v);
venc_write_reg(VENC_GAIN_Y, config->gain_y); venc_write_reg(venc, VENC_GAIN_Y, config->gain_y);
venc_write_reg(VENC_BLACK_LEVEL, config->black_level); venc_write_reg(venc, VENC_BLACK_LEVEL, config->black_level);
venc_write_reg(VENC_BLANK_LEVEL, config->blank_level); venc_write_reg(venc, VENC_BLANK_LEVEL, config->blank_level);
venc_write_reg(VENC_M_CONTROL, config->m_control); venc_write_reg(venc, VENC_M_CONTROL, config->m_control);
venc_write_reg(VENC_BSTAMP_WSS_DATA, config->bstamp_wss_data | venc_write_reg(venc, VENC_BSTAMP_WSS_DATA, config->bstamp_wss_data |
venc.wss_data); venc->wss_data);
venc_write_reg(VENC_S_CARR, config->s_carr); venc_write_reg(venc, VENC_S_CARR, config->s_carr);
venc_write_reg(VENC_L21__WC_CTL, config->l21__wc_ctl); venc_write_reg(venc, VENC_L21__WC_CTL, config->l21__wc_ctl);
venc_write_reg(VENC_SAVID__EAVID, config->savid__eavid); venc_write_reg(venc, VENC_SAVID__EAVID, config->savid__eavid);
venc_write_reg(VENC_FLEN__FAL, config->flen__fal); venc_write_reg(venc, VENC_FLEN__FAL, config->flen__fal);
venc_write_reg(VENC_LAL__PHASE_RESET, config->lal__phase_reset); venc_write_reg(venc, 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, VENC_HS_INT_START_STOP_X,
venc_write_reg(VENC_HS_EXT_START_STOP_X, config->hs_ext_start_stop_x); config->hs_int_start_stop_x);
venc_write_reg(VENC_VS_INT_START_X, config->vs_int_start_x); venc_write_reg(venc, VENC_HS_EXT_START_STOP_X,
venc_write_reg(VENC_VS_INT_STOP_X__VS_INT_START_Y, 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); 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); 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); 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, 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, 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, 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_FID_INT_START_X__FID_INT_START_Y,
config->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); 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); 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, VENC_DAC_B__DAC_C,
venc_write_reg(VENC_VIDOUT_CTRL, config->vidout_ctrl); venc_read_reg(venc, VENC_DAC_B__DAC_C));
venc_write_reg(VENC_HFLTR_CTRL, config->hfltr_ctrl); venc_write_reg(venc, VENC_VIDOUT_CTRL, config->vidout_ctrl);
venc_write_reg(VENC_X_COLOR, config->x_color); venc_write_reg(venc, VENC_HFLTR_CTRL, config->hfltr_ctrl);
venc_write_reg(VENC_LINE21, config->line21); venc_write_reg(venc, VENC_X_COLOR, config->x_color);
venc_write_reg(VENC_LN_SEL, config->ln_sel); venc_write_reg(venc, VENC_LINE21, config->line21);
venc_write_reg(VENC_HTRIGGER_VTRIGGER, config->htrigger_vtrigger); venc_write_reg(venc, VENC_LN_SEL, config->ln_sel);
venc_write_reg(VENC_TVDETGP_INT_START_STOP_X, 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); 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); config->tvdetgp_int_start_stop_y);
venc_write_reg(VENC_GEN_CTRL, config->gen_ctrl); venc_write_reg(venc, VENC_GEN_CTRL, config->gen_ctrl);
venc_write_reg(VENC_F_CONTROL, config->f_control); venc_write_reg(venc, VENC_F_CONTROL, config->f_control);
venc_write_reg(VENC_SYNC_CTRL, config->sync_ctrl); 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; int t = 1000;
venc_write_reg(VENC_F_CONTROL, 1<<8); venc_write_reg(venc, VENC_F_CONTROL, 1<<8);
while (venc_read_reg(VENC_F_CONTROL) & (1<<8)) { while (venc_read_reg(venc, VENC_F_CONTROL) & (1<<8)) {
if (--t == 0) { if (--t == 0) {
DSSERR("Failed to reset venc\n"); DSSERR("Failed to reset venc\n");
return; return;
...@@ -425,24 +431,24 @@ static void venc_reset(void) ...@@ -425,24 +431,24 @@ static void venc_reset(void)
#endif #endif
} }
static int venc_runtime_get(void) static int venc_runtime_get(struct venc_device *venc)
{ {
int r; int r;
DSSDBG("venc_runtime_get\n"); 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); WARN_ON(r < 0);
return r < 0 ? r : 0; return r < 0 ? r : 0;
} }
static void venc_runtime_put(void) static void venc_runtime_put(struct venc_device *venc)
{ {
int r; int r;
DSSDBG("venc_runtime_put\n"); 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); WARN_ON(r < 0 && r != -ENOSYS);
} }
...@@ -458,116 +464,119 @@ static const struct venc_config *venc_timings_to_config(struct videomode *vm) ...@@ -458,116 +464,119 @@ 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)
{ {
u32 l; u32 l;
int r; int r;
r = venc_runtime_get(); r = venc_runtime_get(venc);
if (r) if (r)
goto err0; goto err0;
venc_reset(); venc_reset(venc);
venc_write_config(venc_timings_to_config(&venc.vm)); venc_write_config(venc, venc_timings_to_config(&venc->vm));
dss_set_venc_output(venc.dss, venc.type); dss_set_venc_output(venc->dss, venc->type);
dss_set_dac_pwrdn_bgz(venc.dss, 1); dss_set_dac_pwrdn_bgz(venc->dss, 1);
l = 0; l = 0;
if (venc.type == OMAP_DSS_VENC_TYPE_COMPOSITE) if (venc->type == OMAP_DSS_VENC_TYPE_COMPOSITE)
l |= 1 << 1; l |= 1 << 1;
else /* S-Video */ else /* S-Video */
l |= (1 << 0) | (1 << 2); l |= (1 << 0) | (1 << 2);
if (venc.invert_polarity == false) if (venc->invert_polarity == false)
l |= 1 << 3; l |= 1 << 3;
venc_write_reg(VENC_OUTPUT_CONTROL, l); venc_write_reg(venc, VENC_OUTPUT_CONTROL, l);
dss_mgr_set_timings(&venc.output, &venc.vm); dss_mgr_set_timings(&venc->output, &venc->vm);
r = regulator_enable(venc.vdda_dac_reg); r = regulator_enable(venc->vdda_dac_reg);
if (r) if (r)
goto err1; goto err1;
r = dss_mgr_enable(&venc.output); r = dss_mgr_enable(&venc->output);
if (r) if (r)
goto err2; goto err2;
return 0; return 0;
err2: err2:
regulator_disable(venc.vdda_dac_reg); regulator_disable(venc->vdda_dac_reg);
err1: err1:
venc_write_reg(VENC_OUTPUT_CONTROL, 0); venc_write_reg(venc, VENC_OUTPUT_CONTROL, 0);
dss_set_dac_pwrdn_bgz(venc.dss, 0); dss_set_dac_pwrdn_bgz(venc->dss, 0);
venc_runtime_put(); venc_runtime_put(venc);
err0: err0:
return r; return r;
} }
static void venc_power_off(struct omap_dss_device *dssdev) static void venc_power_off(struct venc_device *venc)
{ {
venc_write_reg(VENC_OUTPUT_CONTROL, 0); venc_write_reg(venc, VENC_OUTPUT_CONTROL, 0);
dss_set_dac_pwrdn_bgz(venc.dss, 0); dss_set_dac_pwrdn_bgz(venc->dss, 0);
dss_mgr_disable(&venc.output); dss_mgr_disable(&venc->output);
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) 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; int r;
DSSDBG("venc_display_enable\n"); 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"); DSSERR("Failed to enable display: no output/manager\n");
r = -ENODEV; r = -ENODEV;
goto err0; goto err0;
} }
r = venc_power_on(dssdev); r = venc_power_on(venc);
if (r) if (r)
goto err0; goto err0;
venc.wss_data = 0; venc->wss_data = 0;
mutex_unlock(&venc.venc_lock); mutex_unlock(&venc->venc_lock);
return 0; return 0;
err0: err0:
mutex_unlock(&venc.venc_lock); mutex_unlock(&venc->venc_lock);
return r; return r;
} }
static void venc_display_disable(struct omap_dss_device *dssdev) static void venc_display_disable(struct omap_dss_device *dssdev)
{ {
struct venc_device *venc = dssdev_to_venc(dssdev);
DSSDBG("venc_display_disable\n"); 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, static void venc_set_timings(struct omap_dss_device *dssdev,
struct videomode *vm) struct videomode *vm)
{ {
struct venc_device *venc = dssdev_to_venc(dssdev);
struct videomode actual_vm; struct videomode actual_vm;
DSSDBG("venc_set_timings\n"); DSSDBG("venc_set_timings\n");
mutex_lock(&venc.venc_lock); mutex_lock(&venc->venc_lock);
switch (venc_get_videomode(vm)) { switch (venc_get_videomode(vm)) {
default: default:
...@@ -581,14 +590,14 @@ static void venc_set_timings(struct omap_dss_device *dssdev, ...@@ -581,14 +590,14 @@ static void venc_set_timings(struct omap_dss_device *dssdev,
} }
/* Reset WSS data when the TV standard changes. */ /* Reset WSS data when the TV standard changes. */
if (memcmp(&venc.vm, &actual_vm, sizeof(actual_vm))) if (memcmp(&venc->vm, &actual_vm, sizeof(actual_vm)))
venc.wss_data = 0; venc->wss_data = 0;
venc.vm = actual_vm; venc->vm = actual_vm;
dispc_set_tv_pclk(venc.dss->dispc, 13500000); dispc_set_tv_pclk(venc->dss->dispc, 13500000);
mutex_unlock(&venc.venc_lock); mutex_unlock(&venc->venc_lock);
} }
static int venc_check_timings(struct omap_dss_device *dssdev, static int venc_check_timings(struct omap_dss_device *dssdev,
...@@ -608,128 +617,136 @@ static int venc_check_timings(struct omap_dss_device *dssdev, ...@@ -608,128 +617,136 @@ static int venc_check_timings(struct omap_dss_device *dssdev,
static void venc_get_timings(struct omap_dss_device *dssdev, static void venc_get_timings(struct omap_dss_device *dssdev,
struct videomode *vm) 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) 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 */ /* 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) 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; const struct venc_config *config;
int r; int r;
DSSDBG("venc_set_wss\n"); 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 */ /* 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) if (r)
goto err; goto err;
venc_write_reg(VENC_BSTAMP_WSS_DATA, config->bstamp_wss_data | venc_write_reg(venc, VENC_BSTAMP_WSS_DATA, config->bstamp_wss_data |
venc.wss_data); venc->wss_data);
venc_runtime_put(); venc_runtime_put(venc);
err: err:
mutex_unlock(&venc.venc_lock); mutex_unlock(&venc->venc_lock);
return r; return r;
} }
static int venc_init_regulator(void) static int venc_init_regulator(struct venc_device *venc)
{ {
struct regulator *vdda_dac; struct regulator *vdda_dac;
if (venc.vdda_dac_reg != NULL) if (venc->vdda_dac_reg != NULL)
return 0; 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 (IS_ERR(vdda_dac)) {
if (PTR_ERR(vdda_dac) != -EPROBE_DEFER) if (PTR_ERR(vdda_dac) != -EPROBE_DEFER)
DSSERR("can't get VDDA_DAC regulator\n"); DSSERR("can't get VDDA_DAC regulator\n");
return PTR_ERR(vdda_dac); return PTR_ERR(vdda_dac);
} }
venc.vdda_dac_reg = vdda_dac; venc->vdda_dac_reg = vdda_dac;
return 0; return 0;
} }
static int venc_dump_regs(struct seq_file *s, void *p) 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; return 0;
DUMPREG(VENC_F_CONTROL); DUMPREG(venc, VENC_F_CONTROL);
DUMPREG(VENC_VIDOUT_CTRL); DUMPREG(venc, VENC_VIDOUT_CTRL);
DUMPREG(VENC_SYNC_CTRL); DUMPREG(venc, VENC_SYNC_CTRL);
DUMPREG(VENC_LLEN); DUMPREG(venc, VENC_LLEN);
DUMPREG(VENC_FLENS); DUMPREG(venc, VENC_FLENS);
DUMPREG(VENC_HFLTR_CTRL); DUMPREG(venc, VENC_HFLTR_CTRL);
DUMPREG(VENC_CC_CARR_WSS_CARR); DUMPREG(venc, VENC_CC_CARR_WSS_CARR);
DUMPREG(VENC_C_PHASE); DUMPREG(venc, VENC_C_PHASE);
DUMPREG(VENC_GAIN_U); DUMPREG(venc, VENC_GAIN_U);
DUMPREG(VENC_GAIN_V); DUMPREG(venc, VENC_GAIN_V);
DUMPREG(VENC_GAIN_Y); DUMPREG(venc, VENC_GAIN_Y);
DUMPREG(VENC_BLACK_LEVEL); DUMPREG(venc, VENC_BLACK_LEVEL);
DUMPREG(VENC_BLANK_LEVEL); DUMPREG(venc, VENC_BLANK_LEVEL);
DUMPREG(VENC_X_COLOR); DUMPREG(venc, VENC_X_COLOR);
DUMPREG(VENC_M_CONTROL); DUMPREG(venc, VENC_M_CONTROL);
DUMPREG(VENC_BSTAMP_WSS_DATA); DUMPREG(venc, VENC_BSTAMP_WSS_DATA);
DUMPREG(VENC_S_CARR); DUMPREG(venc, VENC_S_CARR);
DUMPREG(VENC_LINE21); DUMPREG(venc, VENC_LINE21);
DUMPREG(VENC_LN_SEL); DUMPREG(venc, VENC_LN_SEL);
DUMPREG(VENC_L21__WC_CTL); DUMPREG(venc, VENC_L21__WC_CTL);
DUMPREG(VENC_HTRIGGER_VTRIGGER); DUMPREG(venc, VENC_HTRIGGER_VTRIGGER);
DUMPREG(VENC_SAVID__EAVID); DUMPREG(venc, VENC_SAVID__EAVID);
DUMPREG(VENC_FLEN__FAL); DUMPREG(venc, VENC_FLEN__FAL);
DUMPREG(VENC_LAL__PHASE_RESET); DUMPREG(venc, VENC_LAL__PHASE_RESET);
DUMPREG(VENC_HS_INT_START_STOP_X); DUMPREG(venc, VENC_HS_INT_START_STOP_X);
DUMPREG(VENC_HS_EXT_START_STOP_X); DUMPREG(venc, VENC_HS_EXT_START_STOP_X);
DUMPREG(VENC_VS_INT_START_X); DUMPREG(venc, VENC_VS_INT_START_X);
DUMPREG(VENC_VS_INT_STOP_X__VS_INT_START_Y); DUMPREG(venc, VENC_VS_INT_STOP_X__VS_INT_START_Y);
DUMPREG(VENC_VS_INT_STOP_Y__VS_EXT_START_X); DUMPREG(venc, VENC_VS_INT_STOP_Y__VS_EXT_START_X);
DUMPREG(VENC_VS_EXT_STOP_X__VS_EXT_START_Y); DUMPREG(venc, VENC_VS_EXT_STOP_X__VS_EXT_START_Y);
DUMPREG(VENC_VS_EXT_STOP_Y); DUMPREG(venc, VENC_VS_EXT_STOP_Y);
DUMPREG(VENC_AVID_START_STOP_X); DUMPREG(venc, VENC_AVID_START_STOP_X);
DUMPREG(VENC_AVID_START_STOP_Y); DUMPREG(venc, VENC_AVID_START_STOP_Y);
DUMPREG(VENC_FID_INT_START_X__FID_INT_START_Y); DUMPREG(venc, VENC_FID_INT_START_X__FID_INT_START_Y);
DUMPREG(VENC_FID_INT_OFFSET_Y__FID_EXT_START_X); DUMPREG(venc, VENC_FID_INT_OFFSET_Y__FID_EXT_START_X);
DUMPREG(VENC_FID_EXT_START_Y__FID_EXT_OFFSET_Y); DUMPREG(venc, VENC_FID_EXT_START_Y__FID_EXT_OFFSET_Y);
DUMPREG(VENC_TVDETGP_INT_START_STOP_X); DUMPREG(venc, VENC_TVDETGP_INT_START_STOP_X);
DUMPREG(VENC_TVDETGP_INT_START_STOP_Y); DUMPREG(venc, VENC_TVDETGP_INT_START_STOP_Y);
DUMPREG(VENC_GEN_CTRL); DUMPREG(venc, VENC_GEN_CTRL);
DUMPREG(VENC_OUTPUT_CONTROL); DUMPREG(venc, VENC_OUTPUT_CONTROL);
DUMPREG(VENC_OUTPUT_TEST); DUMPREG(venc, VENC_OUTPUT_TEST);
venc_runtime_put(); venc_runtime_put(venc);
#undef DUMPREG #undef DUMPREG
return 0; return 0;
} }
static int venc_get_clocks(struct platform_device *pdev) static int venc_get_clocks(struct venc_device *venc)
{ {
struct clk *clk; struct clk *clk;
if (venc.requires_tv_dac_clk) { if (venc->requires_tv_dac_clk) {
clk = devm_clk_get(&pdev->dev, "tv_dac_clk"); clk = devm_clk_get(&venc->pdev->dev, "tv_dac_clk");
if (IS_ERR(clk)) { if (IS_ERR(clk)) {
DSSERR("can't get tv_dac_clk\n"); DSSERR("can't get tv_dac_clk\n");
return PTR_ERR(clk); return PTR_ERR(clk);
...@@ -738,7 +755,7 @@ static int venc_get_clocks(struct platform_device *pdev) ...@@ -738,7 +755,7 @@ static int venc_get_clocks(struct platform_device *pdev)
clk = NULL; clk = NULL;
} }
venc.tv_dac_clk = clk; venc->tv_dac_clk = clk;
return 0; return 0;
} }
...@@ -746,13 +763,14 @@ static int venc_get_clocks(struct platform_device *pdev) ...@@ -746,13 +763,14 @@ static int venc_get_clocks(struct platform_device *pdev)
static int venc_connect(struct omap_dss_device *dssdev, static int venc_connect(struct omap_dss_device *dssdev,
struct omap_dss_device *dst) struct omap_dss_device *dst)
{ {
struct venc_device *venc = dssdev_to_venc(dssdev);
int r; int r;
r = venc_init_regulator(); r = venc_init_regulator(venc);
if (r) if (r)
return r; return r;
r = dss_mgr_connect(&venc.output, dssdev); r = dss_mgr_connect(&venc->output, dssdev);
if (r) if (r)
return r; return r;
...@@ -760,7 +778,7 @@ static int venc_connect(struct omap_dss_device *dssdev, ...@@ -760,7 +778,7 @@ static int venc_connect(struct omap_dss_device *dssdev,
if (r) { if (r) {
DSSERR("failed to connect output to new device: %s\n", DSSERR("failed to connect output to new device: %s\n",
dst->name); dst->name);
dss_mgr_disconnect(&venc.output, dssdev); dss_mgr_disconnect(&venc->output, dssdev);
return r; return r;
} }
...@@ -770,6 +788,8 @@ static int venc_connect(struct omap_dss_device *dssdev, ...@@ -770,6 +788,8 @@ static int venc_connect(struct omap_dss_device *dssdev,
static void venc_disconnect(struct omap_dss_device *dssdev, static void venc_disconnect(struct omap_dss_device *dssdev,
struct omap_dss_device *dst) struct omap_dss_device *dst)
{ {
struct venc_device *venc = dssdev_to_venc(dssdev);
WARN_ON(dst != dssdev->dst); WARN_ON(dst != dssdev->dst);
if (dst != dssdev->dst) if (dst != dssdev->dst)
...@@ -777,7 +797,7 @@ static void venc_disconnect(struct omap_dss_device *dssdev, ...@@ -777,7 +797,7 @@ static void venc_disconnect(struct omap_dss_device *dssdev,
omapdss_output_unset_device(dssdev); omapdss_output_unset_device(dssdev);
dss_mgr_disconnect(&venc.output, dssdev); dss_mgr_disconnect(&venc->output, dssdev);
} }
static const struct omapdss_atv_ops venc_ops = { static const struct omapdss_atv_ops venc_ops = {
...@@ -795,11 +815,11 @@ static const struct omapdss_atv_ops venc_ops = { ...@@ -795,11 +815,11 @@ static const struct omapdss_atv_ops venc_ops = {
.get_wss = venc_get_wss, .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->id = OMAP_DSS_OUTPUT_VENC;
out->output_type = OMAP_DISPLAY_TYPE_VENC; out->output_type = OMAP_DISPLAY_TYPE_VENC;
out->name = "venc.0"; out->name = "venc.0";
...@@ -810,16 +830,14 @@ static void venc_init_output(struct platform_device *pdev) ...@@ -810,16 +830,14 @@ static void venc_init_output(struct platform_device *pdev)
omapdss_register_output(out); 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(&venc->output);
omapdss_unregister_output(out);
} }
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; struct device_node *ep;
u32 channels; u32 channels;
int r; int r;
...@@ -828,24 +846,25 @@ static int venc_probe_of(struct platform_device *pdev) ...@@ -828,24 +846,25 @@ static int venc_probe_of(struct platform_device *pdev)
if (!ep) if (!ep)
return 0; 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); r = of_property_read_u32(ep, "ti,channels", &channels);
if (r) { if (r) {
dev_err(&pdev->dev, dev_err(&venc->pdev->dev,
"failed to read property 'ti,channels': %d\n", r); "failed to read property 'ti,channels': %d\n", r);
goto err; goto err;
} }
switch (channels) { switch (channels) {
case 1: case 1:
venc.type = OMAP_DSS_VENC_TYPE_COMPOSITE; venc->type = OMAP_DSS_VENC_TYPE_COMPOSITE;
break; break;
case 2: case 2:
venc.type = OMAP_DSS_VENC_TYPE_SVIDEO; venc->type = OMAP_DSS_VENC_TYPE_SVIDEO;
break; break;
default: default:
dev_err(&pdev->dev, "bad channel propert '%d'\n", channels); dev_err(&venc->pdev->dev, "bad channel propert '%d'\n",
channels);
r = -EINVAL; r = -EINVAL;
goto err; goto err;
} }
...@@ -870,69 +889,81 @@ static int venc_bind(struct device *dev, struct device *master, void *data) ...@@ -870,69 +889,81 @@ static int venc_bind(struct device *dev, struct device *master, void *data)
{ {
struct platform_device *pdev = to_platform_device(dev); struct platform_device *pdev = to_platform_device(dev);
struct dss_device *dss = dss_get_device(master); struct dss_device *dss = dss_get_device(master);
struct venc_device *venc;
u8 rev_id; u8 rev_id;
struct resource *venc_mem; struct resource *venc_mem;
int r; int r;
venc.pdev = pdev; venc = kzalloc(sizeof(*venc), GFP_KERNEL);
venc.dss = dss; 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. */ /* The OMAP34xx, OMAP35xx and AM35xx VENC require the TV DAC clock. */
if (soc_device_match(venc_soc_devices)) 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_mem = platform_get_resource(venc->pdev, IORESOURCE_MEM, 0);
venc.base = devm_ioremap_resource(&pdev->dev, venc_mem); venc->base = devm_ioremap_resource(&pdev->dev, venc_mem);
if (IS_ERR(venc.base)) if (IS_ERR(venc->base)) {
return PTR_ERR(venc.base); r = PTR_ERR(venc->base);
goto err_free;
}
r = venc_get_clocks(pdev); r = venc_get_clocks(venc);
if (r) if (r)
return r; goto err_free;
pm_runtime_enable(&pdev->dev); pm_runtime_enable(&pdev->dev);
r = venc_runtime_get(); r = venc_runtime_get(venc);
if (r) if (r)
goto err_runtime_get; 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); 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) { if (r) {
DSSERR("Invalid DT data\n"); DSSERR("Invalid DT data\n");
goto err_probe_of; goto err_probe_of;
} }
venc.debugfs = dss_debugfs_create_file(dss, "venc", venc_dump_regs, venc->debugfs = dss_debugfs_create_file(dss, "venc", venc_dump_regs,
&venc); venc);
venc_init_output(pdev); venc_init_output(venc);
return 0; return 0;
err_probe_of: err_probe_of:
err_runtime_get: err_runtime_get:
pm_runtime_disable(&pdev->dev); pm_runtime_disable(&pdev->dev);
err_free:
kfree(venc);
return r; return r;
} }
static void venc_unbind(struct device *dev, struct device *master, void *data) 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 = { static const struct component_ops venc_component_ops = {
...@@ -953,24 +984,27 @@ static int venc_remove(struct platform_device *pdev) ...@@ -953,24 +984,27 @@ static int venc_remove(struct platform_device *pdev)
static int venc_runtime_suspend(struct device *dev) static int venc_runtime_suspend(struct device *dev)
{ {
if (venc.tv_dac_clk) struct venc_device *venc = dev_get_drvdata(dev);
clk_disable_unprepare(venc.tv_dac_clk);
if (venc->tv_dac_clk)
clk_disable_unprepare(venc->tv_dac_clk);
dispc_runtime_put(venc.dss->dispc); dispc_runtime_put(venc->dss->dispc);
return 0; return 0;
} }
static int venc_runtime_resume(struct device *dev) static int venc_runtime_resume(struct device *dev)
{ {
struct venc_device *venc = dev_get_drvdata(dev);
int r; int r;
r = dispc_runtime_get(venc.dss->dispc); r = dispc_runtime_get(venc->dss->dispc);
if (r < 0) if (r < 0)
return r; return r;
if (venc.tv_dac_clk) if (venc->tv_dac_clk)
clk_prepare_enable(venc.tv_dac_clk); clk_prepare_enable(venc->tv_dac_clk);
return 0; return 0;
} }
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7