For Z order property we have take example on exynos driver and keep the same property name to avoid forking.
I would prefer to not hardcode Z order because we use it to do a kind of composition between graphical planes and video planes. It allow us to manage the Z order of some windows without using software composition.
If you have a link to the plane properties talks we will happy to follow/participate and fix the driver according to what will be defined.
Benjamin
2014-04-11 12:26 GMT+02:00 Daniel Vetter daniel@ffwll.ch:
On Tue, Apr 08, 2014 at 02:19:24PM +0200, Benjamin Gaignard wrote:
Make the link between all the hardware drivers and DRM/KMS interface. Create the driver itself and make it register all the sub-components. Use GEM CMA helpers for buffer allocation.
Signed-off-by: Benjamin Gaignard benjamin.gaignard@linaro.org Signed-off-by: Vincent Abriou vincent.abriou@st.com Signed-off-by: Fabien Dessenne fabien.dessenne@st.com
drivers/gpu/drm/sti/Kconfig | 8 + drivers/gpu/drm/sti/Makefile | 28 +- drivers/gpu/drm/sti/sti_compositor.c | 2 + drivers/gpu/drm/sti/sti_drm_connector.c | 195 +++++++++++++ drivers/gpu/drm/sti/sti_drm_connector.h | 16 ++ drivers/gpu/drm/sti/sti_drm_crtc.c | 440 ++++++++++++++++++++++++++++++ drivers/gpu/drm/sti/sti_drm_crtc.h | 21 ++ drivers/gpu/drm/sti/sti_drm_drv.c | 466 ++++++++++++++++++++++++++++++++ drivers/gpu/drm/sti/sti_drm_encoder.c | 201 ++++++++++++++ drivers/gpu/drm/sti/sti_drm_encoder.h | 16 ++ drivers/gpu/drm/sti/sti_drm_plane.c | 195 +++++++++++++ drivers/gpu/drm/sti/sti_drm_plane.h | 16 ++ drivers/gpu/drm/sti/sti_vtg_utils.h | 2 + 13 files changed, 1594 insertions(+), 12 deletions(-) create mode 100644 drivers/gpu/drm/sti/sti_drm_connector.c create mode 100644 drivers/gpu/drm/sti/sti_drm_connector.h create mode 100644 drivers/gpu/drm/sti/sti_drm_crtc.c create mode 100644 drivers/gpu/drm/sti/sti_drm_crtc.h create mode 100644 drivers/gpu/drm/sti/sti_drm_drv.c create mode 100644 drivers/gpu/drm/sti/sti_drm_encoder.c create mode 100644 drivers/gpu/drm/sti/sti_drm_encoder.h create mode 100644 drivers/gpu/drm/sti/sti_drm_plane.c create mode 100644 drivers/gpu/drm/sti/sti_drm_plane.h
diff --git a/drivers/gpu/drm/sti/Kconfig b/drivers/gpu/drm/sti/Kconfig index a958398..61c8bd4 100644 --- a/drivers/gpu/drm/sti/Kconfig +++ b/drivers/gpu/drm/sti/Kconfig @@ -1,10 +1,18 @@ config DRM_STI tristate "DRM Support for STMicroelectronics SoC stiH41x Series" depends on DRM && (SOC_STIH415 || SOC_STIH416 || ARCH_MULTIPLATFORM)
select DRM_KMS_HELPERselect DRM_GEM_CMA_HELPER select DRM_KMS_CMA_HELPER help Choose this option to enable DRM on STM stiH41x chipset+config DRM_STI_FBDEV
tristate "DRM frame buffer device for STMicroelectronics SoC stiH41x Serie"depends on DRM_STIhelpChoose this option to enable FBDEV on top of DRM for STM stiH41x chipsetconfig VTAC_STI tristate "Video Trafic Advance Communication Rx and Tx for STMicroelectronics SoC stiH41x Series" depends on DRM_STI diff --git a/drivers/gpu/drm/sti/Makefile b/drivers/gpu/drm/sti/Makefile index d598adc..17b4a68 100644 --- a/drivers/gpu/drm/sti/Makefile +++ b/drivers/gpu/drm/sti/Makefile @@ -1,17 +1,21 @@ ccflags-y := -Iinclude/drm
-stidrm-y := \
sti_compositor.o \sti_mixer.o \sti_layer.o \sti_gdp.o \sti_vid.o \sti_tvout.o \sti_hdmi.o \sti_hdmi_tx3g0c55phy.o \sti_hdmi_tx3g4c28phy.o \sti_hda.o \sti_ddc.o+stidrm-y := sti_drm_drv.o \
sti_drm_crtc.o \sti_drm_plane.o \sti_drm_connector.o \sti_drm_encoder.o \sti_compositor.o \sti_mixer.o \sti_layer.o \sti_gdp.o \sti_vid.o \sti_tvout.o \sti_hdmi.o \sti_hdmi_tx3g0c55phy.o \sti_hdmi_tx3g4c28phy.o \sti_hda.o \sti_ddc.oobj-$(CONFIG_DRM_STI) += stidrm.o obj-$(CONFIG_VTAC_STI) += sti_vtac_tx.o sti_vtac_rx.o diff --git a/drivers/gpu/drm/sti/sti_compositor.c b/drivers/gpu/drm/sti/sti_compositor.c index a163344..4d8d0958 100644 --- a/drivers/gpu/drm/sti/sti_compositor.c +++ b/drivers/gpu/drm/sti/sti_compositor.c @@ -14,6 +14,7 @@
#include "sti_compositor.h" #include "sti_gdp.h" +#include "sti_drm_crtc.h"
static const struct of_device_id compositor_match_types[];
@@ -98,6 +99,7 @@ static int sti_compositor_probe(struct platform_device *pdev) } DRM_DEBUG_DRIVER("Compositor %p\n", compo); compo->dev = dev;
compo->vtg_vblank_nb.notifier_call = sti_drm_crtc_vblank_cb; /* populate data structure depending on compatibility */ BUG_ON(!of_match_node(compositor_match_types, np)->data);diff --git a/drivers/gpu/drm/sti/sti_drm_connector.c b/drivers/gpu/drm/sti/sti_drm_connector.c new file mode 100644 index 0000000..b34a402 --- /dev/null +++ b/drivers/gpu/drm/sti/sti_drm_connector.c @@ -0,0 +1,195 @@ +/*
- Copyright (C) STMicroelectronics SA 2013
- Author: Benjamin Gaignard benjamin.gaignard@st.com for STMicroelectronics.
- License terms: GNU General Public License (GPL), version 2
- */
+#include <drm/drmP.h> +#include <drm/drm_crtc_helper.h>
+#include "sti_drm_connector.h" +#include "sti_drm_drv.h"
+#define to_sti_connector(x) container_of(x, struct sti_connector, drm_connector)
+/*
- sti specific connector structure
- @drm_encoder: connector object
- @encoder: associated encoder
- @tvout: pointer on tvout driver
- @type: tvout connector type
- */
+struct sti_connector {
struct drm_connector drm_connector;struct drm_encoder *encoder;struct sti_tvout *tvout;enum sti_tvout_connector_type type;+};
+static int sti_drm_connector_get_modes(struct drm_connector *connector) +{
struct sti_connector *sti_connector = to_sti_connector(connector);struct drm_device *dev = connector->dev;dev_dbg(dev->dev, "%s\n", __func__);return sti_tvout_get_modes(sti_connector->tvout, sti_connector->type,connector);+}
+static int sti_drm_connector_mode_valid(struct drm_connector *connector,
struct drm_display_mode *mode)+{
struct sti_connector *sti_connector = to_sti_connector(connector);struct drm_device *dev = connector->dev;int ret = MODE_BAD;dev_dbg(dev->dev, "%s\n", __func__);if (!sti_tvout_check_mode(sti_connector->tvout, sti_connector->type, mode))ret = MODE_OK;return ret;+}
+struct drm_encoder *sti_drm_best_encoder(struct drm_connector *connector) +{
struct sti_connector *sti_connector = to_sti_connector(connector);struct drm_device *dev = connector->dev;dev_dbg(dev->dev, "%s\n", __func__);/* Best encoder is the one associated during connector creation */return sti_connector->encoder;+}
+static struct drm_connector_helper_funcs sti_drm_connector_helper_funcs = {
.get_modes = sti_drm_connector_get_modes,.mode_valid = sti_drm_connector_mode_valid,.best_encoder = sti_drm_best_encoder,+};
+static void sti_drm_connector_dpms(struct drm_connector *connector, int mode) +{
struct drm_device *dev = connector->dev;dev_dbg(dev->dev, "%s\n", __func__);drm_helper_connector_dpms(connector, mode);+}
+/* get detection status of display device. */ +static enum drm_connector_status +sti_drm_connector_detect(struct drm_connector *connector, bool force) +{
enum drm_connector_status status = connector_status_disconnected;struct sti_connector *sti_connector = to_sti_connector(connector);struct drm_device *dev = connector->dev;dev_dbg(dev->dev, "%s\n", __func__);if (sti_tvout_connector_detect(sti_connector->tvout,sti_connector->type))status = connector_status_connected;return status;+}
+static void sti_drm_connector_destroy(struct drm_connector *connector) +{
struct sti_connector *sti_connector = to_sti_connector(connector);struct drm_device *dev = connector->dev;dev_dbg(dev->dev, "%s\n", __func__);drm_sysfs_connector_remove(connector);drm_connector_cleanup(connector);kfree(sti_connector);+}
+static struct drm_connector_funcs sti_drm_connector_funcs = {
.dpms = sti_drm_connector_dpms,.fill_modes = drm_helper_probe_single_connector_modes,.detect = sti_drm_connector_detect,.destroy = sti_drm_connector_destroy,+};
+struct drm_connector *sti_drm_connector_create(struct drm_device *dev,
struct sti_tvout *tvout,struct drm_encoder *encoder,enum sti_tvout_connector_typetype)+{
struct sti_connector *sti_connector;struct drm_connector *connector;int connector_type;int err;dev_dbg(dev->dev, "%s\n", __func__);/* Create the tvout connector according to the type */tvout->connector[type] = tvout->connector_create[type] (tvout);if (!tvout->connector[type]) {DRM_INFO("%s: failed to create connector (type = %d)\n",__func__, type);return NULL;}sti_connector = kzalloc(sizeof(*sti_connector), GFP_KERNEL);if (!sti_connector) {DRM_ERROR("failed to allocate connector\n");return NULL;}connector = &sti_connector->drm_connector;switch (type) {case STI_TVOUT_CONNECTOR_HDMI:connector_type = DRM_MODE_CONNECTOR_HDMIA;connector->polled = DRM_CONNECTOR_POLL_HPD;break;case STI_TVOUT_CONNECTOR_HDA:connector_type = DRM_MODE_CONNECTOR_Component;break;case STI_TVOUT_CONNECTOR_DVO:connector_type = DRM_MODE_CONNECTOR_LVDS;break;case STI_TVOUT_CONNECTOR_DENC:connector_type = DRM_MODE_CONNECTOR_Composite;break;default:connector_type = DRM_MODE_CONNECTOR_Unknown;break;}drm_connector_init(dev, connector, &sti_drm_connector_funcs,connector_type);drm_connector_helper_add(connector, &sti_drm_connector_helper_funcs);err = drm_sysfs_connector_add(connector);if (err)goto err_connector;sti_connector->tvout = tvout;sti_connector->encoder = encoder;sti_connector->type = type;err = drm_mode_connector_attach_encoder(connector, encoder);if (err) {DRM_ERROR("Failed to attach a connector to a encoder\n");goto err_sysfs;}DRM_DEBUG_DRIVER("Connector has been created\n");return connector;+err_sysfs:
drm_sysfs_connector_remove(connector);+err_connector:
drm_connector_cleanup(connector);kfree(sti_connector);return NULL;+} diff --git a/drivers/gpu/drm/sti/sti_drm_connector.h b/drivers/gpu/drm/sti/sti_drm_connector.h new file mode 100644 index 0000000..068c674 --- /dev/null +++ b/drivers/gpu/drm/sti/sti_drm_connector.h @@ -0,0 +1,16 @@ +/*
- Copyright (C) STMicroelectronics SA 2013
- Author: Benjamin Gaignard benjamin.gaignard@st.com for STMicroelectronics.
- License terms: GNU General Public License (GPL), version 2
- */
+#ifndef _STI_DRM_CONNECTOR_H_ +#define _STI_DRM_CONNECTOR_H_
+#include "sti_tvout.h"
+struct drm_connector *sti_drm_connector_create(struct drm_device *dev,
struct sti_tvout *tvout, struct drm_encoder *encoder,enum sti_tvout_connector_type type);+#endif diff --git a/drivers/gpu/drm/sti/sti_drm_crtc.c b/drivers/gpu/drm/sti/sti_drm_crtc.c new file mode 100644 index 0000000..5c06d70 --- /dev/null +++ b/drivers/gpu/drm/sti/sti_drm_crtc.c @@ -0,0 +1,440 @@ +/*
- Copyright (C) STMicroelectronics SA 2013
- Authors: Benjamin Gaignard benjamin.gaignard@st.com
Fabien Dessenne <fabien.dessenne@st.com>
for STMicroelectronics.
- License terms: GNU General Public License (GPL), version 2
- */
+#include <linux/clk.h>
+#include <drm/drmP.h> +#include <drm/drm_crtc_helper.h>
+#include "sti_drm_drv.h" +#include "sti_drm_crtc.h" +#include "sti_compositor.h" +#include "sti_vtg_utils.h"
+static void sti_drm_crtc_dpms(struct drm_crtc *crtc, int mode) +{
DRM_DEBUG_KMS("\n");+}
+static void sti_drm_crtc_prepare(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);compo->enable = true;/* Prepare and enable the compo IP clock */if (mixer->id == STI_MIXER_MAIN) {if (clk_prepare_enable(compo->clk_compo_main))DRM_INFO("Failed to prepare/enable compo_main clk\n");} else {if (clk_prepare_enable(compo->clk_compo_aux))DRM_INFO("Failed to prepare/enable compo_aux clk\n");}+}
+static void sti_drm_crtc_commit(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_layer *layer;dev_dbg(dev, "%s\n", __func__);if ((!mixer || !compo)) {DRM_ERROR("Can not find mixer or compositor)\n");return;}/* Find GDP0 which is reserved to the CRTC FB */layer = sti_layer_find_layer(compo->layer, STI_GDP_0);if (layer)sti_layer_commit(layer);elseDRM_ERROR("Can not find CRTC dedicated plane (GDP0)\n");/* Enable layer on mixer */if (sti_mixer_set_layer_status(mixer, layer, true))DRM_ERROR("Can not enable layer at mixer\n");+}
+static bool sti_drm_crtc_mode_fixup(struct drm_crtc *crtc,
const struct drm_display_mode *mode,struct drm_display_mode *adjusted_mode)+{
/* accept the provided drm_display_mode, do not fix it up */dev_dbg(crtc->dev->dev, "%s\n", __func__);return true;+}
+static int +sti_drm_crtc_mode_set(struct drm_crtc *crtc, struct drm_display_mode *mode,
struct drm_display_mode *adjusted_mode, int x, int y,struct drm_framebuffer *old_fb)+{
struct sti_mixer *mixer = to_sti_mixer(crtc);struct device *dev = mixer->dev;struct sti_compositor *compo = dev_get_drvdata(dev);struct sti_layer *layer;struct clk *clk;int rate = mode->clock * 1000;int res;unsigned int w, h;DRM_DEBUG_KMS("CRTC:%d (%s) fb:%d mode:%d (%s)\n",crtc->base.id, sti_mixer_to_str(mixer),crtc->fb->base.id, mode->base.id, mode->name);DRM_DEBUG_KMS("%d %d %d %d %d %d %d %d %d %d 0x%x 0x%x\n",mode->vrefresh, mode->clock,mode->hdisplay,mode->hsync_start, mode->hsync_end,mode->htotal,mode->vdisplay,mode->vsync_start, mode->vsync_end,mode->vtotal, mode->type, mode->flags);/* Set rate and prepare/enable pixel clock */if (mixer->id == STI_MIXER_MAIN)clk = compo->clk_pix_main;elseclk = compo->clk_pix_aux;res = clk_set_rate(clk, rate);if (res < 0) {DRM_ERROR("Cannot set rate (%dHz) for pix clk\n", rate);return 1;}if (clk_prepare_enable(clk)) {DRM_ERROR("Failed to prepare/enable pix clk\n");return 1;}sti_vtg_setconfig(mixer->id == STI_MIXER_MAIN ? VTG_MAIN : VTG_AUX,&crtc->mode);/* GDP0 is reserved to the CRTC FB */layer = sti_layer_find_layer(compo->layer, STI_GDP_0);if (!layer) {DRM_ERROR("Can not find GDP0)\n");return 1;}/* copy the mode data adjusted by mode_fixup() into crtc->mode* so that hardware can be set to proper mode */memcpy(&crtc->mode, adjusted_mode, sizeof(*adjusted_mode));res = sti_mixer_set_layer_depth(mixer, layer);if (res) {DRM_ERROR("Can not set layer depth\n");return 1;}res = sti_mixer_active_video_area(mixer, &crtc->mode);if (res) {DRM_ERROR("Can not set active video area\n");return 1;}if ((mode->hdisplay != crtc->fb->width) ||(mode->vdisplay != crtc->fb->height))DRM_DEBUG_KMS("WARNING: fb and display mode sizes differ\n");w = crtc->fb->width - x;h = crtc->fb->height - y;if ((w <= 0) || (h <= 0)) {DRM_ERROR("Coordinates outside FB\n");return -EINVAL;}return sti_layer_prepare(layer, crtc->fb, &crtc->mode, mixer->id,0, 0, w, h, x, y, w, h);+}
+static int sti_drm_crtc_mode_set_base(struct drm_crtc *crtc, int x, int y,
struct drm_framebuffer *old_fb)+{
struct sti_mixer *mixer = to_sti_mixer(crtc);struct device *dev = mixer->dev;struct sti_compositor *compo = dev_get_drvdata(dev);struct sti_layer *layer;unsigned int w, h;int ret = 0;DRM_DEBUG_KMS("CRTC:%d (%s) fb:%d (%d,%d)\n",crtc->base.id, sti_mixer_to_str(mixer),crtc->fb->base.id, x, y);/* GDP0 is reserved to the CRTC FB */layer = sti_layer_find_layer(compo->layer, STI_GDP_0);if (!layer) {DRM_ERROR("Can not find GDP0)\n");ret = -1;goto out;}w = crtc->fb->width - crtc->x;h = crtc->fb->height - crtc->y;if ((w <= 0) || (h <= 0)) {DRM_ERROR("Coordinates outside FB\n");ret = -EINVAL;goto out;}ret = sti_layer_prepare(layer, crtc->fb, &crtc->mode, mixer->id,0, 0, w, h,crtc->x, crtc->y, w, h);if (ret) {DRM_ERROR("Can not prepare layer\n");goto out;}sti_drm_crtc_commit(crtc);+out:
return ret;+}
+static void sti_drm_crtc_load_lut(struct drm_crtc *crtc) +{
dev_dbg(crtc->dev->dev, "%s\n", __func__);+}
+static void sti_drm_crtc_disable(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_layer *layer;if (!compo->enable)return;DRM_DEBUG_KMS("CRTC:%d (%s)\n", crtc->base.id, sti_mixer_to_str(mixer));/* Disable Background */sti_mixer_set_background_status(mixer, false);/* Disable GDP0 */layer = sti_layer_find_layer(compo->layer, STI_GDP_0);if (!layer) {DRM_ERROR("Cannot find GDP0\n");return;}/* Disable layer at mixer level */if (sti_mixer_set_layer_status(mixer, layer, false))DRM_ERROR("Can not disable %s layer at mixer\n",sti_layer_to_str(layer));/* Wait a while to be sure that a Vsync event is received */msleep(WAIT_NEXT_VSYNC_MS);/* Then disable layer itself */sti_layer_disable(layer);drm_vblank_off(crtc->dev, mixer->id);/* Disable pixel clock and compo IP clocks */if (mixer->id == STI_MIXER_MAIN) {clk_disable_unprepare(compo->clk_pix_main);clk_disable_unprepare(compo->clk_compo_main);} else {clk_disable_unprepare(compo->clk_pix_aux);clk_disable_unprepare(compo->clk_compo_aux);}compo->enable = false;+}
+static struct drm_crtc_helper_funcs sti_crtc_helper_funcs = {
.dpms = sti_drm_crtc_dpms,.prepare = sti_drm_crtc_prepare,.commit = sti_drm_crtc_commit,.mode_fixup = sti_drm_crtc_mode_fixup,.mode_set = sti_drm_crtc_mode_set,.mode_set_base = sti_drm_crtc_mode_set_base,.load_lut = sti_drm_crtc_load_lut,.disable = sti_drm_crtc_disable,+};
+static int sti_drm_crtc_page_flip(struct drm_crtc *crtc,
struct drm_framebuffer *fb,struct drm_pending_vblank_event *event,uint32_t page_flip_flags)+{
struct drm_device *drm_dev = crtc->dev;struct sti_drm_private *dev_priv = drm_dev->dev_private;struct drm_framebuffer *old_fb;struct sti_mixer *mixer = to_sti_mixer(crtc);unsigned long flags;int ret = 0;DRM_DEBUG_KMS("fb %d --> fb %d\n", crtc->fb->base.id, fb->base.id);mutex_lock(&drm_dev->struct_mutex);old_fb = crtc->fb;crtc->fb = fb;ret = sti_drm_crtc_mode_set_base(crtc, crtc->x, crtc->y, old_fb);if (ret) {DRM_ERROR("failed\n");crtc->fb = old_fb;goto out;}if (event) {event->pipe = mixer->id;ret = drm_vblank_get(drm_dev, event->pipe);if (ret) {DRM_ERROR("Cannot get vblank\n");goto out;}spin_lock_irqsave(&drm_dev->event_lock, flags);list_add_tail(&event->base.link, &dev_priv->pageflip_evt_list);spin_unlock_irqrestore(&drm_dev->event_lock, flags);}+out:
mutex_unlock(&drm_dev->struct_mutex);return ret;+}
+static void sti_drm_crtc_destroy(struct drm_crtc *crtc) +{
DRM_DEBUG_KMS("\n");drm_crtc_cleanup(crtc);+}
+static int sti_drm_crtc_set_property(struct drm_crtc *crtc,
struct drm_property *property,uint64_t val)+{
DRM_DEBUG_KMS("\n");return 0;+}
+int sti_drm_crtc_vblank_cb(struct notifier_block *nb,
unsigned long event, void *data)+{
struct sti_compositor *compo = container_of(nb,struct sti_compositor,vtg_vblank_nb);struct drm_device *drm_dev;int *crtc = data;unsigned long flags;struct drm_pending_vblank_event *e, *t;struct sti_drm_private *priv;drm_dev = compo->mixer[*crtc]->drm_crtc.dev;priv = drm_dev->dev_private;dev_dbg(drm_dev->dev, "%s\n", __func__);if ((event != VTG_TOP_FIELD_EVENT) &&(event != VTG_BOTTOM_FIELD_EVENT)) {DRM_ERROR("unknown event: %lu\n", event);return -EINVAL;}drm_handle_vblank(drm_dev, *crtc);spin_lock_irqsave(&drm_dev->event_lock, flags);list_for_each_entry_safe(e, t, &priv->pageflip_evt_list, base.link) {if (*crtc != e->pipe)continue;list_del(&e->base.link);drm_send_vblank_event(drm_dev, -1, e);drm_vblank_put(drm_dev, *crtc);}spin_unlock_irqrestore(&drm_dev->event_lock, flags);return 0;+}
+int sti_drm_crtc_enable_vblank(struct drm_device *dev, int crtc) +{
struct sti_drm_private *dev_priv = dev->dev_private;struct sti_compositor *compo = dev_priv->compo;struct notifier_block *vtg_vblank_nb = &compo->vtg_vblank_nb;DRM_DEBUG_DRIVER("\n");if (sti_vtg_register_client(crtc, vtg_vblank_nb)) {DRM_ERROR("Cannot register VTG notifier\n");return 1;}return 0;+}
+void sti_drm_crtc_disable_vblank(struct drm_device *dev, int crtc) +{
struct sti_drm_private *dev_priv = dev->dev_private;struct sti_compositor *compo = dev_priv->compo;struct notifier_block *vtg_vblank_nb = &compo->vtg_vblank_nb;unsigned long flags;struct drm_pending_vblank_event *e, *t;struct sti_drm_private *priv = dev->dev_private;DRM_DEBUG_DRIVER("\n");if (sti_vtg_unregister_client(crtc, vtg_vblank_nb))DRM_DEBUG_DRIVER("Warning: cannot unregister VTG notifier\n");/* free the resources of the pending requests */spin_lock_irqsave(&dev->event_lock, flags);list_for_each_entry_safe(e, t, &priv->pageflip_evt_list, base.link) {if (crtc != e->pipe)continue;list_del(&e->base.link);drm_vblank_put(dev, crtc);}spin_unlock_irqrestore(&dev->event_lock, flags);+}
+static struct drm_crtc_funcs sti_crtc_funcs = {
.set_config = drm_crtc_helper_set_config,.page_flip = sti_drm_crtc_page_flip,.destroy = sti_drm_crtc_destroy,.set_property = sti_drm_crtc_set_property,+};
+bool sti_drm_crtc_is_main(struct drm_crtc *crtc) +{
struct sti_mixer *mixer = to_sti_mixer(crtc);if (mixer->id == STI_MIXER_MAIN)return true;return false;+}
+int sti_drm_crtc_init(struct drm_device *drm_dev, struct sti_mixer *mixer) +{
struct drm_crtc *crtc = &mixer->drm_crtc;int res;dev_dbg(drm_dev->dev, "%s\n", __func__);res = drm_crtc_init(drm_dev, crtc, &sti_crtc_funcs);if (res) {DRM_ERROR("Can not initialze CRTC\n");return 1;}drm_crtc_helper_add(crtc, &sti_crtc_helper_funcs);DRM_DEBUG_DRIVER("drm CRTC:%d mapped to %s\n",crtc->base.id, sti_mixer_to_str(mixer));return 0;+} diff --git a/drivers/gpu/drm/sti/sti_drm_crtc.h b/drivers/gpu/drm/sti/sti_drm_crtc.h new file mode 100644 index 0000000..9d31e41 --- /dev/null +++ b/drivers/gpu/drm/sti/sti_drm_crtc.h @@ -0,0 +1,21 @@ +/*
- Copyright (C) STMicroelectronics SA 2013
- Author: Benjamin Gaignard benjamin.gaignard@st.com for STMicroelectronics.
- License terms: GNU General Public License (GPL), version 2
- */
+#ifndef _STI_DRM_CRTC_H_ +#define _STI_DRM_CRTC_H_
+#include <drm/drmP.h>
+#include "sti_mixer.h"
+int sti_drm_crtc_init(struct drm_device *drm_dev, struct sti_mixer *mixer); +int sti_drm_crtc_enable_vblank(struct drm_device *dev, int crtc); +void sti_drm_crtc_disable_vblank(struct drm_device *dev, int crtc); +int sti_drm_crtc_vblank_cb(struct notifier_block *nb,
unsigned long event, void *data);+bool sti_drm_crtc_is_main(struct drm_crtc *drm_crtc);
+#endif diff --git a/drivers/gpu/drm/sti/sti_drm_drv.c b/drivers/gpu/drm/sti/sti_drm_drv.c new file mode 100644 index 0000000..16ac771 --- /dev/null +++ b/drivers/gpu/drm/sti/sti_drm_drv.c @@ -0,0 +1,466 @@ +/*
- Copyright (C) STMicroelectronics SA 2013
- Author: Benjamin Gaignard benjamin.gaignard@st.com for STMicroelectronics.
- License terms: GNU General Public License (GPL), version 2
- */
+#include <drm/drmP.h>
+#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/debugfs.h> +#include <drm/drm_crtc_helper.h> +#include <drm/drm_gem_cma_helper.h> +#include <drm/drm_fb_cma_helper.h>
+#include "sti_drm_drv.h" +#include "sti_drm_crtc.h" +#include "sti_drm_plane.h" +#include "sti_compositor.h" +#include "sti_gdp.h" +#include "sti_drm_encoder.h" +#include "sti_drm_connector.h" +#include "sti_tvout.h"
+#define DRIVER_NAME "sti" +#define DRIVER_DESC "STMicroelectronics SoC DRM" +#define DRIVER_DATE "20130905" +#define DRIVER_MAJOR 1 +#define DRIVER_MINOR 0
+/* platform device pointer for sti drm device. */ +static struct platform_device *sti_drm_pdev; +#ifdef CONFIG_DRM_STI_FBDEV +#define FBDEV_CREATE_DELAY 2000 +struct drm_device *sti_drm_device;
+static void stid_fbdev_create(struct work_struct *dummy) +{
if (!sti_drm_device)return;drm_fbdev_cma_init(sti_drm_device, 32,sti_drm_device->mode_config.num_crtc,sti_drm_device->mode_config.num_connector);+}
+static DECLARE_DELAYED_WORK(sti_fbdev_work, stid_fbdev_create); +#endif
+static int sti_drm_tvout_init(struct device *dev, void *data) +{
struct sti_tvout *tvout = dev_get_drvdata(dev);struct drm_device *drm_dev = data;struct drm_encoder *encoder;int i;struct sti_drm_private *dev_priv = drm_dev->dev_private;dev_priv->tvout = tvout;tvout->drm_dev = drm_dev;/* Register all encoder/connector couples supported by tvout */for (i = 0; i < STI_TVOUT_CONNECTOR_MAX; i++) {if (tvout->connector_create[i] != NULL) {encoder = sti_drm_encoder_create(drm_dev, tvout,1 << 0, i);sti_drm_connector_create(drm_dev, tvout, encoder, i);}}return 0;+}
+static int sti_drm_compositor_init(struct device *dev, void *data) +{
struct sti_compositor *compo = dev_get_drvdata(dev);struct drm_device *drm_dev = data;int i, crtc = 0, plane = 0;struct sti_drm_private *dev_priv = drm_dev->dev_private;dev_dbg(dev, "%s\n", __func__);dev_priv->compo = compo;INIT_LIST_HEAD(&dev_priv->pageflip_evt_list);for (i = 0; i < compo->nb_mixers; i++) {if (compo->mixer[i]) {sti_drm_crtc_init(drm_dev, compo->mixer[i]);crtc++;}}if (crtc == 0) {DRM_ERROR("No CRTC available\n");return 1;}drm_vblank_init(drm_dev, crtc);/* Allow usage of vblank without having to call drm_irq_install */drm_dev->irq_enabled = 1;for (i = 0; i < compo->nb_layers; i++) {if (compo->layer[i]) {/* Create planes for GDP.* except GDP0 as it is reserved for CRTC FB */enum sti_layer_desc desc = compo->layer[i]->desc;enum sti_layer_type type = desc & STI_LAYER_TYPE_MASK;if ((type == STI_GDP) && (desc != STI_GDP_0)) {sti_drm_plane_init(drm_dev, compo->layer[i],(1 << crtc) - 1);plane++;}}}DRM_DEBUG_DRIVER("Initialized %d DRM CRTC(s) and %d DRM plane(s)\n",crtc, plane);DRM_DEBUG_DRIVER("DRM plane(s) for VID/VDP not created yet\n");return 0;+}
+static struct drm_mode_config_funcs sti_drm_mode_config_funcs = {
.fb_create = drm_fb_cma_create,+};
+#ifdef CONFIG_DEBUG_FS +static struct drm_info_list sti_drm_dbg_list[] = {
{"gdp", sti_gdp_dbg_show, 0},{"node", sti_gdp_node_dbg_show, 0},{"mixer", sti_mixer_dbg_show, 0},{"hdmi", sti_tvout_hdmi_dbg_show, 0, NULL},{"hda", sti_tvout_hda_dbg_show, 0, NULL},+};
+static int sti_drm_fps_get(void *data, u64 *val) +{
struct drm_device *dev = data;struct sti_drm_private *dev_priv = dev->dev_private;struct sti_compositor *compo = dev_priv->compo;int i;*val = 0;for (i = 0; i < compo->nb_layers; i++)*val |= (compo->layer[i]->fps_info.output) << i;return 0;+}
+static int sti_drm_fps_set(void *data, u64 val) +{
struct drm_device *dev = data;struct sti_drm_private *dev_priv = dev->dev_private;struct sti_compositor *compo = dev_priv->compo;int i;for (i = 0; i < compo->nb_layers; i++)compo->layer[i]->fps_info.output = (val >> i) & 1;return 0;+}
+DEFINE_SIMPLE_ATTRIBUTE(sti_drm_fps_fops,
sti_drm_fps_get, sti_drm_fps_set, "%llu\n");+static int sti_drm_debugfs_create(struct dentry *root, struct drm_minor *minor,
const char *name,const struct file_operations *fops)+{
struct drm_device *dev = minor->dev;struct drm_info_node *node;struct dentry *ent;ent = debugfs_create_file(name, S_IRUGO | S_IWUSR, root, dev, fops);if (IS_ERR(ent))return PTR_ERR(ent);node = kmalloc(sizeof(struct drm_info_node), GFP_KERNEL);if (node == NULL) {debugfs_remove(ent);return -ENOMEM;}node->minor = minor;node->dent = ent;node->info_ent = (void *)fops;mutex_lock(&minor->debugfs_lock);list_add(&node->list, &minor->debugfs_list);mutex_unlock(&minor->debugfs_lock);return 0;+}
+int sti_drm_dbg_init(struct drm_minor *minor) +{
int ret;ret = sti_drm_debugfs_create(minor->debugfs_root, minor, "fps_show",&sti_drm_fps_fops);if (ret)goto err;ret = drm_debugfs_create_files(sti_drm_dbg_list,ARRAY_SIZE(sti_drm_dbg_list),minor->debugfs_root, minor);if (ret)goto err;DRM_INFO("%s debugfs installed\n", DRIVER_NAME);return ret;+err:
DRM_ERROR("Cannot install debugfs\n");return ret;+}
+void sti_drm_dbg_cleanup(struct drm_minor *minor) +{
drm_debugfs_remove_files(sti_drm_dbg_list,ARRAY_SIZE(sti_drm_dbg_list), minor);drm_debugfs_remove_files((struct drm_info_list *)&sti_drm_fps_fops,1, minor);+} +#endif
+static void sti_drm_mode_config_init(struct drm_device *dev) +{
dev->mode_config.min_width = 0;dev->mode_config.min_height = 0;/** set max width and height as default value.* this value would be used to check framebuffer size limitation* at drm_mode_addfb().*/dev->mode_config.max_width = STI_MAX_FB_HEIGHT;dev->mode_config.max_height = STI_MAX_FB_WIDTH;dev->mode_config.funcs = &sti_drm_mode_config_funcs;+}
+static int sti_drm_load(struct drm_device *dev, unsigned long flags) +{
struct sti_drm_private *private;struct device_driver *drv;int err;DRM_INFO("%s drm_device: %p\n", __func__, dev);private = kzalloc(sizeof(struct sti_drm_private), GFP_KERNEL);if (!private) {DRM_ERROR("Failed to allocate private\n");return -ENOMEM;}dev->dev_private = (void *)private;drm_mode_config_init(dev);drm_kms_helper_poll_init(dev);sti_drm_mode_config_init(dev);/* look for compositors HW */drv = driver_find("sti-compositor", &platform_bus_type);if (!drv) {DRM_ERROR("No compositor found\n");return -ENOMEM;}err = driver_for_each_device(drv, NULL, dev, sti_drm_compositor_init);if (err)DRM_ERROR("Failed to initialize CRTC\n");/* look for TVOUT driver */drv = driver_find("sti-tvout", &platform_bus_type);if (!drv) {DRM_ERROR("No tvout found\n");return -ENOMEM;}err = driver_for_each_device(drv, NULL, dev, sti_drm_tvout_init);if (err)DRM_ERROR("Failed to initialize TVOUT\n");drm_helper_disable_unused_functions(dev);+#ifdef CONFIG_DRM_STI_FBDEV
sti_drm_device = dev;schedule_delayed_work(&sti_fbdev_work,msecs_to_jiffies(FBDEV_CREATE_DELAY));+#endif
return err;+}
+static const struct file_operations sti_drm_driver_fops = {
.owner = THIS_MODULE,.open = drm_open,.mmap = drm_gem_cma_mmap,.poll = drm_poll,.read = drm_read,.unlocked_ioctl = drm_ioctl,+#ifdef CONFIG_COMPAT
.compat_ioctl = drm_compat_ioctl,+#endif
.release = drm_release,+};
+static struct dma_buf *sti_drm_gem_prime_export(struct drm_device *dev,
struct drm_gem_object *obj,int flags)+{
/* we want to be able to write in mmapped buffer */flags |= O_RDWR;return drm_gem_prime_export(dev, obj, flags);+}
+static struct drm_driver sti_drm_driver = {
.driver_features = DRIVER_HAVE_IRQ | DRIVER_MODESET |DRIVER_GEM | DRIVER_PRIME,.load = sti_drm_load,.gem_free_object = drm_gem_cma_free_object,.gem_vm_ops = &drm_gem_cma_vm_ops,.dumb_create = drm_gem_cma_dumb_create,.dumb_map_offset = drm_gem_cma_dumb_map_offset,.dumb_destroy = drm_gem_dumb_destroy,.fops = &sti_drm_driver_fops,.get_vblank_counter = drm_vblank_count,.enable_vblank = sti_drm_crtc_enable_vblank,.disable_vblank = sti_drm_crtc_disable_vblank,.prime_handle_to_fd = drm_gem_prime_handle_to_fd,.prime_fd_to_handle = drm_gem_prime_fd_to_handle,.gem_prime_export = sti_drm_gem_prime_export,.gem_prime_import = drm_gem_prime_import,.gem_prime_get_sg_table = drm_gem_cma_prime_get_sg_table,.gem_prime_import_sg_table = drm_gem_cma_prime_import_sg_table,.gem_prime_vmap = drm_gem_cma_prime_vmap,.gem_prime_vunmap = drm_gem_cma_prime_vunmap,.gem_prime_mmap = drm_gem_cma_prime_mmap,+#ifdef CONFIG_DEBUG_FS
.debugfs_init = sti_drm_dbg_init,.debugfs_cleanup = sti_drm_dbg_cleanup,+#endif
.name = DRIVER_NAME,.desc = DRIVER_DESC,.date = DRIVER_DATE,.major = DRIVER_MAJOR,.minor = DRIVER_MINOR,+};
+static int sti_drm_platform_probe(struct platform_device *pdev) +{
DRM_INFO("%s\n", __func__);dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));return drm_platform_init(&sti_drm_driver, pdev);+}
+static int sti_drm_platform_remove(struct platform_device *pdev) +{
DRM_INFO("%s\n", __func__);drm_put_dev(platform_get_drvdata(pdev));return 0;+}
+static struct platform_driver sti_drm_platform_driver = {
.probe = sti_drm_platform_probe,.remove = sti_drm_platform_remove,.driver = {.owner = THIS_MODULE,.name = DRIVER_NAME,},+};
+static int __init sti_drm_init(void) +{
int ret;DRM_INFO("%s\n", __func__);+#ifdef CONFIG_VTAC_STI
ret = platform_driver_register(&sti_vtac_tx_driver);if (ret < 0)goto out_vtac_tx;ret = platform_driver_register(&sti_vtac_rx_driver);if (ret < 0)goto out_vtac_rx;+#endif +#ifdef CONFIG_VTG_STI
ret = platform_driver_register(&sti_vtg_driver);if (ret < 0)goto out_vtg;+#endif
ret = platform_driver_register(&sti_compositor_driver);if (ret < 0)goto out_compo;ret = platform_driver_register(&sti_tvout_driver);if (ret < 0)goto out_tvout;ret = platform_driver_register(&sti_hdmi_driver);if (ret < 0)goto out_hdmi;ret = platform_driver_register(&sti_hda_driver);if (ret < 0)goto out_hda;ret = platform_driver_register(&sti_drm_platform_driver);if (ret < 0)goto out_drm;sti_drm_pdev =platform_device_register_simple(DRIVER_NAME, -1, NULL, 0);if (IS_ERR(sti_drm_pdev)) {ret = PTR_ERR(sti_drm_pdev);goto out_drm_device;}return 0;+out_drm_device:
platform_driver_unregister(&sti_drm_platform_driver);+out_drm:
platform_driver_unregister(&sti_hda_driver);+out_hda:
platform_driver_unregister(&sti_hdmi_driver);+out_hdmi:
platform_driver_unregister(&sti_tvout_driver);+out_tvout:
DRM_DEBUG_DRIVER("Can't register STI DRM platform driver");platform_driver_unregister(&sti_compositor_driver);+out_compo: +#ifdef CONFIG_VTG_STI
platform_driver_unregister(&sti_vtg_driver);+out_vtg: +#endif +#ifdef CONFIG_VTAC_STI
platform_driver_unregister(&sti_vtac_rx_driver);+out_vtac_rx:
platform_driver_unregister(&sti_vtac_tx_driver);+out_vtac_tx: +#endif
return ret;+}
+static void __exit sti_drm_exit(void) +{
DRM_DEBUG_DRIVER("\n");platform_device_unregister(sti_drm_pdev);platform_driver_unregister(&sti_drm_platform_driver);platform_driver_unregister(&sti_compositor_driver);+}
+module_init(sti_drm_init); +module_exit(sti_drm_exit);
+MODULE_AUTHOR("Benjamin Gaignard benjamin.gaignard@st.com"); +MODULE_DESCRIPTION("STMicroelectronics SoC DRM driver"); +MODULE_LICENSE("GPL"); diff --git a/drivers/gpu/drm/sti/sti_drm_encoder.c b/drivers/gpu/drm/sti/sti_drm_encoder.c new file mode 100644 index 0000000..96194cf --- /dev/null +++ b/drivers/gpu/drm/sti/sti_drm_encoder.c @@ -0,0 +1,201 @@ +/*
- Copyright (C) STMicroelectronics SA 2013
- Author: Benjamin Gaignard benjamin.gaignard@st.com for STMicroelectronics.
- License terms: GNU General Public License (GPL), version 2
- */
+#include <drm/drmP.h> +#include <drm/drm_crtc_helper.h>
+#include "sti_drm_crtc.h" +#include "sti_drm_encoder.h" +#include "sti_tvout.h"
+#define to_sti_encoder(x) container_of(x, struct sti_encoder, drm_encoder)
+#define ENCODER_MAIN_CRTC_MASK (1 << 0)
+/*
- sti specific encoder structure.
- @drm_encoder: encoder object.
- @tvout: pointer on tvout driver.
- @type: tvout connector type.
- */
+struct sti_encoder {
struct drm_encoder drm_encoder;struct sti_tvout *tvout;enum sti_tvout_connector_type type;+};
+static void sti_drm_encoder_dpms(struct drm_encoder *encoder, int mode) +{ +}
+static bool sti_drm_encoder_mode_fixup(struct drm_encoder *encoder,
const struct drm_display_mode *mode,struct drm_display_mode *adjusted_mode)+{
return true;+}
+static void sti_drm_encoder_mode_set(struct drm_encoder *encoder,
struct drm_display_mode *mode,struct drm_display_mode *adjusted_mode)+{
struct sti_encoder *sti_encoder = to_sti_encoder(encoder);struct drm_device *dev = encoder->dev;struct drm_connector *connector;dev_dbg(dev->dev, "%s\n", __func__);list_for_each_entry(connector, &dev->mode_config.connector_list, head) {if (connector->encoder == encoder) {sti_tvout_set_mode(sti_encoder->tvout, mode,sti_encoder->type);break;}}+}
+static void sti_drm_encoder_prepare(struct drm_encoder *encoder) +{
struct sti_encoder *sti_encoder = to_sti_encoder(encoder);struct drm_device *dev = encoder->dev;struct drm_connector *connector;dev_dbg(dev->dev, "%s\n", __func__);list_for_each_entry(connector, &dev->mode_config.connector_list, head) {if (connector->encoder == encoder) {sti_tvout_prepare(sti_encoder->tvout,sti_encoder->type);break;}}+}
+static void sti_drm_encoder_commit(struct drm_encoder *encoder) +{
struct sti_encoder *sti_encoder = to_sti_encoder(encoder);struct drm_device *dev = encoder->dev;struct drm_connector *connector;dev_dbg(dev->dev, "%s\n", __func__);list_for_each_entry(connector, &dev->mode_config.connector_list, head) {if (connector->encoder == encoder) {sti_tvout_commit(sti_encoder->tvout,sti_encoder->type,sti_drm_crtc_is_main(encoder->crtc));break;}}+}
+static void sti_drm_encoder_disable(struct drm_encoder *encoder) +{
struct sti_encoder *sti_encoder = to_sti_encoder(encoder);struct drm_device *dev = encoder->dev;struct drm_connector *connector;struct drm_connector_helper_funcs *connector_funcs;dev_dbg(dev->dev, "%s\n", __func__);list_for_each_entry(connector, &dev->mode_config.connector_list, head) {connector_funcs = connector->helper_private;if (connector_funcs->best_encoder(connector) == encoder) {sti_tvout_disable(sti_encoder->tvout,sti_encoder->type);break;}}+}
+static const struct drm_encoder_helper_funcs sti_drm_encoder_helper_funcs = {
.dpms = sti_drm_encoder_dpms,.mode_fixup = sti_drm_encoder_mode_fixup,.mode_set = sti_drm_encoder_mode_set,.prepare = sti_drm_encoder_prepare,.commit = sti_drm_encoder_commit,.disable = sti_drm_encoder_disable,+};
+static void sti_drm_encoder_destroy(struct drm_encoder *encoder) +{
struct sti_encoder *sti_encoder = to_sti_encoder(encoder);struct drm_device *dev = encoder->dev;dev_dbg(dev->dev, "%s\n", __func__);drm_encoder_cleanup(encoder);kfree(sti_encoder);+}
+static const struct drm_encoder_funcs sti_drm_encoder_funcs = {
.destroy = sti_drm_encoder_destroy,+};
+struct drm_encoder *sti_drm_encoder_create(struct drm_device *dev,
struct sti_tvout *tvout,unsigned int possible_crtcs,enum sti_tvout_connector_type type)+{
struct sti_encoder *sti_encoder;struct drm_encoder *encoder;int encoder_type;dev_dbg(dev->dev, "%s\n", __func__);if (!dev || !tvout || !possible_crtcs)return NULL;sti_encoder = kzalloc(sizeof(*sti_encoder), GFP_KERNEL);if (!sti_encoder) {DRM_ERROR("failed to allocate encoder\n");return NULL;}sti_encoder->tvout = tvout;sti_encoder->type = type;encoder = &sti_encoder->drm_encoder;encoder->possible_crtcs = possible_crtcs;/* HDMI connector only supports main crtc */if (type == STI_TVOUT_CONNECTOR_HDMI)encoder->possible_crtcs &= ENCODER_MAIN_CRTC_MASK;/* HD Analog connector may support aux CRTC. Not implemented yet */if (type == STI_TVOUT_CONNECTOR_HDA)encoder->possible_crtcs &= ENCODER_MAIN_CRTC_MASK;DRM_DEBUG_DRIVER("possible_crtcs = 0x%x\n", encoder->possible_crtcs);switch (type) {case STI_TVOUT_CONNECTOR_HDMI:encoder_type = DRM_MODE_ENCODER_TMDS;encoder->possible_clones = 1 << STI_TVOUT_CONNECTOR_HDA;break;case STI_TVOUT_CONNECTOR_HDA:encoder_type = DRM_MODE_ENCODER_DAC;encoder->possible_clones = 1 << STI_TVOUT_CONNECTOR_HDMI;break;case STI_TVOUT_CONNECTOR_DENC:encoder_type = DRM_MODE_ENCODER_DAC;break;case STI_TVOUT_CONNECTOR_DVO:encoder_type = DRM_MODE_ENCODER_LVDS;break;default:encoder_type = DRM_MODE_ENCODER_NONE;break;}drm_encoder_init(dev, encoder, &sti_drm_encoder_funcs, encoder_type);drm_encoder_helper_add(encoder, &sti_drm_encoder_helper_funcs);DRM_DEBUG_DRIVER("encoder has been created\n");return encoder;+} diff --git a/drivers/gpu/drm/sti/sti_drm_encoder.h b/drivers/gpu/drm/sti/sti_drm_encoder.h new file mode 100644 index 0000000..35d9945 --- /dev/null +++ b/drivers/gpu/drm/sti/sti_drm_encoder.h @@ -0,0 +1,16 @@ +/*
- Copyright (C) STMicroelectronics SA 2013
- Author: Benjamin Gaignard benjamin.gaignard@st.com for STMicroelectronics.
- License terms: GNU General Public License (GPL), version 2
- */
+#ifndef _STI_DRM_ENCODER_H_ +#define _STI_DRM_ENCODER_H_
+#include "sti_tvout.h"
+struct drm_encoder *sti_drm_encoder_create(struct drm_device *dev,
struct sti_tvout *tvout, unsigned int possible_crtcs,enum sti_tvout_connector_type type);+#endif diff --git a/drivers/gpu/drm/sti/sti_drm_plane.c b/drivers/gpu/drm/sti/sti_drm_plane.c new file mode 100644 index 0000000..e34c33a --- /dev/null +++ b/drivers/gpu/drm/sti/sti_drm_plane.c @@ -0,0 +1,195 @@ +/*
- Copyright (C) STMicroelectronics SA 2013
- Authors: Benjamin Gaignard benjamin.gaignard@st.com
Fabien Dessenne <fabien.dessenne@st.com>
for STMicroelectronics.
- License terms: GNU General Public License (GPL), version 2
- */
+#include "sti_drm_drv.h" +#include "sti_drm_plane.h" +#include "sti_compositor.h" +#include "sti_vtg_utils.h"
+enum sti_layer_desc sti_layer_default_zorder[] = {
STI_GDP_0,STI_VID_0,STI_GDP_1,STI_VID_1,STI_GDP_2,STI_GDP_3,+};
+/* (Background) < GDP0 < VID0 < GDP1 < VID1 < GDP2 < GDP3 < (ForeGround) */
+static int +sti_drm_update_plane(struct drm_plane *plane, struct drm_crtc *crtc,
struct drm_framebuffer *fb, int crtc_x, int crtc_y,unsigned int crtc_w, unsigned int crtc_h,uint32_t src_x, uint32_t src_y,uint32_t src_w, uint32_t src_h)+{
struct sti_layer *layer = to_sti_layer(plane);struct sti_mixer *mixer = to_sti_mixer(crtc);int res;DRM_DEBUG_KMS("CRTC:%d (%s) drm plane:%d (%s) drm fb:%d\n",crtc->base.id, sti_mixer_to_str(mixer),plane->base.id, sti_layer_to_str(layer), fb->base.id);DRM_DEBUG_KMS("(%dx%d)@(%d,%d)\n", crtc_w, crtc_h, crtc_x, crtc_y);res = sti_mixer_set_layer_depth(mixer, layer);if (res) {DRM_ERROR("Can not set layer depth\n");return res;}/* src_x are in 16.16 format. */res = sti_layer_prepare(layer, fb, &crtc->mode, mixer->id,crtc_x, crtc_y, crtc_w, crtc_h,src_x >> 16, src_y >> 16,src_w >> 16, src_h >> 16);if (res) {DRM_ERROR("Layer prepare failed\n");return res;}res = sti_layer_commit(layer);if (res) {DRM_ERROR("Layer commit failed\n");return res;}res = sti_mixer_set_layer_status(mixer, layer, true);if (res) {DRM_ERROR("Can not enable layer at mixer\n");return res;}return 0;+}
+static int sti_drm_disable_plane(struct drm_plane *plane) +{
struct sti_layer *layer;struct sti_mixer *mixer;int lay_res, mix_res;if (!plane->crtc) {DRM_DEBUG_DRIVER("drm plane:%d not enabled\n", plane->base.id);return 0;}layer = to_sti_layer(plane);mixer = to_sti_mixer(plane->crtc);DRM_DEBUG_DRIVER("CRTC:%d (%s) drm plane:%d (%s)\n",plane->crtc->base.id, sti_mixer_to_str(mixer),plane->base.id, sti_layer_to_str(layer));/* Disable layer at mixer level */mix_res = sti_mixer_set_layer_status(mixer, layer, false);if (mix_res)DRM_ERROR("Can not disable layer at mixer\n");/* Wait a while to be sure that a Vsync event is received */msleep(WAIT_NEXT_VSYNC_MS);/* Then disable layer itself */lay_res = sti_layer_disable(layer);if (lay_res)DRM_ERROR("Layer disable failed\n");if (lay_res || mix_res)return 1;elsereturn 0;+}
+static void sti_drm_plane_destroy(struct drm_plane *plane) +{
DRM_DEBUG_DRIVER("\n");sti_drm_disable_plane(plane);drm_plane_cleanup(plane);+}
+static int sti_drm_plane_set_property(struct drm_plane *plane,
struct drm_property *property,uint64_t val)+{
struct drm_device *dev = plane->dev;struct sti_drm_private *private = dev->dev_private;struct sti_layer *layer = to_sti_layer(plane);DRM_DEBUG_DRIVER("\n");if (property == private->plane_zorder_property) {layer->zorder = val;return 0;}return -EINVAL;+}
+static struct drm_plane_funcs sti_drm_plane_funcs = {
.update_plane = sti_drm_update_plane,.disable_plane = sti_drm_disable_plane,.destroy = sti_drm_plane_destroy,.set_property = sti_drm_plane_set_property,+};
+static void sti_drm_plane_attach_zorder_property(struct drm_plane *plane,
uint64_t default_val)+{
struct drm_device *dev = plane->dev;struct sti_drm_private *private = dev->dev_private;struct drm_property *prop;struct sti_layer *layer = to_sti_layer(plane);dev_dbg(dev->dev, "%s zorder:%llu\n", __func__, default_val);prop = private->plane_zorder_property;if (!prop) {prop = drm_property_create_range(dev, 0, "zpos", 0,GAM_MIXER_NB_DEPTH_LEVEL - 1);if (!prop)return;private->plane_zorder_property = prop;}drm_object_attach_property(&plane->base, prop, default_val);layer->zorder = default_val;+}
There's lots of ongoing discussions about standardizing properties a bit better. Especially about plane Z ordering and blending modes. I think it'd be good to hold off on this a bit and participate in the larger discussion about a spec for plane properties until things settle. Especially for a new driver.
I guess for now you could just hardcode Z order how you register the planes. -Daniel
+struct drm_plane *sti_drm_plane_init(struct drm_device *dev,
struct sti_layer *layer,unsigned int possible_crtcs)+{
int err, i;uint64_t default_zorder = 0;dev_dbg(dev->dev, "%s\n", __func__);err = drm_plane_init(dev, &layer->plane, possible_crtcs,&sti_drm_plane_funcs,sti_layer_get_formats(layer),sti_layer_get_nb_formats(layer), false);if (err) {DRM_ERROR("Failed to initialize plane\n");return NULL;}for (i = 0; i < ARRAY_SIZE(sti_layer_default_zorder); i++)if (sti_layer_default_zorder[i] == layer->desc)break;default_zorder = i;sti_drm_plane_attach_zorder_property(&layer->plane, default_zorder);DRM_DEBUG_DRIVER("drm plane:%d mapped to %s with zorder:%llu\n",layer->plane.base.id,sti_layer_to_str(layer), default_zorder);return &layer->plane;+} diff --git a/drivers/gpu/drm/sti/sti_drm_plane.h b/drivers/gpu/drm/sti/sti_drm_plane.h new file mode 100644 index 0000000..d182066 --- /dev/null +++ b/drivers/gpu/drm/sti/sti_drm_plane.h @@ -0,0 +1,16 @@ +/*
- Copyright (C) STMicroelectronics SA 2013
- Author: Benjamin Gaignard benjamin.gaignard@st.com for STMicroelectronics.
- License terms: GNU General Public License (GPL), version 2
- */
+#ifndef _STI_DRM_PLANE_H_ +#define _STI_DRM_PLANE_H_
+#include <drm/drmP.h> +#include "sti_layer.h"
+struct drm_plane *sti_drm_plane_init(struct drm_device *dev,
struct sti_layer *layer, unsigned int possible_crtcs);+#endif diff --git a/drivers/gpu/drm/sti/sti_vtg_utils.h b/drivers/gpu/drm/sti/sti_vtg_utils.h index 8992a04..fea2852 100644 --- a/drivers/gpu/drm/sti/sti_vtg_utils.h +++ b/drivers/gpu/drm/sti/sti_vtg_utils.h @@ -11,6 +11,8 @@
#include <drm/drmP.h>
+#define WAIT_NEXT_VSYNC_MS 50 /*ms*/
#define VTG_MAIN 0 #define VTG_AUX 1
-- 1.9.0
dri-devel mailing list dri-devel@lists.freedesktop.org http://lists.freedesktop.org/mailman/listinfo/dri-devel
-- Daniel Vetter Software Engineer, Intel Corporation +41 (0) 79 365 57 48 - http://blog.ffwll.ch