Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 871bcdfe authored by Vincent Abriou's avatar Vincent Abriou Committed by Benjamin Gaignard
Browse files

drm/sti: code clean up 



Purpose is to simplify the STI driver:
- remove layer structure
- consider video subdev as part of the compositor (like mixer subdev)
- remove useless STI_VID0 and STI_VID1 enum

Signed-off-by: default avatarVincent Abriou <vincent.abriou@st.com>
Reviewed-by: default avatarBenjamin Gaignard <benjamin.gaignard@linaro.org>
parent bf60b29f

drivers/gpu/drm/sti/Makefile

+0 −1
Original line number Diff line number Diff line 
sticompositor-y := \

	sti_layer.o \

	sti_mixer.o \

	sti_gdp.o \

	sti_vid.o \

drivers/gpu/drm/sti/sti_compositor.c

+69 −66
Original line number Diff line number Diff line
@@ -14,10 +14,12 @@ 
#include <drm/drmP.h>



#include "sti_compositor.h"

#include "sti_cursor.h"

#include "sti_drm_crtc.h"

#include "sti_drm_drv.h"

#include "sti_drm_plane.h"

#include "sti_gdp.h"

#include "sti_vid.h"

#include "sti_vtg.h"



/*
@@ -31,7 +33,7 @@ struct sti_compositor_data stih407_compositor_data = { 
			{STI_GPD_SUBDEV, (int)STI_GDP_1, 0x200},

			{STI_GPD_SUBDEV, (int)STI_GDP_2, 0x300},

			{STI_GPD_SUBDEV, (int)STI_GDP_3, 0x400},

			{STI_VID_SUBDEV, (int)STI_VID_0, 0x700},

			{STI_VID_SUBDEV, (int)STI_HQVDP_0, 0x700},

			{STI_MIXER_MAIN_SUBDEV, STI_MIXER_MAIN, 0xC00},

			{STI_MIXER_AUX_SUBDEV, STI_MIXER_AUX, 0xD00},

	},
@@ -53,14 +55,31 @@ struct sti_compositor_data stih416_compositor_data = { 
	},

};



static int sti_compositor_init_subdev(struct sti_compositor *compo,

		struct sti_compositor_subdev_descriptor *desc,

		unsigned int array_size)

static int sti_compositor_bind(struct device *dev,

			       struct device *master,

			       void *data)

{

	unsigned int i, mixer_id = 0, layer_id = 0;

	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;

	struct sti_drm_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 */

	for (i = 0; i < array_size; i++) {

		switch (desc[i].type) {

		case STI_VID_SUBDEV:

			compo->vid[vid_id++] =

			    sti_vid_create(compo->dev, desc[i].id,

					   compo->regs + desc[i].offset);

			break;

		case STI_MIXER_MAIN_SUBDEV:

		case STI_MIXER_AUX_SUBDEV:

			compo->mixer[mixer_id++] =
@@ -68,81 +87,72 @@ static int sti_compositor_init_subdev(struct sti_compositor *compo, 
					     compo->regs + desc[i].offset);

			break;

		case STI_GPD_SUBDEV:

		case STI_VID_SUBDEV:

		case STI_CURSOR_SUBDEV:

			compo->layer[layer_id++] =

			    sti_layer_create(compo->dev, desc[i].id,

					     compo->regs + desc[i].offset);

			/* Nothing to do, wait for the second round */

			break;

		default:

			DRM_ERROR("Unknow subdev compoment type\n");

			return 1;

		}



	}

	compo->nb_mixers = mixer_id;

	compo->nb_layers = layer_id;



	return 0;

	}



static int sti_compositor_bind(struct device *dev, struct device *master,

	void *data)

