You've already forked linux-apfs
mirror of
https://github.com/linux-apfs/linux-apfs.git
synced 2026-05-01 15:00:59 -07:00
drm/sti: atomic crtc/plane update
Better fit STI hardware structure. Planes are no more responsible of updating mixer information such as z-order and status. It is now up to the CRTC atomic flush to do it. Plane actions (enable or disable) are performed atomically. Disabling of a plane is synchronize with the vsync event. Signed-off-by: Vincent Abriou <vincent.abriou@st.com> Reviewed-by: Benjamin Gaignard <benjamin.gaignard@linaro.org>
This commit is contained in:
Vincent Abriou
committed by
Benjamin Gaignard
Benjamin Gaignard
parent
9e1f05b280
commit
29d1dc62e1
@@ -61,15 +61,13 @@ static int sti_compositor_bind(struct device *dev,
|
||||
{
|
||||
struct sti_compositor *compo = dev_get_drvdata(dev);
|
||||
struct drm_device *drm_dev = data;
|
||||
unsigned int i, mixer_id = 0, vid_id = 0, crtc_id = 0, plane_id = 0;
|
||||
unsigned int i, mixer_id = 0, vid_id = 0, crtc_id = 0;
|
||||
struct sti_private *dev_priv = drm_dev->dev_private;
|
||||
struct drm_plane *cursor = NULL;
|
||||
struct drm_plane *primary = NULL;
|
||||
struct sti_compositor_subdev_descriptor *desc = compo->data.subdev_desc;
|
||||
unsigned int array_size = compo->data.nb_subdev;
|
||||
|
||||
struct sti_plane *plane;
|
||||
|
||||
dev_priv->compo = compo;
|
||||
|
||||
/* Register mixer subdev and video subdev first */
|
||||
@@ -110,27 +108,25 @@ static int sti_compositor_bind(struct device *dev,
|
||||
/* Nothing to do, already done at the first round */
|
||||
break;
|
||||
case STI_CURSOR_SUBDEV:
|
||||
plane = sti_cursor_create(compo->dev, desc[i].id,
|
||||
compo->regs + desc[i].offset);
|
||||
if (!plane) {
|
||||
cursor = sti_cursor_create(drm_dev, compo->dev,
|
||||
desc[i].id,
|
||||
compo->regs + desc[i].offset,
|
||||
1);
|
||||
if (!cursor) {
|
||||
DRM_ERROR("Can't create CURSOR plane\n");
|
||||
break;
|
||||
}
|
||||
cursor = sti_plane_init(drm_dev, plane, 1,
|
||||
DRM_PLANE_TYPE_CURSOR);
|
||||
plane_id++;
|
||||
break;
|
||||
case STI_GPD_SUBDEV:
|
||||
plane = sti_gdp_create(compo->dev, desc[i].id,
|
||||
compo->regs + desc[i].offset);
|
||||
if (!plane) {
|
||||
primary = sti_gdp_create(drm_dev, compo->dev,
|
||||
desc[i].id,
|
||||
compo->regs + desc[i].offset,
|
||||
(1 << mixer_id) - 1,
|
||||
plane_type);
|
||||
if (!primary) {
|
||||
DRM_ERROR("Can't create GDP plane\n");
|
||||
break;
|
||||
}
|
||||
primary = sti_plane_init(drm_dev, plane,
|
||||
(1 << mixer_id) - 1,
|
||||
plane_type);
|
||||
plane_id++;
|
||||
break;
|
||||
default:
|
||||
DRM_ERROR("Unknown subdev compoment type\n");
|
||||
@@ -151,10 +147,6 @@ static int sti_compositor_bind(struct device *dev,
|
||||
/* Allow usage of vblank without having to call drm_irq_install */
|
||||
drm_dev->irq_enabled = 1;
|
||||
|
||||
DRM_DEBUG_DRIVER("Initialized %d DRM CRTC(s) and %d DRM plane(s)\n",
|
||||
crtc_id, plane_id);
|
||||
DRM_DEBUG_DRIVER("DRM plane(s) for VID/VDP not created yet\n");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@@ -17,20 +17,18 @@
|
||||
#include "sti_compositor.h"
|
||||
#include "sti_crtc.h"
|
||||
#include "sti_drv.h"
|
||||
#include "sti_vid.h"
|
||||
#include "sti_vtg.h"
|
||||
|
||||
static void sti_crtc_dpms(struct drm_crtc *crtc, int mode)
|
||||
{
|
||||
DRM_DEBUG_KMS("\n");
|
||||
}
|
||||
|
||||
static void sti_crtc_prepare(struct drm_crtc *crtc)
|
||||
static void sti_crtc_enable(struct drm_crtc *crtc)
|
||||
{
|
||||
struct sti_mixer *mixer = to_sti_mixer(crtc);
|
||||
struct device *dev = mixer->dev;
|
||||
struct sti_compositor *compo = dev_get_drvdata(dev);
|
||||
|
||||
mixer->enabled = true;
|
||||
DRM_DEBUG_DRIVER("\n");
|
||||
|
||||
mixer->status = STI_MIXER_READY;
|
||||
|
||||
/* Prepare and enable the compo IP clock */
|
||||
if (mixer->id == STI_MIXER_MAIN) {
|
||||
@@ -41,31 +39,16 @@ static void sti_crtc_prepare(struct drm_crtc *crtc)
|
||||
DRM_INFO("Failed to prepare/enable compo_aux clk\n");
|
||||
}
|
||||
|
||||
sti_mixer_clear_all_planes(mixer);
|
||||
drm_crtc_vblank_on(crtc);
|
||||
}
|
||||
|
||||
static void sti_crtc_commit(struct drm_crtc *crtc)
|
||||
static void sti_crtc_disabling(struct drm_crtc *crtc)
|
||||
{
|
||||
struct sti_mixer *mixer = to_sti_mixer(crtc);
|
||||
struct device *dev = mixer->dev;
|
||||
struct sti_compositor *compo = dev_get_drvdata(dev);
|
||||
struct sti_plane *plane;
|
||||
|
||||
if ((!mixer || !compo)) {
|
||||
DRM_ERROR("Can't find mixer or compositor)\n");
|
||||
return;
|
||||
}
|
||||
DRM_DEBUG_DRIVER("\n");
|
||||
|
||||
/* get GDP which is reserved to the CRTC FB */
|
||||
plane = to_sti_plane(crtc->primary);
|
||||
if (!plane)
|
||||
DRM_ERROR("Can't find CRTC dedicated plane (GDP0)\n");
|
||||
|
||||
/* Enable plane on mixer */
|
||||
if (sti_mixer_set_plane_status(mixer, plane, true))
|
||||
DRM_ERROR("Cannot enable plane at mixer\n");
|
||||
|
||||
drm_crtc_vblank_on(crtc);
|
||||
mixer->status = STI_MIXER_DISABLING;
|
||||
}
|
||||
|
||||
static bool sti_crtc_mode_fixup(struct drm_crtc *crtc,
|
||||
@@ -133,9 +116,6 @@ static void sti_crtc_disable(struct drm_crtc *crtc)
|
||||
struct device *dev = mixer->dev;
|
||||
struct sti_compositor *compo = dev_get_drvdata(dev);
|
||||
|
||||
if (!mixer->enabled)
|
||||
return;
|
||||
|
||||
DRM_DEBUG_KMS("CRTC:%d (%s)\n", crtc->base.id, sti_mixer_to_str(mixer));
|
||||
|
||||
/* Disable Background */
|
||||
@@ -152,13 +132,13 @@ static void sti_crtc_disable(struct drm_crtc *crtc)
|
||||
clk_disable_unprepare(compo->clk_compo_aux);
|
||||
}
|
||||
|
||||
mixer->enabled = false;
|
||||
mixer->status = STI_MIXER_DISABLED;
|
||||
}
|
||||
|
||||
static void
|
||||
sti_crtc_mode_set_nofb(struct drm_crtc *crtc)
|
||||
{
|
||||
sti_crtc_prepare(crtc);
|
||||
sti_crtc_enable(crtc);
|
||||
sti_crtc_mode_set(crtc, &crtc->state->adjusted_mode);
|
||||
}
|
||||
|
||||
@@ -178,17 +158,79 @@ static void sti_crtc_atomic_begin(struct drm_crtc *crtc)
|
||||
|
||||
static void sti_crtc_atomic_flush(struct drm_crtc *crtc)
|
||||
{
|
||||
struct drm_device *drm_dev = crtc->dev;
|
||||
struct sti_mixer *mixer = to_sti_mixer(crtc);
|
||||
struct sti_compositor *compo = dev_get_drvdata(mixer->dev);
|
||||
struct drm_plane *p;
|
||||
|
||||
DRM_DEBUG_DRIVER("\n");
|
||||
|
||||
/* perform plane actions */
|
||||
list_for_each_entry(p, &drm_dev->mode_config.plane_list, head) {
|
||||
struct sti_plane *plane = to_sti_plane(p);
|
||||
|
||||
switch (plane->status) {
|
||||
case STI_PLANE_UPDATED:
|
||||
/* update planes tag as updated */
|
||||
DRM_DEBUG_DRIVER("update plane %s\n",
|
||||
sti_plane_to_str(plane));
|
||||
|
||||
if (sti_mixer_set_plane_depth(mixer, plane)) {
|
||||
DRM_ERROR("Cannot set plane %s depth\n",
|
||||
sti_plane_to_str(plane));
|
||||
break;
|
||||
}
|
||||
|
||||
if (sti_mixer_set_plane_status(mixer, plane, true)) {
|
||||
DRM_ERROR("Cannot enable plane %s at mixer\n",
|
||||
sti_plane_to_str(plane));
|
||||
break;
|
||||
}
|
||||
|
||||
/* if plane is HQVDP_0 then commit the vid[0] */
|
||||
if (plane->desc == STI_HQVDP_0)
|
||||
sti_vid_commit(compo->vid[0], p->state);
|
||||
|
||||
plane->status = STI_PLANE_READY;
|
||||
|
||||
break;
|
||||
case STI_PLANE_DISABLING:
|
||||
/* disabling sequence for planes tag as disabling */
|
||||
DRM_DEBUG_DRIVER("disable plane %s from mixer\n",
|
||||
sti_plane_to_str(plane));
|
||||
|
||||
if (sti_mixer_set_plane_status(mixer, plane, false)) {
|
||||
DRM_ERROR("Cannot disable plane %s at mixer\n",
|
||||
sti_plane_to_str(plane));
|
||||
continue;
|
||||
}
|
||||
|
||||
if (plane->desc == STI_CURSOR)
|
||||
/* tag plane status for disabled */
|
||||
plane->status = STI_PLANE_DISABLED;
|
||||
else
|
||||
/* tag plane status for flushing */
|
||||
plane->status = STI_PLANE_FLUSHING;
|
||||
|
||||
/* if plane is HQVDP_0 then disable the vid[0] */
|
||||
if (plane->desc == STI_HQVDP_0)
|
||||
sti_vid_disable(compo->vid[0]);
|
||||
|
||||
break;
|
||||
default:
|
||||
/* Other status case are not handled */
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static struct drm_crtc_helper_funcs sti_crtc_helper_funcs = {
|
||||
.dpms = sti_crtc_dpms,
|
||||
.prepare = sti_crtc_prepare,
|
||||
.commit = sti_crtc_commit,
|
||||
.enable = sti_crtc_enable,
|
||||
.disable = sti_crtc_disabling,
|
||||
.mode_fixup = sti_crtc_mode_fixup,
|
||||
.mode_set = drm_helper_crtc_mode_set,
|
||||
.mode_set_nofb = sti_crtc_mode_set_nofb,
|
||||
.mode_set_base = drm_helper_crtc_mode_set_base,
|
||||
.disable = sti_crtc_disable,
|
||||
.atomic_begin = sti_crtc_atomic_begin,
|
||||
.atomic_flush = sti_crtc_atomic_flush,
|
||||
};
|
||||
@@ -237,6 +279,21 @@ int sti_crtc_vblank_cb(struct notifier_block *nb,
|
||||
}
|
||||
spin_unlock_irqrestore(&drm_dev->event_lock, flags);
|
||||
|
||||
if (compo->mixer[*crtc]->status == STI_MIXER_DISABLING) {
|
||||
struct drm_plane *p;
|
||||
|
||||
/* Disable mixer only if all overlay planes (GDP and VDP)
|
||||
* are disabled */
|
||||
list_for_each_entry(p, &drm_dev->mode_config.plane_list, head) {
|
||||
struct sti_plane *plane = to_sti_plane(p);
|
||||
|
||||
if ((plane->desc & STI_PLANE_TYPE_MASK) <= STI_VDP)
|
||||
if (plane->status != STI_PLANE_DISABLED)
|
||||
return 0;
|
||||
}
|
||||
sti_crtc_disable(&compo->mixer[*crtc]->drm_crtc);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -259,9 +316,9 @@ int sti_crtc_enable_vblank(struct drm_device *dev, int crtc)
|
||||
}
|
||||
EXPORT_SYMBOL(sti_crtc_enable_vblank);
|
||||
|
||||
void sti_crtc_disable_vblank(struct drm_device *dev, int crtc)
|
||||
void sti_crtc_disable_vblank(struct drm_device *drm_dev, int crtc)
|
||||
{
|
||||
struct sti_private *priv = dev->dev_private;
|
||||
struct sti_private *priv = drm_dev->dev_private;
|
||||
struct sti_compositor *compo = priv->compo;
|
||||
struct notifier_block *vtg_vblank_nb = &compo->vtg_vblank_nb;
|
||||
|
||||
@@ -273,7 +330,7 @@ void sti_crtc_disable_vblank(struct drm_device *dev, int crtc)
|
||||
|
||||
/* free the resources of the pending requests */
|
||||
if (compo->mixer[crtc]->pending_event) {
|
||||
drm_vblank_put(dev, crtc);
|
||||
drm_vblank_put(drm_dev, crtc);
|
||||
compo->mixer[crtc]->pending_event = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -7,6 +7,12 @@
|
||||
*/
|
||||
#include <drm/drmP.h>
|
||||
|
||||
#include <drm/drm_atomic_helper.h>
|
||||
#include <drm/drm_fb_cma_helper.h>
|
||||
#include <drm/drm_gem_cma_helper.h>
|
||||
#include <drm/drm_plane_helper.h>
|
||||
|
||||
#include "sti_compositor.h"
|
||||
#include "sti_cursor.h"
|
||||
#include "sti_plane.h"
|
||||
#include "sti_vtg.h"
|
||||
@@ -42,14 +48,14 @@ struct dma_pixmap {
|
||||
/**
|
||||
* STI Cursor structure
|
||||
*
|
||||
* @sti_plane: sti_plane structure
|
||||
* @dev: driver device
|
||||
* @regs: cursor registers
|
||||
* @width: cursor width
|
||||
* @height: cursor height
|
||||
* @clut: color look up table
|
||||
* @clut_paddr: color look up table physical address
|
||||
* @pixmap: pixmap dma buffer (clut8-format cursor)
|
||||
* @sti_plane: sti_plane structure
|
||||
* @dev: driver device
|
||||
* @regs: cursor registers
|
||||
* @width: cursor width
|
||||
* @height: cursor height
|
||||
* @clut: color look up table
|
||||
* @clut_paddr: color look up table physical address
|
||||
* @pixmap: pixmap dma buffer (clut8-format cursor)
|
||||
*/
|
||||
struct sti_cursor {
|
||||
struct sti_plane plane;
|
||||
@@ -68,20 +74,8 @@ static const uint32_t cursor_supported_formats[] = {
|
||||
|
||||
#define to_sti_cursor(x) container_of(x, struct sti_cursor, plane)
|
||||
|
||||
static const uint32_t *sti_cursor_get_formats(struct sti_plane *plane)
|
||||
static void sti_cursor_argb8888_to_clut8(struct sti_cursor *cursor, u32 *src)
|
||||
{
|
||||
return cursor_supported_formats;
|
||||
}
|
||||
|
||||
static unsigned int sti_cursor_get_nb_formats(struct sti_plane *plane)
|
||||
{
|
||||
return ARRAY_SIZE(cursor_supported_formats);
|
||||
}
|
||||
|
||||
static void sti_cursor_argb8888_to_clut8(struct sti_plane *plane)
|
||||
{
|
||||
struct sti_cursor *cursor = to_sti_cursor(plane);
|
||||
u32 *src = plane->vaddr;
|
||||
u8 *dst = cursor->pixmap.base;
|
||||
unsigned int i, j;
|
||||
u32 a, r, g, b;
|
||||
@@ -100,32 +94,67 @@ static void sti_cursor_argb8888_to_clut8(struct sti_plane *plane)
|
||||
}
|
||||
}
|
||||
|
||||
static int sti_cursor_prepare_plane(struct sti_plane *plane, bool first_prepare)
|
||||
static void sti_cursor_init(struct sti_cursor *cursor)
|
||||
{
|
||||
unsigned short *base = cursor->clut;
|
||||
unsigned int a, r, g, b;
|
||||
|
||||
/* Assign CLUT values, ARGB444 format */
|
||||
for (a = 0; a < 4; a++)
|
||||
for (r = 0; r < 4; r++)
|
||||
for (g = 0; g < 4; g++)
|
||||
for (b = 0; b < 4; b++)
|
||||
*base++ = (a * 5) << 12 |
|
||||
(r * 5) << 8 |
|
||||
(g * 5) << 4 |
|
||||
(b * 5);
|
||||
}
|
||||
|
||||
static void sti_cursor_atomic_update(struct drm_plane *drm_plane,
|
||||
struct drm_plane_state *oldstate)
|
||||
{
|
||||
struct drm_plane_state *state = drm_plane->state;
|
||||
struct sti_plane *plane = to_sti_plane(drm_plane);
|
||||
struct sti_cursor *cursor = to_sti_cursor(plane);
|
||||
struct drm_display_mode *mode = plane->mode;
|
||||
struct drm_crtc *crtc = state->crtc;
|
||||
struct sti_mixer *mixer = to_sti_mixer(crtc);
|
||||
struct drm_framebuffer *fb = state->fb;
|
||||
struct drm_display_mode *mode = &crtc->mode;
|
||||
int dst_x = state->crtc_x;
|
||||
int dst_y = state->crtc_y;
|
||||
int dst_w = clamp_val(state->crtc_w, 0, mode->crtc_hdisplay - dst_x);
|
||||
int dst_h = clamp_val(state->crtc_h, 0, mode->crtc_vdisplay - dst_y);
|
||||
/* src_x are in 16.16 format */
|
||||
int src_w = state->src_w >> 16;
|
||||
int src_h = state->src_h >> 16;
|
||||
bool first_prepare = plane->status == STI_PLANE_DISABLED ? true : false;
|
||||
struct drm_gem_cma_object *cma_obj;
|
||||
u32 y, x;
|
||||
u32 val;
|
||||
|
||||
DRM_DEBUG_DRIVER("\n");
|
||||
DRM_DEBUG_KMS("CRTC:%d (%s) drm plane:%d (%s)\n",
|
||||
crtc->base.id, sti_mixer_to_str(mixer),
|
||||
drm_plane->base.id, sti_plane_to_str(plane));
|
||||
DRM_DEBUG_KMS("(%dx%d)@(%d,%d)\n", dst_w, dst_h, dst_x, dst_y);
|
||||
|
||||
dev_dbg(cursor->dev, "%s %s\n", __func__, sti_plane_to_str(plane));
|
||||
dev_dbg(cursor->dev, "%s %s\n", __func__,
|
||||
sti_plane_to_str(plane));
|
||||
|
||||
if (plane->src_w < STI_CURS_MIN_SIZE ||
|
||||
plane->src_h < STI_CURS_MIN_SIZE ||
|
||||
plane->src_w > STI_CURS_MAX_SIZE ||
|
||||
plane->src_h > STI_CURS_MAX_SIZE) {
|
||||
if (src_w < STI_CURS_MIN_SIZE ||
|
||||
src_h < STI_CURS_MIN_SIZE ||
|
||||
src_w > STI_CURS_MAX_SIZE ||
|
||||
src_h > STI_CURS_MAX_SIZE) {
|
||||
DRM_ERROR("Invalid cursor size (%dx%d)\n",
|
||||
plane->src_w, plane->src_h);
|
||||
return -EINVAL;
|
||||
src_w, src_h);
|
||||
return;
|
||||
}
|
||||
|
||||
/* If the cursor size has changed, re-allocated the pixmap */
|
||||
if (!cursor->pixmap.base ||
|
||||
(cursor->width != plane->src_w) ||
|
||||
(cursor->height != plane->src_h)) {
|
||||
cursor->width = plane->src_w;
|
||||
cursor->height = plane->src_h;
|
||||
(cursor->width != src_w) ||
|
||||
(cursor->height != src_h)) {
|
||||
cursor->width = src_w;
|
||||
cursor->height = src_h;
|
||||
|
||||
if (cursor->pixmap.base)
|
||||
dma_free_writecombine(cursor->dev,
|
||||
@@ -141,12 +170,18 @@ static int sti_cursor_prepare_plane(struct sti_plane *plane, bool first_prepare)
|
||||
GFP_KERNEL | GFP_DMA);
|
||||
if (!cursor->pixmap.base) {
|
||||
DRM_ERROR("Failed to allocate memory for pixmap\n");
|
||||
return -ENOMEM;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
cma_obj = drm_fb_cma_get_gem_obj(fb, 0);
|
||||
if (!cma_obj) {
|
||||
DRM_ERROR("Can't get CMA GEM object for fb\n");
|
||||
return;
|
||||
}
|
||||
|
||||
/* Convert ARGB8888 to CLUT8 */
|
||||
sti_cursor_argb8888_to_clut8(plane);
|
||||
sti_cursor_argb8888_to_clut8(cursor, (u32 *)cma_obj->vaddr);
|
||||
|
||||
/* AWS and AWE depend on the mode */
|
||||
y = sti_vtg_get_line_number(*mode, 0);
|
||||
@@ -164,62 +199,50 @@ static int sti_cursor_prepare_plane(struct sti_plane *plane, bool first_prepare)
|
||||
writel(CUR_CTL_CLUT_UPDATE, cursor->regs + CUR_CTL);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int sti_cursor_commit_plane(struct sti_plane *plane)
|
||||
{
|
||||
struct sti_cursor *cursor = to_sti_cursor(plane);
|
||||
struct drm_display_mode *mode = plane->mode;
|
||||
u32 ydo, xdo;
|
||||
|
||||
dev_dbg(cursor->dev, "%s %s\n", __func__, sti_plane_to_str(plane));
|
||||
|
||||
/* Set memory location, size, and position */
|
||||
writel(cursor->pixmap.paddr, cursor->regs + CUR_PML);
|
||||
writel(cursor->width, cursor->regs + CUR_PMP);
|
||||
writel(cursor->height << 16 | cursor->width, cursor->regs + CUR_SIZE);
|
||||
|
||||
ydo = sti_vtg_get_line_number(*mode, plane->dst_y);
|
||||
xdo = sti_vtg_get_pixel_number(*mode, plane->dst_y);
|
||||
writel((ydo << 16) | xdo, cursor->regs + CUR_VPO);
|
||||
y = sti_vtg_get_line_number(*mode, dst_y);
|
||||
x = sti_vtg_get_pixel_number(*mode, dst_y);
|
||||
writel((y << 16) | x, cursor->regs + CUR_VPO);
|
||||
|
||||
return 0;
|
||||
plane->status = STI_PLANE_UPDATED;
|
||||
}
|
||||
|
||||
static int sti_cursor_disable_plane(struct sti_plane *plane)
|
||||
static void sti_cursor_atomic_disable(struct drm_plane *drm_plane,
|
||||
struct drm_plane_state *oldstate)
|
||||
{
|
||||
return 0;
|
||||
struct sti_plane *plane = to_sti_plane(drm_plane);
|
||||
struct sti_mixer *mixer = to_sti_mixer(drm_plane->crtc);
|
||||
|
||||
if (!drm_plane->crtc) {
|
||||
DRM_DEBUG_DRIVER("drm plane:%d not enabled\n",
|
||||
drm_plane->base.id);
|
||||
return;
|
||||
}
|
||||
|
||||
DRM_DEBUG_DRIVER("CRTC:%d (%s) drm plane:%d (%s)\n",
|
||||
drm_plane->crtc->base.id, sti_mixer_to_str(mixer),
|
||||
drm_plane->base.id, sti_plane_to_str(plane));
|
||||
|
||||
plane->status = STI_PLANE_DISABLING;
|
||||
}
|
||||
|
||||
static void sti_cursor_init(struct sti_cursor *cursor)
|
||||
{
|
||||
unsigned short *base = cursor->clut;
|
||||
unsigned int a, r, g, b;
|
||||
|
||||
/* Assign CLUT values, ARGB444 format */
|
||||
for (a = 0; a < 4; a++)
|
||||
for (r = 0; r < 4; r++)
|
||||
for (g = 0; g < 4; g++)
|
||||
for (b = 0; b < 4; b++)
|
||||
*base++ = (a * 5) << 12 |
|
||||
(r * 5) << 8 |
|
||||
(g * 5) << 4 |
|
||||
(b * 5);
|
||||
}
|
||||
|
||||
static const struct sti_plane_funcs cursor_plane_ops = {
|
||||
.get_formats = sti_cursor_get_formats,
|
||||
.get_nb_formats = sti_cursor_get_nb_formats,
|
||||
.prepare = sti_cursor_prepare_plane,
|
||||
.commit = sti_cursor_commit_plane,
|
||||
.disable = sti_cursor_disable_plane,
|
||||
static const struct drm_plane_helper_funcs sti_cursor_helpers_funcs = {
|
||||
.atomic_update = sti_cursor_atomic_update,
|
||||
.atomic_disable = sti_cursor_atomic_disable,
|
||||
};
|
||||
|
||||
struct sti_plane *sti_cursor_create(struct device *dev, int desc,
|
||||
void __iomem *baseaddr)
|
||||
struct drm_plane *sti_cursor_create(struct drm_device *drm_dev,
|
||||
struct device *dev, int desc,
|
||||
void __iomem *baseaddr,
|
||||
unsigned int possible_crtcs)
|
||||
{
|
||||
struct sti_cursor *cursor;
|
||||
size_t size;
|
||||
int res;
|
||||
|
||||
cursor = devm_kzalloc(dev, sizeof(*cursor), GFP_KERNEL);
|
||||
if (!cursor) {
|
||||
@@ -228,23 +251,43 @@ struct sti_plane *sti_cursor_create(struct device *dev, int desc,
|
||||
}
|
||||
|
||||
/* Allocate clut buffer */
|
||||
cursor->clut = dma_alloc_writecombine(dev,
|
||||
0x100 * sizeof(unsigned short),
|
||||
&cursor->clut_paddr,
|
||||
GFP_KERNEL | GFP_DMA);
|
||||
size = 0x100 * sizeof(unsigned short);
|
||||
cursor->clut = dma_alloc_writecombine(dev, size, &cursor->clut_paddr,
|
||||
GFP_KERNEL | GFP_DMA);
|
||||
|
||||
if (!cursor->clut) {
|
||||
DRM_ERROR("Failed to allocate memory for cursor clut\n");
|
||||
devm_kfree(dev, cursor);
|
||||
return NULL;
|
||||
goto err_clut;
|
||||
}
|
||||
|
||||
cursor->dev = dev;
|
||||
cursor->regs = baseaddr;
|
||||
cursor->plane.desc = desc;
|
||||
cursor->plane.ops = &cursor_plane_ops;
|
||||
cursor->plane.status = STI_PLANE_DISABLED;
|
||||
|
||||
sti_cursor_init(cursor);
|
||||
|
||||
return &cursor->plane;
|
||||
res = drm_universal_plane_init(drm_dev, &cursor->plane.drm_plane,
|
||||
possible_crtcs,
|
||||
&sti_plane_helpers_funcs,
|
||||
cursor_supported_formats,
|
||||
ARRAY_SIZE(cursor_supported_formats),
|
||||
DRM_PLANE_TYPE_CURSOR);
|
||||
if (res) {
|
||||
DRM_ERROR("Failed to initialize universal plane\n");
|
||||
goto err_plane;
|
||||
}
|
||||
|
||||
drm_plane_helper_add(&cursor->plane.drm_plane,
|
||||
&sti_cursor_helpers_funcs);
|
||||
|
||||
sti_plane_init_property(&cursor->plane, DRM_PLANE_TYPE_CURSOR);
|
||||
|
||||
return &cursor->plane.drm_plane;
|
||||
|
||||
err_plane:
|
||||
dma_free_writecombine(dev, size, cursor->clut, cursor->clut_paddr);
|
||||
err_clut:
|
||||
devm_kfree(dev, cursor);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@@ -7,7 +7,9 @@
|
||||
#ifndef _STI_CURSOR_H_
|
||||
#define _STI_CURSOR_H_
|
||||
|
||||
struct sti_plane *sti_cursor_create(struct device *dev, int desc,
|
||||
void __iomem *baseaddr);
|
||||
struct drm_plane *sti_cursor_create(struct drm_device *drm_dev,
|
||||
struct device *dev, int desc,
|
||||
void __iomem *baseaddr,
|
||||
unsigned int possible_crtcs);
|
||||
|
||||
#endif
|
||||
|
||||
+274
-219
File diff suppressed because it is too large
Load Diff
@@ -11,7 +11,9 @@
|
||||
|
||||
#include <linux/types.h>
|
||||
|
||||
struct sti_plane *sti_gdp_create(struct device *dev, int desc,
|
||||
void __iomem *baseaddr);
|
||||
|
||||
struct drm_plane *sti_gdp_create(struct drm_device *drm_dev,
|
||||
struct device *dev, int desc,
|
||||
void __iomem *baseaddr,
|
||||
unsigned int possible_crtcs,
|
||||
enum drm_plane_type type);
|
||||
#endif
|
||||
|
||||
+230
-199
File diff suppressed because it is too large
Load Diff
@@ -58,6 +58,7 @@ const char *sti_mixer_to_str(struct sti_mixer *mixer)
|
||||
return "<UNKNOWN MIXER>";
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL(sti_mixer_to_str);
|
||||
|
||||
static inline u32 sti_mixer_reg_read(struct sti_mixer *mixer, u32 reg_id)
|
||||
{
|
||||
@@ -225,15 +226,6 @@ int sti_mixer_set_plane_status(struct sti_mixer *mixer,
|
||||
return 0;
|
||||
}
|
||||
|
||||
void sti_mixer_clear_all_planes(struct sti_mixer *mixer)
|
||||
{
|
||||
u32 val;
|
||||
|
||||
DRM_DEBUG_DRIVER("%s clear all planes\n", sti_mixer_to_str(mixer));
|
||||
val = sti_mixer_reg_read(mixer, GAM_MIXER_CTL) & 0xFFFF0000;
|
||||
sti_mixer_reg_write(mixer, GAM_MIXER_CTL, val);
|
||||
}
|
||||
|
||||
void sti_mixer_set_matrix(struct sti_mixer *mixer)
|
||||
{
|
||||
unsigned int i;
|
||||
|
||||
@@ -15,6 +15,12 @@
|
||||
|
||||
#define to_sti_mixer(x) container_of(x, struct sti_mixer, drm_crtc)
|
||||
|
||||
enum sti_mixer_status {
|
||||
STI_MIXER_READY,
|
||||
STI_MIXER_DISABLING,
|
||||
STI_MIXER_DISABLED,
|
||||
};
|
||||
|
||||
/**
|
||||
* STI Mixer subdevice structure
|
||||
*
|
||||
@@ -23,7 +29,7 @@
|
||||
* @id: id of the mixer
|
||||
* @drm_crtc: crtc object link to the mixer
|
||||
* @pending_event: set if a flip event is pending on crtc
|
||||
* @enabled: to know if the mixer is active or not
|
||||
* @status: to know the status of the mixer
|
||||
*/
|
||||
struct sti_mixer {
|
||||
struct device *dev;
|
||||
@@ -31,7 +37,7 @@ struct sti_mixer {
|
||||
int id;
|
||||
struct drm_crtc drm_crtc;
|
||||
struct drm_pending_vblank_event *pending_event;
|
||||
bool enabled;
|
||||
enum sti_mixer_status status;
|
||||
};
|
||||
|
||||
const char *sti_mixer_to_str(struct sti_mixer *mixer);
|
||||
@@ -41,7 +47,6 @@ struct sti_mixer *sti_mixer_create(struct device *dev, int id,
|
||||
|
||||
int sti_mixer_set_plane_status(struct sti_mixer *mixer,
|
||||
struct sti_plane *plane, bool status);
|
||||
void sti_mixer_clear_all_planes(struct sti_mixer *mixer);
|
||||
int sti_mixer_set_plane_depth(struct sti_mixer *mixer, struct sti_plane *plane);
|
||||
int sti_mixer_active_video_area(struct sti_mixer *mixer,
|
||||
struct drm_display_mode *mode);
|
||||
|
||||
+16
-237
@@ -7,15 +7,12 @@
|
||||
*/
|
||||
|
||||
#include <drm/drmP.h>
|
||||
#include <drm/drm_atomic_helper.h>
|
||||
#include <drm/drm_gem_cma_helper.h>
|
||||
#include <drm/drm_fb_cma_helper.h>
|
||||
#include <drm/drm_plane_helper.h>
|
||||
#include <drm/drm_gem_cma_helper.h>
|
||||
|
||||
#include "sti_compositor.h"
|
||||
#include "sti_drv.h"
|
||||
#include "sti_plane.h"
|
||||
#include "sti_vtg.h"
|
||||
|
||||
/* (Background) < GDP0 < GDP1 < HQVDP0 < GDP2 < GDP3 < (ForeGround) */
|
||||
enum sti_plane_desc sti_plane_default_zorder[] = {
|
||||
@@ -47,115 +44,6 @@ const char *sti_plane_to_str(struct sti_plane *plane)
|
||||
}
|
||||
EXPORT_SYMBOL(sti_plane_to_str);
|
||||
|
||||
static int sti_plane_prepare(struct sti_plane *plane,
|
||||
struct drm_crtc *crtc,
|
||||
struct drm_framebuffer *fb,
|
||||
struct drm_display_mode *mode, int mixer_id,
|
||||
int dest_x, int dest_y, int dest_w, int dest_h,
|
||||
int src_x, int src_y, int src_w, int src_h)
|
||||
{
|
||||
struct drm_gem_cma_object *cma_obj;
|
||||
unsigned int i;
|
||||
int res;
|
||||
|
||||
if (!plane || !fb || !mode) {
|
||||
DRM_ERROR("Null fb, plane or mode\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
cma_obj = drm_fb_cma_get_gem_obj(fb, 0);
|
||||
if (!cma_obj) {
|
||||
DRM_ERROR("Can't get CMA GEM object for fb\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
plane->fb = fb;
|
||||
plane->mode = mode;
|
||||
plane->mixer_id = mixer_id;
|
||||
plane->dst_x = dest_x;
|
||||
plane->dst_y = dest_y;
|
||||
plane->dst_w = clamp_val(dest_w, 0, mode->crtc_hdisplay - dest_x);
|
||||
plane->dst_h = clamp_val(dest_h, 0, mode->crtc_vdisplay - dest_y);
|
||||
plane->src_x = src_x;
|
||||
plane->src_y = src_y;
|
||||
plane->src_w = src_w;
|
||||
plane->src_h = src_h;
|
||||
plane->format = fb->pixel_format;
|
||||
plane->vaddr = cma_obj->vaddr;
|
||||
plane->paddr = cma_obj->paddr;
|
||||
for (i = 0; i < 4; i++) {
|
||||
plane->pitches[i] = fb->pitches[i];
|
||||
plane->offsets[i] = fb->offsets[i];
|
||||
}
|
||||
|
||||
DRM_DEBUG_DRIVER("%s is associated with mixer_id %d\n",
|
||||
sti_plane_to_str(plane),
|
||||
plane->mixer_id);
|
||||
DRM_DEBUG_DRIVER("%s dst=(%dx%d)@(%d,%d) - src=(%dx%d)@(%d,%d)\n",
|
||||
sti_plane_to_str(plane),
|
||||
plane->dst_w, plane->dst_h, plane->dst_x, plane->dst_y,
|
||||
plane->src_w, plane->src_h, plane->src_x,
|
||||
plane->src_y);
|
||||
|
||||
DRM_DEBUG_DRIVER("drm FB:%d format:%.4s phys@:0x%lx\n", fb->base.id,
|
||||
(char *)&plane->format, (unsigned long)plane->paddr);
|
||||
|
||||
if (!plane->ops->prepare) {
|
||||
DRM_ERROR("Cannot prepare\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
res = plane->ops->prepare(plane, !plane->enabled);
|
||||
if (res) {
|
||||
DRM_ERROR("Plane prepare failed\n");
|
||||
return res;
|
||||
}
|
||||
|
||||
plane->enabled = true;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int sti_plane_commit(struct sti_plane *plane)
|
||||
{
|
||||
if (!plane)
|
||||
return 1;
|
||||
|
||||
if (!plane->ops->commit) {
|
||||
DRM_ERROR("Cannot commit\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
return plane->ops->commit(plane);
|
||||
}
|
||||
|
||||
static int sti_plane_disable(struct sti_plane *plane)
|
||||
{
|
||||
int res;
|
||||
|
||||
DRM_DEBUG_DRIVER("%s\n", sti_plane_to_str(plane));
|
||||
if (!plane)
|
||||
return 1;
|
||||
|
||||
if (!plane->enabled)
|
||||
return 0;
|
||||
|
||||
if (!plane->ops->disable) {
|
||||
DRM_ERROR("Cannot disable\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
res = plane->ops->disable(plane);
|
||||
if (res) {
|
||||
DRM_ERROR("Plane disable failed\n");
|
||||
return res;
|
||||
}
|
||||
|
||||
plane->enabled = false;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void sti_plane_destroy(struct drm_plane *drm_plane)
|
||||
{
|
||||
DRM_DEBUG_DRIVER("\n");
|
||||
@@ -182,109 +70,6 @@ static int sti_plane_set_property(struct drm_plane *drm_plane,
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
static struct drm_plane_funcs sti_plane_funcs = {
|
||||
.update_plane = drm_atomic_helper_update_plane,
|
||||
.disable_plane = drm_atomic_helper_disable_plane,
|
||||
.destroy = sti_plane_destroy,
|
||||
.set_property = sti_plane_set_property,
|
||||
.reset = drm_atomic_helper_plane_reset,
|
||||
.atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
|
||||
.atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
|
||||
};
|
||||
|
||||
static int sti_plane_atomic_check(struct drm_plane *drm_plane,
|
||||
struct drm_plane_state *state)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void sti_plane_atomic_update(struct drm_plane *drm_plane,
|
||||
struct drm_plane_state *oldstate)
|
||||
{
|
||||
struct drm_plane_state *state = drm_plane->state;
|
||||
struct sti_plane *plane = to_sti_plane(drm_plane);
|
||||
struct sti_mixer *mixer = to_sti_mixer(state->crtc);
|
||||
int res;
|
||||
|
||||
DRM_DEBUG_KMS("CRTC:%d (%s) drm plane:%d (%s)\n",
|
||||
state->crtc->base.id, sti_mixer_to_str(mixer),
|
||||
drm_plane->base.id, sti_plane_to_str(plane));
|
||||
DRM_DEBUG_KMS("(%dx%d)@(%d,%d)\n",
|
||||
state->crtc_w, state->crtc_h,
|
||||
state->crtc_x, state->crtc_y);
|
||||
|
||||
res = sti_mixer_set_plane_depth(mixer, plane);
|
||||
if (res) {
|
||||
DRM_ERROR("Cannot set plane depth\n");
|
||||
return;
|
||||
}
|
||||
|
||||
/* src_x are in 16.16 format */
|
||||
res = sti_plane_prepare(plane, state->crtc, state->fb,
|
||||
&state->crtc->mode, mixer->id,
|
||||
state->crtc_x, state->crtc_y,
|
||||
state->crtc_w, state->crtc_h,
|
||||
state->src_x >> 16, state->src_y >> 16,
|
||||
state->src_w >> 16, state->src_h >> 16);
|
||||
if (res) {
|
||||
DRM_ERROR("Plane prepare failed\n");
|
||||
return;
|
||||
}
|
||||
|
||||
res = sti_plane_commit(plane);
|
||||
if (res) {
|
||||
DRM_ERROR("Plane commit failed\n");
|
||||
return;
|
||||
}
|
||||
|
||||
res = sti_mixer_set_plane_status(mixer, plane, true);
|
||||
if (res) {
|
||||
DRM_ERROR("Cannot enable plane at mixer\n");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
static void sti_plane_atomic_disable(struct drm_plane *drm_plane,
|
||||
struct drm_plane_state *oldstate)
|
||||
{
|
||||
struct sti_plane *plane = to_sti_plane(drm_plane);
|
||||
struct sti_mixer *mixer = to_sti_mixer(drm_plane->crtc);
|
||||
int res;
|
||||
|
||||
if (!drm_plane->crtc) {
|
||||
DRM_DEBUG_DRIVER("drm plane:%d not enabled\n",
|
||||
drm_plane->base.id);
|
||||
return;
|
||||
}
|
||||
|
||||
DRM_DEBUG_DRIVER("CRTC:%d (%s) drm plane:%d (%s)\n",
|
||||
drm_plane->crtc->base.id, sti_mixer_to_str(mixer),
|
||||
drm_plane->base.id, sti_plane_to_str(plane));
|
||||
|
||||
/* Disable plane at mixer level */
|
||||
res = sti_mixer_set_plane_status(mixer, plane, false);
|
||||
if (res) {
|
||||
DRM_ERROR("Cannot disable plane at mixer\n");
|
||||
return;
|
||||
}
|
||||
|
||||
/* Wait a while to be sure that a Vsync event is received */
|
||||
msleep(WAIT_NEXT_VSYNC_MS);
|
||||
|
||||
/* Then disable plane itself */
|
||||
res = sti_plane_disable(plane);
|
||||
if (res) {
|
||||
DRM_ERROR("Plane disable failed\n");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
static const struct drm_plane_helper_funcs sti_plane_helpers_funcs = {
|
||||
.atomic_check = sti_plane_atomic_check,
|
||||
.atomic_update = sti_plane_atomic_update,
|
||||
.atomic_disable = sti_plane_atomic_disable,
|
||||
};
|
||||
|
||||
static void sti_plane_attach_zorder_property(struct drm_plane *drm_plane)
|
||||
{
|
||||
struct drm_device *dev = drm_plane->dev;
|
||||
@@ -305,25 +90,10 @@ static void sti_plane_attach_zorder_property(struct drm_plane *drm_plane)
|
||||
drm_object_attach_property(&drm_plane->base, prop, plane->zorder);
|
||||
}
|
||||
|
||||
struct drm_plane *sti_plane_init(struct drm_device *dev,
|
||||
struct sti_plane *plane,
|
||||
unsigned int possible_crtcs,
|
||||
enum drm_plane_type type)
|
||||
void sti_plane_init_property(struct sti_plane *plane,
|
||||
enum drm_plane_type type)
|
||||
{
|
||||
int err, i;
|
||||
|
||||
err = drm_universal_plane_init(dev, &plane->drm_plane,
|
||||
possible_crtcs,
|
||||
&sti_plane_funcs,
|
||||
plane->ops->get_formats(plane),
|
||||
plane->ops->get_nb_formats(plane),
|
||||
type);
|
||||
if (err) {
|
||||
DRM_ERROR("Failed to initialize universal plane\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
drm_plane_helper_add(&plane->drm_plane, &sti_plane_helpers_funcs);
|
||||
unsigned int i;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(sti_plane_default_zorder); i++)
|
||||
if (sti_plane_default_zorder[i] == plane->desc)
|
||||
@@ -337,7 +107,16 @@ struct drm_plane *sti_plane_init(struct drm_device *dev,
|
||||
DRM_DEBUG_DRIVER("drm plane:%d mapped to %s with zorder:%d\n",
|
||||
plane->drm_plane.base.id,
|
||||
sti_plane_to_str(plane), plane->zorder);
|
||||
|
||||
return &plane->drm_plane;
|
||||
}
|
||||
EXPORT_SYMBOL(sti_plane_init);
|
||||
EXPORT_SYMBOL(sti_plane_init_property);
|
||||
|
||||
struct drm_plane_funcs sti_plane_helpers_funcs = {
|
||||
.update_plane = drm_atomic_helper_update_plane,
|
||||
.disable_plane = drm_atomic_helper_disable_plane,
|
||||
.destroy = sti_plane_destroy,
|
||||
.set_property = sti_plane_set_property,
|
||||
.reset = drm_atomic_helper_plane_reset,
|
||||
.atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
|
||||
.atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
|
||||
};
|
||||
EXPORT_SYMBOL(sti_plane_helpers_funcs);
|
||||
|
||||
@@ -8,6 +8,10 @@
|
||||
#define _STI_PLANE_H_
|
||||
|
||||
#include <drm/drmP.h>
|
||||
#include <drm/drm_atomic_helper.h>
|
||||
#include <drm/drm_plane_helper.h>
|
||||
|
||||
extern struct drm_plane_funcs sti_plane_helpers_funcs;
|
||||
|
||||
#define to_sti_plane(x) container_of(x, struct sti_plane, drm_plane)
|
||||
|
||||
@@ -38,68 +42,30 @@ enum sti_plane_desc {
|
||||
STI_BACK = STI_BCK
|
||||
};
|
||||
|
||||
enum sti_plane_status {
|
||||
STI_PLANE_READY,
|
||||
STI_PLANE_UPDATED,
|
||||
STI_PLANE_DISABLING,
|
||||
STI_PLANE_FLUSHING,
|
||||
STI_PLANE_DISABLED,
|
||||
};
|
||||
|
||||
/**
|
||||
* STI plane structure
|
||||
*
|
||||
* @plane: drm plane it is bound to (if any)
|
||||
* @fb: drm fb it is bound to
|
||||
* @mode: display mode
|
||||
* @desc: plane type & id
|
||||
* @ops: plane functions
|
||||
* @status: to know the status of the plane
|
||||
* @zorder: plane z-order
|
||||
* @mixer_id: id of the mixer used to display the plane
|
||||
* @enabled: to know if the plane is active or not
|
||||
* @src_x src_y: coordinates of the input (fb) area
|
||||
* @src_w src_h: size of the input (fb) area
|
||||
* @dst_x dst_y: coordinates of the output (crtc) area
|
||||
* @dst_w dst_h: size of the output (crtc) area
|
||||
* @format: format
|
||||
* @pitches: pitch of 'planes' (eg: Y, U, V)
|
||||
* @offsets: offset of 'planes'
|
||||
* @vaddr: virtual address of the input buffer
|
||||
* @paddr: physical address of the input buffer
|
||||
*/
|
||||
struct sti_plane {
|
||||
struct drm_plane drm_plane;
|
||||
struct drm_framebuffer *fb;
|
||||
struct drm_display_mode *mode;
|
||||
enum sti_plane_desc desc;
|
||||
const struct sti_plane_funcs *ops;
|
||||
enum sti_plane_status status;
|
||||
int zorder;
|
||||
int mixer_id;
|
||||
bool enabled;
|
||||
int src_x, src_y;
|
||||
int src_w, src_h;
|
||||
int dst_x, dst_y;
|
||||
int dst_w, dst_h;
|
||||
uint32_t format;
|
||||
unsigned int pitches[4];
|
||||
unsigned int offsets[4];
|
||||
void *vaddr;
|
||||
dma_addr_t paddr;
|
||||
};
|
||||
|
||||
/**
|
||||
* STI plane functions structure
|
||||
*
|
||||
* @get_formats: get plane supported formats
|
||||
* @get_nb_formats: get number of format supported
|
||||
* @prepare: prepare plane before rendering
|
||||
* @commit: set plane for rendering
|
||||
* @disable: disable plane
|
||||
*/
|
||||
struct sti_plane_funcs {
|
||||
const uint32_t* (*get_formats)(struct sti_plane *plane);
|
||||
unsigned int (*get_nb_formats)(struct sti_plane *plane);
|
||||
int (*prepare)(struct sti_plane *plane, bool first_prepare);
|
||||
int (*commit)(struct sti_plane *plane);
|
||||
int (*disable)(struct sti_plane *plane);
|
||||
};
|
||||
|
||||
struct drm_plane *sti_plane_init(struct drm_device *dev,
|
||||
struct sti_plane *sti_plane,
|
||||
unsigned int possible_crtcs,
|
||||
enum drm_plane_type type);
|
||||
const char *sti_plane_to_str(struct sti_plane *plane);
|
||||
|
||||
void sti_plane_init_property(struct sti_plane *plane,
|
||||
enum drm_plane_type type);
|
||||
#endif
|
||||
|
||||
@@ -43,28 +43,37 @@
|
||||
#define VID_MPR2_BT709 0x07150545
|
||||
#define VID_MPR3_BT709 0x00000AE8
|
||||
|
||||
int sti_vid_commit(struct sti_vid *vid, struct sti_plane *plane)
|
||||
void sti_vid_commit(struct sti_vid *vid,
|
||||
struct drm_plane_state *state)
|
||||
{
|
||||
struct drm_display_mode *mode = plane->mode;
|
||||
struct drm_crtc *crtc = state->crtc;
|
||||
struct drm_display_mode *mode = &crtc->mode;
|
||||
int dst_x = state->crtc_x;
|
||||
int dst_y = state->crtc_y;
|
||||
int dst_w = clamp_val(state->crtc_w, 0, mode->crtc_hdisplay - dst_x);
|
||||
int dst_h = clamp_val(state->crtc_h, 0, mode->crtc_vdisplay - dst_y);
|
||||
u32 val, ydo, xdo, yds, xds;
|
||||
|
||||
/* Input / output size
|
||||
* Align to upper even value */
|
||||
dst_w = ALIGN(dst_w, 2);
|
||||
dst_h = ALIGN(dst_h, 2);
|
||||
|
||||
/* Unmask */
|
||||
val = readl(vid->regs + VID_CTL);
|
||||
val &= ~VID_CTL_IGNORE;
|
||||
writel(val, vid->regs + VID_CTL);
|
||||
|
||||
ydo = sti_vtg_get_line_number(*mode, plane->dst_y);
|
||||
yds = sti_vtg_get_line_number(*mode, plane->dst_y + plane->dst_h - 1);
|
||||
xdo = sti_vtg_get_pixel_number(*mode, plane->dst_x);
|
||||
xds = sti_vtg_get_pixel_number(*mode, plane->dst_x + plane->dst_w - 1);
|
||||
ydo = sti_vtg_get_line_number(*mode, dst_y);
|
||||
yds = sti_vtg_get_line_number(*mode, dst_y + dst_h - 1);
|
||||
xdo = sti_vtg_get_pixel_number(*mode, dst_x);
|
||||
xds = sti_vtg_get_pixel_number(*mode, dst_x + dst_w - 1);
|
||||
|
||||
writel((ydo << 16) | xdo, vid->regs + VID_VPO);
|
||||
writel((yds << 16) | xds, vid->regs + VID_VPS);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int sti_vid_disable(struct sti_vid *vid)
|
||||
void sti_vid_disable(struct sti_vid *vid)
|
||||
{
|
||||
u32 val;
|
||||
|
||||
@@ -72,8 +81,6 @@ int sti_vid_disable(struct sti_vid *vid)
|
||||
val = readl(vid->regs + VID_CTL);
|
||||
val |= VID_CTL_IGNORE;
|
||||
writel(val, vid->regs + VID_CTL);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void sti_vid_init(struct sti_vid *vid)
|
||||
|
||||
@@ -20,8 +20,9 @@ struct sti_vid {
|
||||
int id;
|
||||
};
|
||||
|
||||
int sti_vid_commit(struct sti_vid *vid, struct sti_plane *plane);
|
||||
int sti_vid_disable(struct sti_vid *vid);
|
||||
void sti_vid_commit(struct sti_vid *vid,
|
||||
struct drm_plane_state *state);
|
||||
void sti_vid_disable(struct sti_vid *vid);
|
||||
struct sti_vid *sti_vid_create(struct device *dev, int id,
|
||||
void __iomem *baseaddr);
|
||||
|
||||
|
||||
Reference in New Issue
Block a user