{

	struct sti_compositor *compo = dev_get_drvdata(dev);

	struct drm_device *drm_dev = data;

	unsigned int i, crtc = 0, plane = 0;

	struct sti_drm_private *dev_priv = drm_dev->dev_private;

	struct drm_plane *cursor = NULL;

	struct drm_plane *primary = NULL;



	dev_priv->compo = compo;



	for (i = 0; i < compo->nb_layers; i++) {

		if (compo->layer[i]) {

			enum sti_layer_desc desc = compo->layer[i]->desc;

			enum sti_layer_type type = desc & STI_LAYER_TYPE_MASK;

	/* Register the other subdevs, create crtc and planes */

	for (i = 0; i < array_size; i++) {

		enum drm_plane_type plane_type = DRM_PLANE_TYPE_OVERLAY;



			if (crtc < compo->nb_mixers)

		if (crtc_id < mixer_id)

			plane_type = DRM_PLANE_TYPE_PRIMARY;



			switch (type) {

			case STI_CUR:

				cursor = sti_drm_plane_init(drm_dev,

						compo->layer[i],

						1, DRM_PLANE_TYPE_CURSOR);

		switch (desc[i].type) {

		case STI_MIXER_MAIN_SUBDEV:

		case STI_MIXER_AUX_SUBDEV:

		case STI_VID_SUBDEV:

			/* Nothing to do, already done at the first round */

			break;

			case STI_GDP:

			case STI_VID:

				primary = sti_drm_plane_init(drm_dev,

						compo->layer[i],

						(1 << compo->nb_mixers) - 1,

						plane_type);

				plane++;

		case STI_CURSOR_SUBDEV:

			plane = sti_cursor_create(compo->dev, desc[i].id,

						  compo->regs + desc[i].offset);

			if (!plane) {

				DRM_ERROR("Can't create CURSOR plane\n");

				break;

			case STI_BCK:

			case STI_VDP:

			}

			cursor = sti_drm_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) {

				DRM_ERROR("Can't create GDP plane\n");

				break;

			}

			primary = sti_drm_plane_init(drm_dev, plane,

						     (1 << mixer_id) - 1,

						     plane_type);

			plane_id++;

			break;

		default:

			DRM_ERROR("Unknown subdev compoment type\n");

			return 1;

		}



		/* The first planes are reserved for primary planes*/

			if (crtc < compo->nb_mixers && primary) {

				sti_drm_crtc_init(drm_dev, compo->mixer[crtc],

		if (crtc_id < mixer_id && primary) {

			sti_drm_crtc_init(drm_dev, compo->mixer[crtc_id],

					  primary, cursor);

				crtc++;

			crtc_id++;

			cursor = NULL;

			primary = NULL;

		}

	}

	}



	drm_vblank_init(drm_dev, crtc);

	drm_vblank_init(drm_dev, crtc_id);

	/* 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, plane);

			 crtc_id, plane_id);

	DRM_DEBUG_DRIVER("DRM plane(s) for VID/VDP not created yet\n");



	return 0;
@@ -179,7 +189,6 @@ static int sti_compositor_probe(struct platform_device *pdev) 
	struct device_node *vtg_np;

	struct sti_compositor *compo;

	struct resource *res;

	int err;



	compo = devm_kzalloc(dev, sizeof(*compo), GFP_KERNEL);

	if (!compo) {
@@ -251,12 +260,6 @@ static int sti_compositor_probe(struct platform_device *pdev) 
	if (vtg_np)

		compo->vtg_aux = of_vtg_find(vtg_np);



	/* Initialize compositor subdevices */

	err = sti_compositor_init_subdev(compo, compo->data.subdev_desc,

					 compo->data.nb_subdev);

	if (err)

		return err;



	platform_set_drvdata(pdev, compo);



	return component_add(&pdev->dev, &sti_compositor_ops);

drivers/gpu/drm/sti/sti_compositor.h

+4 −8
Original line number Diff line number Diff line
@@ -12,13 +12,13 @@ 
#include <linux/clk.h>

#include <linux/kernel.h>



#include "sti_layer.h"

#include "sti_drm_plane.h"

#include "sti_mixer.h"



#define WAIT_NEXT_VSYNC_MS      50 /*ms*/



#define STI_MAX_LAYER 8

#define STI_MAX_MIXER 2

#define STI_MAX_VID   1



enum sti_compositor_subdev_type {

	STI_MIXER_MAIN_SUBDEV,
@@ -59,11 +59,9 @@ struct sti_compositor_data { 
 * @rst_main: reset control of the main path

 * @rst_aux: reset control of the aux path

 * @mixer: array of mixers

 * @vid: array of vids

 * @vtg_main: vtg for main data path

 * @vtg_aux: vtg for auxillary data path

 * @layer: array of layers

 * @nb_mixers: number of mixers for this compositor

 * @nb_layers: number of layers (GDP,VID,...) for this compositor

 * @vtg_vblank_nb: callback for VTG VSYNC notification

 */

struct sti_compositor {
@@ -77,11 +75,9 @@ struct sti_compositor { 
	struct reset_control *rst_main;

	struct reset_control *rst_aux;

	struct sti_mixer *mixer[STI_MAX_MIXER];

	struct sti_vid *vid[STI_MAX_VID];

	struct sti_vtg *vtg_main;

	struct sti_vtg *vtg_aux;

	struct sti_layer *layer[STI_MAX_LAYER];

	int nb_mixers;

	int nb_layers;

	struct notifier_block vtg_vblank_nb;

};

drivers/gpu/drm/sti/sti_cursor.c

+58 −50
Original line number Diff line number Diff line
@@ -8,7 +8,7 @@ 
#include <drm/drmP.h>



#include "sti_cursor.h"

#include "sti_layer.h"

#include "sti_drm_plane.h"

#include "sti_vtg.h"



/* Registers */
@@ -42,7 +42,9 @@ struct dma_pixmap { 
/**

 * STI Cursor structure

 *

 * @layer:      layer structure

 * @sti_plane:  sti_plane structure

 * @dev:        driver device

 * @regs:       cursor registers

 * @width:      cursor width

 * @height:     cursor height

 * @clut:       color look up table
@@ -50,7 +52,9 @@ struct dma_pixmap { 
 * @pixmap:     pixmap dma buffer (clut8-format cursor)

 */

struct sti_cursor {

	struct sti_layer layer;

	struct sti_plane plane;

	struct device *dev;

	void __iomem *regs;

	unsigned int width;

	unsigned int height;

	unsigned short *clut;
@@ -62,22 +66,22 @@ static const uint32_t cursor_supported_formats[] = { 
	DRM_FORMAT_ARGB8888,

};



#define to_sti_cursor(x) container_of(x, struct sti_cursor, layer)

#define to_sti_cursor(x) container_of(x, struct sti_cursor, plane)



static const uint32_t *sti_cursor_get_formats(struct sti_layer *layer)

static const uint32_t *sti_cursor_get_formats(struct sti_plane *plane)

{

	return cursor_supported_formats;

}



static unsigned int sti_cursor_get_nb_formats(struct sti_layer *layer)

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_layer *layer)

static void sti_cursor_argb8888_to_clut8(struct sti_plane *plane)

{

	struct sti_cursor *cursor = to_sti_cursor(layer);

	u32 *src = layer->vaddr;

	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;
@@ -96,42 +100,42 @@ static void sti_cursor_argb8888_to_clut8(struct sti_layer *layer) 
	}

}



static int sti_cursor_prepare_layer(struct sti_layer *layer, bool first_prepare)

static int sti_cursor_prepare_plane(struct sti_plane *plane, bool first_prepare)

{

	struct sti_cursor *cursor = to_sti_cursor(layer);

	struct drm_display_mode *mode = layer->mode;

	struct sti_cursor *cursor = to_sti_cursor(plane);

	struct drm_display_mode *mode = plane->mode;

	u32 y, x;

	u32 val;



	DRM_DEBUG_DRIVER("\n");



	dev_dbg(layer->dev, "%s %s\n", __func__, sti_layer_to_str(layer));

	dev_dbg(cursor->dev, "%s %s\n", __func__, sti_plane_to_str(plane));



	if (layer->src_w < STI_CURS_MIN_SIZE ||

	    layer->src_h < STI_CURS_MIN_SIZE ||

	    layer->src_w > STI_CURS_MAX_SIZE ||

	    layer->src_h > STI_CURS_MAX_SIZE) {

	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) {

		DRM_ERROR("Invalid cursor size (%dx%d)\n",

				layer->src_w, layer->src_h);

				plane->src_w, plane->src_h);

		return -EINVAL;

	}



	/* If the cursor size has changed, re-allocated the pixmap */

	if (!cursor->pixmap.base ||

	    (cursor->width != layer->src_w) ||

	    (cursor->height != layer->src_h)) {

		cursor->width = layer->src_w;

		cursor->height = layer->src_h;

	    (cursor->width != plane->src_w) ||

	    (cursor->height != plane->src_h)) {

		cursor->width = plane->src_w;

		cursor->height = plane->src_h;



		if (cursor->pixmap.base)

			dma_free_writecombine(layer->dev,

			dma_free_writecombine(cursor->dev,

					      cursor->pixmap.size,

					      cursor->pixmap.base,

					      cursor->pixmap.paddr);



		cursor->pixmap.size = cursor->width * cursor->height;



		cursor->pixmap.base = dma_alloc_writecombine(layer->dev,

		cursor->pixmap.base = dma_alloc_writecombine(cursor->dev,

							cursor->pixmap.size,

							&cursor->pixmap.paddr,

							GFP_KERNEL | GFP_DMA);
@@ -142,55 +146,54 @@ static int sti_cursor_prepare_layer(struct sti_layer *layer, bool first_prepare) 
	}



	/* Convert ARGB8888 to CLUT8 */

	sti_cursor_argb8888_to_clut8(layer);

	sti_cursor_argb8888_to_clut8(plane);



	/* AWS and AWE depend on the mode */

	y = sti_vtg_get_line_number(*mode, 0);

	x = sti_vtg_get_pixel_number(*mode, 0);

	val = y << 16 | x;

	writel(val, layer->regs + CUR_AWS);

	writel(val, cursor->regs + CUR_AWS);

	y = sti_vtg_get_line_number(*mode, mode->vdisplay - 1);

	x = sti_vtg_get_pixel_number(*mode, mode->hdisplay - 1);

	val = y << 16 | x;

	writel(val, layer->regs + CUR_AWE);

	writel(val, cursor->regs + CUR_AWE);



	if (first_prepare) {

		/* Set and fetch CLUT */

		writel(cursor->clut_paddr, layer->regs + CUR_CML);

		writel(CUR_CTL_CLUT_UPDATE, layer->regs + CUR_CTL);

		writel(cursor->clut_paddr, cursor->regs + CUR_CML);

		writel(CUR_CTL_CLUT_UPDATE, cursor->regs + CUR_CTL);

	}



	return 0;

}



static int sti_cursor_commit_layer(struct sti_layer *layer)

static int sti_cursor_commit_plane(struct sti_plane *plane)

{

	struct sti_cursor *cursor = to_sti_cursor(layer);

	struct drm_display_mode *mode = layer->mode;

	struct sti_cursor *cursor = to_sti_cursor(plane);

	struct drm_display_mode *mode = plane->mode;

	u32 ydo, xdo;



	dev_dbg(layer->dev, "%s %s\n", __func__, sti_layer_to_str(layer));

	dev_dbg(cursor->dev, "%s %s\n", __func__, sti_plane_to_str(plane));



	/* Set memory location, size, and position */

	writel(cursor->pixmap.paddr, layer->regs + CUR_PML);

	writel(cursor->width, layer->regs + CUR_PMP);

	writel(cursor->height << 16 | cursor->width, layer->regs + CUR_SIZE);

	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, layer->dst_y);

	xdo = sti_vtg_get_pixel_number(*mode, layer->dst_y);

	writel((ydo << 16) | xdo, layer->regs + CUR_VPO);

	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);



	return 0;

}



static int sti_cursor_disable_layer(struct sti_layer *layer)

static int sti_cursor_disable_plane(struct sti_plane *plane)

{

	return 0;

}



static void sti_cursor_init(struct sti_layer *layer)

static void sti_cursor_init(struct sti_cursor *cursor)

{

	struct sti_cursor *cursor = to_sti_cursor(layer);

	unsigned short *base = cursor->clut;

	unsigned int a, r, g, b;
@@ -205,16 +208,16 @@ static void sti_cursor_init(struct sti_layer *layer) 
						  (b * 5);

}



static const struct sti_layer_funcs cursor_ops = {

static const struct sti_plane_funcs cursor_plane_ops = {

	.get_formats = sti_cursor_get_formats,

	.get_nb_formats = sti_cursor_get_nb_formats,

	.init = sti_cursor_init,

	.prepare = sti_cursor_prepare_layer,

	.commit = sti_cursor_commit_layer,

	.disable = sti_cursor_disable_layer,

	.prepare = sti_cursor_prepare_plane,

	.commit = sti_cursor_commit_plane,

	.disable = sti_cursor_disable_plane,

};



struct sti_layer *sti_cursor_create(struct device *dev)

struct sti_plane *sti_cursor_create(struct device *dev, int desc,

				    void __iomem *baseaddr)

{

	struct sti_cursor *cursor;
@@ -236,7 +239,12 @@ struct sti_layer *sti_cursor_create(struct device *dev) 
		return NULL;

	}



	cursor->layer.ops = &cursor_ops;

	cursor->dev = dev;

	cursor->regs = baseaddr;

	cursor->plane.desc = desc;

	cursor->plane.ops = &cursor_plane_ops;



	return (struct sti_layer *)cursor;

	sti_cursor_init(cursor);



	return &cursor->plane;

}

drivers/gpu/drm/sti/sti_cursor.h

+2 −1
Original line number Diff line number Diff line
@@ -7,6 +7,7 @@ 
#ifndef _STI_CURSOR_H_

#define _STI_CURSOR_H_



struct sti_layer *sti_cursor_create(struct device *dev);

struct sti_plane *sti_cursor_create(struct device *dev, int desc,

				    void __iomem *baseaddr);



#endif