gmane.comp.video.dri.devel

[PATCH] drm/radeon: fix typo in trinity tiling setup

2012-05-25T02:55:15

From: Alex Deucher <alexander.deucher< at >amd.com>

Using the wrong union.

Signed-off-by: Alex Deucher <alexander.deucher< at >amd.com>
Cc: stable< at >vger.kernel.org
---
 drivers/gpu/drm/radeon/ni.c |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)

diff --git a/drivers/gpu/drm/radeon/ni.c b/drivers/gpu/drm/radeon/ni.c
index b01c2dd..ce4e7cc 100644
--- a/drivers/gpu/drm/radeon/ni.c
+++ b/drivers/gpu/drm/radeon/ni.c
< at >< at > -865,7 +865,7 < at >< at > static void cayman_gpu_init(struct radeon_device *rdev)
 
 /* num banks is 8 on all fusion asics. 0 = 4, 1 = 8, 2 = 16 */
 if (rdev->flags & RADEON_IS_IGP)
-rdev->config.evergreen.tile_config |= 1 << 4;
+rdev->config.cayman.tile_config |= 1 << 4;
 else
 rdev->config.cayman.tile_config |=
 ((mc_arb_ramcfg & NOOFBANK_MASK) >> NOOFBANK_SHIFT) << 4;

drm/i915 3.5 merge window: gen6_sanitize_pm errors

Linus Torvalds — 2012-05-25T02:27:04

These guys seem to be recently introduced:

  [drm:gen6_sanitize_pm] *ERROR* Power management discrepancy:
GEN6_RP_INTERRUPT_LIMITS expected 17000000, was 12060000
  [drm:gen6_sanitize_pm] *ERROR* Power management discrepancy:
GEN6_RP_INTERRUPT_LIMITS expected 17070000, was 17000000

This is on my SNB Macbook Air.

Everything seems to *work*, which makes me think:

 - that error isn't really so big a deal that you have to *SHOUT* about it.

 - I wonder how valid the discrepancy checking code is to begin with.

Hmm?

              Linus

[Bug 50325] Glyphy bad render on r600g (software render is fine)

2012-05-24T21:57:24

https://bugs.freedesktop.org/show_bug.cgi?id=50325

--- Comment #2 from Török Edwin <edwin+mesa< at >etorok.net> 2012-05-24 14:57:24 PDT ---
Created attachment 62080
  --> https://bugs.freedesktop.org/attachment.cgi?id=62080
sw-good.png

[Bug 50325] Glyphy bad render on r600g (software render is fine)

2012-05-24T21:57:08

https://bugs.freedesktop.org/show_bug.cgi?id=50325

--- Comment #1 from Török Edwin <edwin+mesa< at >etorok.net> 2012-05-24 14:57:08 PDT ---
Created attachment 62079
  --> https://bugs.freedesktop.org/attachment.cgi?id=62079
r600g-bad.png

[Bug 50325] New: Glyphy bad render on r600g (software render is fine)

2012-05-24T21:56:46

https://bugs.freedesktop.org/show_bug.cgi?id=50325

             Bug #: 50325
           Summary: Glyphy bad render on r600g (software render is fine)
    Classification: Unclassified
           Product: Mesa
           Version: 8.0
          Platform: x86-64 (AMD64)
        OS/Version: Linux (All)
            Status: NEW
          Severity: normal
          Priority: medium
         Component: Drivers/Gallium/r600
        AssignedTo: dri-devel< at >lists.freedesktop.org
        ReportedBy: edwin+mesa< at >etorok.net


Created attachment 62078
  --> https://bugs.freedesktop.org/attachment.cgi?id=62078
apitrace (cf. https://github.com/apitrace/apitrace/tree/1.0)

I just tried Glyphy on r600g and the output is very bad.
Don't know if its Glyphy bug or Mesa bug, but if I force software rendering in
Mesa then I do see the output.

Attached screenshots of bad (r600g) and good (software render).

The bad render was obtained by:
demo/glyphy-demo

The good one:
LIBGL_ALWAYS_SOFTWARE=1 demo/glyphy-demo

I tested on:
OpenGL vendor string: X.Org
OpenGL renderer string: Gallium 0.4 on AMD RV730
OpenGL version string: 2.1 Mesa 8.0.2
OpenGL shading language version string: 1.20

I'll try to test on mesa git later to see if its still an issue there.

Also attached is a an apitrace, and the bad render can be reproduced with:
build/glretrace lt-glyphy-demo.trace

The good render (initialization a bit slow, but works):
LIBGL_ALWAYS_SOFTWARE=1 build/glretrace lt-glyphy-demo.trace

The source code for Glyphy can be found here:
https://code.google.com/p/glyphy/source/checkout

[PATCH 12/14] drm/i915: cache hdmi edid

Daniel Vetter — 2012-05-24T19:26:47

Like the previous patches.

While at it also kill a stale comment - we've moved hdmi audio
detection from ->get_modes to ->detect and the audio property handling
functions.

Signed-Off-by: Daniel Vetter <daniel.vetter< at >ffwll.ch>
---
 drivers/gpu/drm/i915/intel_drv.h  |    1 +
 drivers/gpu/drm/i915/intel_hdmi.c |   48 +++++++++++++++++++++++--------------
 2 files changed, 31 insertions(+), 18 deletions(-)

diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h
index 3b6f716..8693551 100644
--- a/drivers/gpu/drm/i915/intel_drv.h
+++ b/drivers/gpu/drm/i915/intel_drv.h
< at >< at > -301,6 +301,7 < at >< at > struct intel_hdmi {
 enum hdmi_force_audio force_audio;
 void (*write_infoframe)(struct drm_encoder *encoder,
 struct dip_infoframe *frame);
+struct edid *cached_edid;
 };
 
 static inline struct drm_crtc *
diff --git a/drivers/gpu/drm/i915/intel_hdmi.c b/drivers/gpu/drm/i915/intel_hdmi.c
index 2ead3bf..373d252 100644
--- a/drivers/gpu/drm/i915/intel_hdmi.c
+++ b/drivers/gpu/drm/i915/intel_hdmi.c
< at >< at > -452,19 +452,37 < at >< at > static bool intel_hdmi_mode_fixup(struct drm_encoder *encoder,
 return true;
 }
 
+struct edid *
+intel_hdmi_get_edid(struct drm_connector *connector)
+{
+struct intel_hdmi *intel_hdmi = intel_attached_hdmi(connector);
+struct drm_i915_private *dev_priv = connector->dev->dev_private;
+
+if (!intel_hdmi->cached_edid) {
+struct i2c_adapter *adapter;
+
+adapter = intel_gmbus_get_adapter(dev_priv,
+  intel_hdmi->ddc_bus);
+intel_hdmi->cached_edid = drm_get_edid(connector, adapter);
+}
+
+return intel_hdmi->cached_edid;
+}
+
 static enum drm_connector_status
 intel_hdmi_detect(struct drm_connector *connector, bool force)
 {
 struct intel_hdmi *intel_hdmi = intel_attached_hdmi(connector);
-struct drm_i915_private *dev_priv = connector->dev->dev_private;
 struct edid *edid;
 enum drm_connector_status status = connector_status_disconnected;
 
+/* Clean the edid cache. */
+kfree(intel_hdmi->cached_edid);
+intel_hdmi->cached_edid = NULL;
+
 intel_hdmi->has_hdmi_sink = false;
 intel_hdmi->has_audio = false;
-edid = drm_get_edid(connector,
-    intel_gmbus_get_adapter(dev_priv,
-    intel_hdmi->ddc_bus));
+edid = intel_hdmi_get_edid(connector);
 
 if (edid) {
 if (edid->input & DRM_EDID_INPUT_DIGITAL) {
< at >< at > -477,6 +495,7 < at >< at > intel_hdmi_detect(struct drm_connector *connector, bool force)
 connector->display_info.raw_edid = NULL;
 kfree(edid);
 }
+intel_hdmi->cached_edid = edid;
 
 if (status == connector_status_connected) {
 if (intel_hdmi->force_audio != HDMI_AUDIO_AUTO)
< at >< at > -489,29 +508,19 < at >< at > intel_hdmi_detect(struct drm_connector *connector, bool force)
 
 static int intel_hdmi_get_modes(struct drm_connector *connector)
 {
-struct intel_hdmi *intel_hdmi = intel_attached_hdmi(connector);
-struct drm_i915_private *dev_priv = connector->dev->dev_private;
-
-/* We should parse the EDID data and find out if it's an HDMI sink so
- * we can send audio to it.
- */
+struct edid *edid;
 
-return intel_ddc_get_modes(connector,
-   intel_gmbus_get_adapter(dev_priv,
-   intel_hdmi->ddc_bus));
+edid = intel_hdmi_get_edid(connector);
+return intel_edid_get_modes(connector, edid);
 }
 
 static bool
 intel_hdmi_detect_audio(struct drm_connector *connector)
 {
-struct intel_hdmi *intel_hdmi = intel_attached_hdmi(connector);
-struct drm_i915_private *dev_priv = connector->dev->dev_private;
 struct edid *edid;
 bool has_audio = false;
 
-edid = drm_get_edid(connector,
-    intel_gmbus_get_adapter(dev_priv,
-    intel_hdmi->ddc_bus));
+edid = intel_hdmi_get_edid(connector);
 if (edid) {
 if (edid->input & DRM_EDID_INPUT_DIGITAL)
 has_audio = drm_detect_monitor_audio(edid);
< at >< at > -580,8 +589,11 < at >< at > done:
 
 static void intel_hdmi_destroy(struct drm_connector *connector)
 {
+struct intel_hdmi *intel_hdmi = intel_attached_hdmi(connector);
+
 drm_sysfs_connector_remove(connector);
 drm_connector_cleanup(connector);
+kfree(intel_hdmi->cached_edid);
 kfree(connector);
 }

[PATCH 09/14] drm: don't poll forced connectors

Daniel Vetter — 2012-05-24T19:26:44

Otherwise if the detect callback reports a different state than what
the user forced (rather likely), we continously annoy userspace about
a hotplug uevent.

Signed-Off-by: Daniel Vetter <daniel.vetter< at >ffwll.ch>
---
 drivers/gpu/drm/drm_crtc_helper.c |    4 ++++
 1 files changed, 4 insertions(+), 0 deletions(-)

diff --git a/drivers/gpu/drm/drm_crtc_helper.c b/drivers/gpu/drm/drm_crtc_helper.c
index 87a45de..9214612 100644
--- a/drivers/gpu/drm/drm_crtc_helper.c
+++ b/drivers/gpu/drm/drm_crtc_helper.c
< at >< at > -948,6 +948,10 < at >< at > static void output_poll_execute(struct work_struct *work)
 mutex_lock(&dev->mode_config.mutex);
 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
 
+/* Ignore forced connectors. */
+if (connector->force)
+continue;
+
 /* Ignore HDP capable connectors and connectors where we don't
  * want any hotplug detection at all for polling. */
 if (!connector->polled ||

[PATCH 08/14] drm: don't unnecessarily enable the polling work

Daniel Vetter — 2012-05-24T19:26:43

... by properly checking connector->polled. This doesn't matter too
much because the polling work itself gets this slightly more right and
doesn't set repoll if there's nothing to do. But we can do better.

Signed-Off-by: Daniel Vetter <daniel.vetter< at >ffwll.ch>
---
 drivers/gpu/drm/drm_crtc_helper.c |    6 ++----
 1 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/drivers/gpu/drm/drm_crtc_helper.c b/drivers/gpu/drm/drm_crtc_helper.c
index f17953e..87a45de 100644
--- a/drivers/gpu/drm/drm_crtc_helper.c
+++ b/drivers/gpu/drm/drm_crtc_helper.c
< at >< at > -955,9 +955,6 < at >< at > static void output_poll_execute(struct work_struct *work)
     (connector->polled & DRM_CONNECTOR_POLL_HPD))
 continue;
 
-else if (connector->polled & (DRM_CONNECTOR_POLL_CONNECT | DRM_CONNECTOR_POLL_DISCONNECT))
-repoll = true;
-
 old_status = connector->status;
 /* if we are connected and don't want to poll for disconnect
    skip it */
< at >< at > -1000,7 +997,8 < at >< at > void drm_kms_helper_poll_enable(struct drm_device *dev)
 return;
 
 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
-if (connector->polled)
+if (connector->polled & (DRM_CONNECTOR_POLL_CONNECT |
+ DRM_CONNECTOR_POLL_DISCONNECT))
 poll = true;
 }

[PATCH 04/14] drm/i915: set POLL_FORCE for sdvo outputs

Daniel Vetter — 2012-05-24T19:26:39

The detection function is simply too unreliable - it doesn't
properly pick up changes right away.

For now, just set the compat flag and ignore this, because on a
quick look fixing this properly is a very big fish to fry.

Signed-off-by: Daniel Vetter <daniel.vetter< at >ffwll.ch>
---
 drivers/gpu/drm/i915/intel_sdvo.c |    2 ++
 1 files changed, 2 insertions(+), 0 deletions(-)

diff --git a/drivers/gpu/drm/i915/intel_sdvo.c b/drivers/gpu/drm/i915/intel_sdvo.c
index a658207..fdc0574 100644
--- a/drivers/gpu/drm/i915/intel_sdvo.c
+++ b/drivers/gpu/drm/i915/intel_sdvo.c
< at >< at > -2012,6 +2012,8 < at >< at > intel_sdvo_connector_init(struct intel_sdvo_connector *connector,
 connector->base.base.doublescan_allowed = 0;
 connector->base.base.display_info.subpixel_order = SubPixelHorizontalRGB;
 
+connector->base.base.polled |= DRM_CONNECTOR_POLL_FORCE;
+
 intel_connector_attach_encoder(&connector->base, &encoder->base);
 drm_sysfs_connector_add(&connector->base.base);
 }

[PATCH 03/14] drm: introduce DRM_CONNECTOR_POLL_FORCE

Daniel Vetter — 2012-05-24T19:26:38

Useful for ->detect functions that have different behaviour if force
is set. This way probe_single_connector can avoid to do the expensive
edid dance on connectors where this is not needed.

I've checked through all drivers and set this flag everywhere where
the connector->detect function has different behaviour if force is
set. For nouveau and radeon I've got lost in the code traces, so I've
set this flag unconditionally.

Note that we also need to update the poll_execute function to now
also ignore connectors which have only this new flag set.

v2: Change POLL_HDP checks so that they ignore POLL_FORCE for both the
poll and the hpd handling code.

v3: Sprinkle POLL_FORCE more liberally over drivers. It should be now
everywhere where a non-intel driver can return anything else than
connector_status_connected in its detect callback.

Signed-Off-by: Daniel Vetter <daniel.vetter< at >ffwll.ch>
---
 drivers/gpu/drm/drm_crtc_helper.c             |    6 ++++--
 drivers/gpu/drm/exynos/exynos_drm_connector.c |    2 ++
 drivers/gpu/drm/gma500/cdv_intel_crt.c        |    2 ++
 drivers/gpu/drm/gma500/cdv_intel_hdmi.c       |    2 ++
 drivers/gpu/drm/gma500/mdfld_dsi_output.c     |    1 +
 drivers/gpu/drm/gma500/oaktrail_hdmi.c        |    2 ++
 drivers/gpu/drm/gma500/psb_intel_sdvo.c       |    2 ++
 drivers/gpu/drm/i915/intel_crt.c              |    3 ++-
 drivers/gpu/drm/i915/intel_tv.c               |    3 ++-
 drivers/gpu/drm/nouveau/nouveau_connector.c   |    1 +
 drivers/gpu/drm/radeon/radeon_connectors.c    |    5 +++++
 drivers/gpu/drm/udl/udl_connector.c           |    2 ++
 drivers/staging/omapdrm/omap_connector.c      |    2 ++
 include/drm/drm_crtc.h                        |    4 ++++
 14 files changed, 33 insertions(+), 4 deletions(-)

diff --git a/drivers/gpu/drm/drm_crtc_helper.c b/drivers/gpu/drm/drm_crtc_helper.c
index b1d643d..8ea1c1e 100644
--- a/drivers/gpu/drm/drm_crtc_helper.c
+++ b/drivers/gpu/drm/drm_crtc_helper.c
< at >< at > -944,7 +944,9 < at >< at > static void output_poll_execute(struct work_struct *work)
 
 /* Ignore HDP capable connectors and connectors where we don't
  * want any hotplug detection at all for polling. */
-if (!connector->polled || connector->polled == DRM_CONNECTOR_POLL_HPD)
+if (!connector->polled ||
+    connector->polled == DRM_CONNECTOR_POLL_FORCE ||
+    (connector->polled & DRM_CONNECTOR_POLL_HPD))
 continue;
 
 else if (connector->polled & (DRM_CONNECTOR_POLL_CONNECT | DRM_CONNECTOR_POLL_DISCONNECT))
< at >< at > -1029,7 +1031,7 < at >< at > void drm_helper_hpd_irq_event(struct drm_device *dev)
 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
 
 /* Only handle HPD capable connectors. */
-if (connector->polled != DRM_CONNECTOR_POLL_HPD)
+if (!(connector->polled & DRM_CONNECTOR_POLL_HPD))
 continue;
 
 old_status = connector->status;
diff --git a/drivers/gpu/drm/exynos/exynos_drm_connector.c b/drivers/gpu/drm/exynos/exynos_drm_connector.c
index bf791fa..e5a8a27 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_connector.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_connector.c
< at >< at > -327,6 +327,8 < at >< at > struct drm_connector *exynos_drm_connector_create(struct drm_device *dev,
 drm_connector_init(dev, connector, &exynos_connector_funcs, type);
 drm_connector_helper_add(connector, &exynos_connector_helper_funcs);
 
+connector->polled |= DRM_CONNECTOR_POLL_FORCE;
+
 err = drm_sysfs_connector_add(connector);
 if (err)
 goto err_connector;
diff --git a/drivers/gpu/drm/gma500/cdv_intel_crt.c b/drivers/gpu/drm/gma500/cdv_intel_crt.c
index 1874220..e6b2e49 100644
--- a/drivers/gpu/drm/gma500/cdv_intel_crt.c
+++ b/drivers/gpu/drm/gma500/cdv_intel_crt.c
< at >< at > -313,6 +313,8 < at >< at > void cdv_intel_crt_init(struct drm_device *dev,
 drm_connector_helper_add(connector,
 &cdv_intel_crt_connector_helper_funcs);
 
+connector->polled |= DRM_CONNECTOR_POLL_FORCE;
+
 drm_sysfs_connector_add(connector);
 
 return;
diff --git a/drivers/gpu/drm/gma500/cdv_intel_hdmi.c b/drivers/gpu/drm/gma500/cdv_intel_hdmi.c
index 88b59d4..766aec8 100644
--- a/drivers/gpu/drm/gma500/cdv_intel_hdmi.c
+++ b/drivers/gpu/drm/gma500/cdv_intel_hdmi.c
< at >< at > -373,6 +373,8 < at >< at > void cdv_hdmi_init(struct drm_device *dev,
 hdmi_priv->hdmi_i2c_adapter =
 &(psb_intel_encoder->i2c_bus->adapter);
 hdmi_priv->dev = dev;
+connector->polled |= DRM_CONNECTOR_POLL_FORCE;
+
 drm_sysfs_connector_add(connector);
 return;
 
diff --git a/drivers/gpu/drm/gma500/mdfld_dsi_output.c b/drivers/gpu/drm/gma500/mdfld_dsi_output.c
index 5675d93..0e97a91 100644
--- a/drivers/gpu/drm/gma500/mdfld_dsi_output.c
+++ b/drivers/gpu/drm/gma500/mdfld_dsi_output.c
< at >< at > -604,6 +604,7 < at >< at > void mdfld_dsi_output_init(struct drm_device *dev,
 dsi_config->encoder = encoder;
 encoder->base.type = (pipe == 0) ? INTEL_OUTPUT_MIPI :
 INTEL_OUTPUT_MIPI2;
+connector->polled |= DRM_CONNECTOR_POLL_FORCE;
 drm_sysfs_connector_add(connector);
 return;
 
diff --git a/drivers/gpu/drm/gma500/oaktrail_hdmi.c b/drivers/gpu/drm/gma500/oaktrail_hdmi.c
index c10899c..23b8d52 100644
--- a/drivers/gpu/drm/gma500/oaktrail_hdmi.c
+++ b/drivers/gpu/drm/gma500/oaktrail_hdmi.c
< at >< at > -349,6 +349,8 < at >< at > void oaktrail_hdmi_init(struct drm_device *dev,
 connector->display_info.subpixel_order = SubPixelHorizontalRGB;
 connector->interlace_allowed = false;
 connector->doublescan_allowed = false;
+connector->polled |= DRM_CONNECTOR_POLL_FORCE;
+
 drm_sysfs_connector_add(connector);
 
 return;
diff --git a/drivers/gpu/drm/gma500/psb_intel_sdvo.c b/drivers/gpu/drm/gma500/psb_intel_sdvo.c
index d39b15b..e86d8ba 100644
--- a/drivers/gpu/drm/gma500/psb_intel_sdvo.c
+++ b/drivers/gpu/drm/gma500/psb_intel_sdvo.c
< at >< at > -2028,6 +2028,8 < at >< at > psb_intel_sdvo_connector_init(struct psb_intel_sdvo_connector *connector,
 connector->base.base.display_info.subpixel_order = SubPixelHorizontalRGB;
 
 psb_intel_connector_attach_encoder(&connector->base, &encoder->base);
+connector->polled |= DRM_CONNECTOR_POLL_FORCE;
+
 drm_sysfs_connector_add(&connector->base.base);
 }
 
diff --git a/drivers/gpu/drm/i915/intel_crt.c b/drivers/gpu/drm/i915/intel_crt.c
index 75a70c4..a60d131 100644
--- a/drivers/gpu/drm/i915/intel_crt.c
+++ b/drivers/gpu/drm/i915/intel_crt.c
< at >< at > -639,7 +639,8 < at >< at > void intel_crt_init(struct drm_device *dev)
 if (I915_HAS_HOTPLUG(dev))
 connector->polled = DRM_CONNECTOR_POLL_HPD;
 else
-connector->polled = DRM_CONNECTOR_POLL_CONNECT;
+connector->polled = DRM_CONNECTOR_POLL_CONNECT |
+    DRM_CONNECTOR_POLL_FORCE;
 
 /*
  * Configure the automatic hotplug detection stuff
diff --git a/drivers/gpu/drm/i915/intel_tv.c b/drivers/gpu/drm/i915/intel_tv.c
index a233a51..dad7d8e 100644
--- a/drivers/gpu/drm/i915/intel_tv.c
+++ b/drivers/gpu/drm/i915/intel_tv.c
< at >< at > -1614,7 +1614,8 < at >< at > intel_tv_init(struct drm_device *dev)
  *
  * More recent chipsets favour HDMI rather than integrated S-Video.
  */
-connector->polled = DRM_CONNECTOR_POLL_CONNECT;
+connector->polled = DRM_CONNECTOR_POLL_CONNECT |
+    DRM_CONNECTOR_POLL_FORCE;
 
 drm_connector_init(dev, connector, &intel_tv_connector_funcs,
    DRM_MODE_CONNECTOR_SVIDEO);
diff --git a/drivers/gpu/drm/nouveau/nouveau_connector.c b/drivers/gpu/drm/nouveau/nouveau_connector.c
index fa86035..780d608 100644
--- a/drivers/gpu/drm/nouveau/nouveau_connector.c
+++ b/drivers/gpu/drm/nouveau/nouveau_connector.c
< at >< at > -1085,6 +1085,7 < at >< at > nouveau_connector_create(struct drm_device *dev, int index)
 if (ret == 0)
 connector->polled = DRM_CONNECTOR_POLL_HPD;
 }
+connector->polled |= DRM_CONNECTOR_POLL_FORCE;
 
 drm_sysfs_connector_add(connector);
 return connector;
diff --git a/drivers/gpu/drm/radeon/radeon_connectors.c b/drivers/gpu/drm/radeon/radeon_connectors.c
index 2914c57..c64ecc9 100644
--- a/drivers/gpu/drm/radeon/radeon_connectors.c
+++ b/drivers/gpu/drm/radeon/radeon_connectors.c
< at >< at > -1830,6 +1830,8 < at >< at > radeon_add_atom_connector(struct drm_device *dev,
 } else
 connector->polled = DRM_CONNECTOR_POLL_HPD;
 
+connector->polled |= DRM_CONNECTOR_POLL_FORCE;
+
 connector->display_info.subpixel_order = subpixel_order;
 drm_sysfs_connector_add(connector);
 return;
< at >< at > -1987,6 +1989,9 < at >< at > radeon_add_legacy_connector(struct drm_device *dev,
 connector->polled = DRM_CONNECTOR_POLL_CONNECT;
 } else
 connector->polled = DRM_CONNECTOR_POLL_HPD;
+
+connector->polled |= DRM_CONNECTOR_POLL_FORCE;
+
 connector->display_info.subpixel_order = subpixel_order;
 drm_sysfs_connector_add(connector);
 if (connector_type == DRM_MODE_CONNECTOR_LVDS) {
diff --git a/drivers/gpu/drm/udl/udl_connector.c b/drivers/gpu/drm/udl/udl_connector.c
index ba055e9..838dc71 100644
--- a/drivers/gpu/drm/udl/udl_connector.c
+++ b/drivers/gpu/drm/udl/udl_connector.c
< at >< at > -131,6 +131,8 < at >< at > int udl_connector_init(struct drm_device *dev, struct drm_encoder *encoder)
 drm_connector_init(dev, connector, &udl_connector_funcs, DRM_MODE_CONNECTOR_DVII);
 drm_connector_helper_add(connector, &udl_connector_helper_funcs);
 
+connector->polled |= DRM_CONNECTOR_POLL_FORCE;
+
 drm_sysfs_connector_add(connector);
 drm_mode_connector_attach_encoder(connector, encoder);
 
diff --git a/drivers/staging/omapdrm/omap_connector.c b/drivers/staging/omapdrm/omap_connector.c
index 5e2856c..bb8b134 100644
--- a/drivers/staging/omapdrm/omap_connector.c
+++ b/drivers/staging/omapdrm/omap_connector.c
< at >< at > -358,6 +358,8 < at >< at > struct drm_connector *omap_connector_init(struct drm_device *dev,
 connector->interlace_allowed = 1;
 connector->doublescan_allowed = 0;
 
+connector->polled |= DRM_CONNECTOR_POLL_FORCE;
+
 drm_sysfs_connector_add(connector);
 
 return connector;
diff --git a/include/drm/drm_crtc.h b/include/drm/drm_crtc.h
index d59bb7d..4417da2 100644
--- a/include/drm/drm_crtc.h
+++ b/include/drm/drm_crtc.h
< at >< at > -514,6 +514,10 < at >< at > enum drm_connector_force {
 /* can cleanly poll for disconnections without flickering the screen */
 /* DACs should rarely do this without a lot of testing */
 #define DRM_CONNECTOR_POLL_DISCONNECT (1 << 2)
+/* connector's ->detect function needs to be called when userspace forces
+ * detection. Should only be used if the detect function has special handling
+ * when force is set to avoid spurious re-reading of the edid. */
+#define DRM_CONNECTOR_POLL_FORCE (1 << 3)
 
 #define MAX_ELD_BYTES128

[RFC] [PATCH 00/14] HPD/connector-polling rework

Daniel Vetter — 2012-05-24T19:26:35

Hi all,

I've got fed up with our sorry state of connector detection and rampant edid re
and rere-reading.

This patch series lays the groundwork in the drm helpers so that drivers can
avoid all this madness (at least on working hw) and properly cache the edid.

With the additional changes for drm/i915, the edid is now read _once_ per plug
event (or at boot-up/resume time). A further step would be to integrate the
hotplug handling into the driver itself and only call ->detect on the connectors
for which the irq handler received a hotplug event.

By adding POLL_FORCE drivers can get back the old behaviour of calling ->detect
every time probe_single_connector is called from userspace. I've splattered that
over all drivers where I've thought it might be required.

Note though that setting this doesn't avoid all regressions - the regular output
poll work will still ignore any connectors with POLL_HPD set. If a driver/hw
with broken hpd got away due to this, this will break stuff. But that should be
easy to fix by admitting the defeat and setting POLL_CONNECT|DISCONNECT
directly.

If other people want to convert over their drivers, the following steps are
required:
- Ensure that the connector status is unknown every time the driver could have
  missed a hpd event (e.g. after resume). drm_mode_config_reset will do that for
  you.
- Drop the POLL_FORCE flag for connectors where hdp is fully reliable.
- Implement edid caching - that's a nice way to figure out whether hpd is
  actually reliable, because if it isn't, this step will ensure that you get bug
  reports because the the edid won't ever get updated ;-)
- Optionally teach the driver some smarts about which specific connectors
  actually got a hotplug event. Mostly useful on cheap hw (like intel's) that
  can't distinguish between hdmi and dp without trying some aux channel
  transfers.

As you can guess from the patch series, I've discovered the hard way that i915
sdvo support is totally broken. Tested on most of the intel machines I have and
also quickly on my radeon hd5000.

Comments, flames, ideas and test reports highly welcome.

Cheers, Daniel

Daniel Vetter (14):
  drm: extract drm_kms_helper_hotplug_event
  drm: handle HDP and polled connectors separately
  drm: introduce DRM_CONNECTOR_POLL_FORCE
  drm/i915: set POLL_FORCE for sdvo outputs
  drm: properly init/reset connector status
  drm: kill unnecessary calls to connector->detect
  drm: don't start the poll engine in probe_single_connector
  drm: don't unnecessarily enable the polling work
  drm: don't poll forced connectors
  drm/i915: cache crt edid
  drm/i915: cache dp edid
  drm/i915: cache hdmi edid
  drm/i915/sdvo: implement correct return value for ->get_modes
  drm/i915: s/mdelay/msleep/ in the sdvo detect function

 drivers/gpu/drm/drm_crtc.c                    |    6 ++-
 drivers/gpu/drm/drm_crtc_helper.c             |   76 ++++++++++++++++++-------
 drivers/gpu/drm/exynos/exynos_drm_connector.c |    2 +
 drivers/gpu/drm/gma500/cdv_intel_crt.c        |    2 +
 drivers/gpu/drm/gma500/cdv_intel_hdmi.c       |    2 +
 drivers/gpu/drm/gma500/mdfld_dsi_output.c     |    1 +
 drivers/gpu/drm/gma500/oaktrail_hdmi.c        |    2 +
 drivers/gpu/drm/gma500/psb_intel_sdvo.c       |    2 +
 drivers/gpu/drm/i915/intel_crt.c              |   28 +++++++--
 drivers/gpu/drm/i915/intel_dp.c               |   47 +++++++--------
 drivers/gpu/drm/i915/intel_drv.h              |    2 +
 drivers/gpu/drm/i915/intel_hdmi.c             |   48 ++++++++++------
 drivers/gpu/drm/i915/intel_modes.c            |   18 +++++-
 drivers/gpu/drm/i915/intel_sdvo.c             |   45 +++++++++------
 drivers/gpu/drm/i915/intel_tv.c               |    3 +-
 drivers/gpu/drm/nouveau/nouveau_connector.c   |    1 +
 drivers/gpu/drm/radeon/radeon_connectors.c    |    5 ++
 drivers/gpu/drm/udl/udl_connector.c           |    2 +
 drivers/staging/omapdrm/omap_connector.c      |    2 +
 include/drm/drm_crtc.h                        |    5 ++
 include/drm/drm_crtc_helper.h                 |    1 +
 21 files changed, 208 insertions(+), 92 deletions(-)

[Bug 50232] screen redraw is wrong in sauerbraten with the llvmcompiler

2012-05-24T20:25:38

https://bugs.freedesktop.org/show_bug.cgi?id=50232

--- Comment #2 from almos <aaalmosss< at >gmail.com> 2012-05-24 13:25:38 PDT ---
(In reply to comment #1)
The revert patch fixes the ghost image problem. The warning is still printed,
but the visuals seem to be good now.

[Bug 50230] offset mapping in nexuiz results in bad texturing withthe llvm compiler

2012-05-24T20:25:32

https://bugs.freedesktop.org/show_bug.cgi?id=50230

--- Comment #10 from almos <aaalmosss< at >gmail.com> 2012-05-24 13:25:32 PDT ---
(In reply to comment #9)
Yes, the patch fixes it. I also tried the revert patch, and that fixes the
lightmap flickering.

[RFC][PATCH 6/6] WIP drm/i915: "Atomic" modeset test implementation

2012-05-24T20:16:47

From: Ville Syrjälä <ville.syrjala< at >linux.intel.com>

Just a quick prototype to test the atomic modeset API. Implemented
via already existing non-atomic mechanisms internally.
---
 drivers/gpu/drm/i915/Makefile        |    1 +
 drivers/gpu/drm/i915/intel_atomic.c  |  788 ++++++++++++++++++++++++++++++++++
 drivers/gpu/drm/i915/intel_display.c |    7 +
 3 files changed, 796 insertions(+), 0 deletions(-)
 create mode 100644 drivers/gpu/drm/i915/intel_atomic.c

diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile
index 2e9268d..f97e7a4 100644
--- a/drivers/gpu/drm/i915/Makefile
+++ b/drivers/gpu/drm/i915/Makefile
< at >< at > -15,6 +15,7 < at >< at > i915-y := i915_drv.o i915_dma.o i915_irq.o \
   i915_gem_tiling.o \
   i915_sysfs.o \
   i915_trace_points.o \
+  intel_atomic.o \
   intel_display.o \
   intel_crt.o \
   intel_lvds.o \
diff --git a/drivers/gpu/drm/i915/intel_atomic.c b/drivers/gpu/drm/i915/intel_atomic.c
new file mode 100644
index 0000000..a6643fd
--- /dev/null
+++ b/drivers/gpu/drm/i915/intel_atomic.c
< at >< at > -0,0 +1,788 < at >< at >
+/*
+ */
+
+#include <drm/drmP.h>
+#include <drm/drm_crtc.h>
+
+static struct drm_property *prop_src_x;
+static struct drm_property *prop_src_y;
+static struct drm_property *prop_src_w;
+static struct drm_property *prop_src_h;
+static struct drm_property *prop_crtc_x;
+static struct drm_property *prop_crtc_y;
+static struct drm_property *prop_crtc_w;
+static struct drm_property *prop_crtc_h;
+static struct drm_property *prop_fb_id;
+static struct drm_property *prop_crtc_id;
+static struct drm_property *prop_mode_id;
+static struct drm_property *prop_connector_ids;
+/* FIXME must be per-CRTC */
+static struct drm_property_blob *blob_connector_ids;
+
+static uint32_t *connector_ids;
+
+struct intel_plane_state {
+struct drm_plane *plane;
+int32_t crtc_x, crtc_y;
+uint32_t crtc_w, crtc_h;
+uint32_t src_x, src_y, src_w, src_h;
+struct drm_framebuffer *fb;
+struct drm_crtc *crtc;
+uint32_t fb_id;
+uint32_t crtc_id;
+bool dirty;
+};
+
+struct intel_crtc_state {
+struct drm_crtc *crtc;
+struct drm_display_mode *mode;
+int x, y;
+struct drm_framebuffer *fb;
+uint32_t fb_id;
+bool mode_dirty;
+bool fb_dirty;
+bool active_dirty;
+unsigned int count_connectors;
+struct drm_connector **connectors;
+};
+
+struct intel_atomic_state {
+struct intel_plane_state plane[3];
+struct intel_crtc_state crtc[3];
+bool fbs_pinned;
+bool dirty;
+};
+
+static int populate_connectors(const struct drm_crtc *crtc,
+       struct drm_connector **connector_list)
+{
+struct drm_connector *connector;
+
+int i = 0;
+
+list_for_each_entry(connector, &crtc->dev->mode_config.connector_list, head) {
+if (!connector->encoder || connector->encoder->crtc != crtc)
+continue;
+
+connector_list[i++] = connector;
+}
+
+return i;
+}
+
+static void *intel_atomic_begin(struct drm_device *dev, uint32_t flags)
+{
+struct intel_atomic_state *state;
+struct drm_plane *plane;
+struct drm_crtc *crtc;
+struct drm_connector **connector_ptr;
+int i;
+
+state = kzalloc(sizeof *state + dev->mode_config.num_connector *
+sizeof(struct drm_connector *) * ARRAY_SIZE(state->crtc), GFP_KERNEL);
+if (!state)
+return ERR_PTR(-ENOMEM);
+
+connector_ptr = (struct drm_connector **)(state + 1);
+
+i = 0;
+list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+if (i >= ARRAY_SIZE(state->crtc))
+break;
+
+state->crtc[i].crtc = crtc;
+state->crtc[i].mode = &crtc->mode;
+state->crtc[i].x = crtc->x;
+state->crtc[i].y = crtc->y;
+state->crtc[i].fb = crtc->fb;
+state->crtc[i].fb_id = crtc->fb ? crtc->fb->base.id : 0;
+
+state->crtc[i].count_connectors = populate_connectors(crtc, connector_ptr);
+state->crtc[i].connectors = connector_ptr;
+connector_ptr += dev->mode_config.num_connector;
+
+i++;
+}
+
+i = 0;
+list_for_each_entry(plane, &dev->mode_config.plane_list, head) {
+if (i >= ARRAY_SIZE(state->plane))
+break;
+
+state->plane[i].plane = plane;
+state->plane[i].crtc_x = plane->crtc_x;
+state->plane[i].crtc_y = plane->crtc_y;
+state->plane[i].crtc_w = plane->crtc_w;
+state->plane[i].crtc_h = plane->crtc_h;
+state->plane[i].src_x = plane->src_x;
+state->plane[i].src_y = plane->src_y;
+state->plane[i].src_w = plane->src_w;
+state->plane[i].src_h = plane->src_h;
+state->plane[i].fb = plane->fb;
+state->plane[i].fb_id = plane->fb ? plane->fb->base.id : 0;
+state->plane[i].crtc = plane->crtc;
+state->plane[i].crtc_id = plane->crtc ? plane->crtc->base.id : 0;
+
+i++;
+}
+
+return state;
+}
+
+static int plane_set(struct intel_plane_state *state,
+     struct drm_property *prop,
+     uint64_t value)
+{
+struct drm_plane *plane = state->plane;
+struct drm_mode_object *obj;
+
+if (!state)
+return -ENOENT;
+
+if (prop == prop_src_x) {
+if (state->src_x == value)
+return 0;
+state->src_x = value;
+} else if (prop == prop_src_y) {
+if (state->src_y == value)
+return 0;
+state->src_y = value;
+} else if (prop == prop_src_w) {
+if (state->src_w == value)
+return 0;
+state->src_w = value;
+} else if (prop == prop_src_h) {
+if (state->src_h == value)
+return 0;
+state->src_h = value;
+} else if (prop == prop_crtc_x) {
+if (state->crtc_x == value)
+return 0;
+state->crtc_x = value;
+} else if (prop == prop_crtc_y) {
+if (state->crtc_y == value)
+return 0;
+state->crtc_y = value;
+} else if (prop == prop_crtc_w) {
+if (state->crtc_w == value)
+return 0;
+state->crtc_w = value;
+} else if (prop == prop_crtc_h) {
+if (state->crtc_h == value)
+return 0;
+state->crtc_h = value;
+} else if (prop == prop_crtc_id) {
+struct drm_crtc *crtc = NULL;
+
+if (state->crtc_id == value)
+return 0;
+
+if (value) {
+obj = drm_mode_object_find(plane->dev, value, DRM_MODE_OBJECT_CRTC);
+if (!obj) {
+printk("Unknown CRTC ID %llu\n", value);
+return -ENOENT;
+}
+crtc = obj_to_crtc(obj);
+}
+
+state->crtc = crtc;
+state->crtc_id = value;
+} else if (prop == prop_fb_id) {
+struct drm_framebuffer *fb = NULL;
+
+if (state->fb_id == value)
+return 0;
+
+if (value) {
+obj = drm_mode_object_find(plane->dev, value, DRM_MODE_OBJECT_FB);
+if (!obj) {
+printk("Unknown framebuffer ID %llu\n", value);
+return -ENOENT;
+}
+fb = obj_to_fb(obj);
+}
+
+state->fb = fb;
+state->fb_id = value;
+} else
+return -ENOENT;
+
+state->dirty = true;
+
+return 0;
+}
+
+static int crtc_set(struct intel_crtc_state *state,
+    struct drm_property *prop,
+    uint64_t value, void *blob_data)
+{
+struct drm_crtc *crtc = state->crtc;
+struct drm_mode_object *obj;
+
+if (!state)
+return -ENOENT;
+
+if (prop == prop_src_x) {
+if (state->x == value)
+return 0;
+state->x = value;
+state->mode_dirty = true;
+} else if (prop == prop_src_y) {
+if (state->y == value)
+return 0;
+state->y = value;
+state->mode_dirty = true;
+} else if (prop == prop_mode_id) {
+struct drm_display_mode *mode = NULL;
+
+if (value) {
+obj = drm_mode_object_find(crtc->dev, value, DRM_MODE_OBJECT_MODE);
+if (!obj) {
+printk("Unknown mode ID %llu\n", value);
+return -ENOENT;
+}
+mode = obj_to_mode(obj);
+}
+
+if (!state->mode && !mode)
+return 0;
+
+if (state->mode && mode && !memcmp(state->mode, mode, sizeof *mode))
+return 0;
+
+if (!state->mode || !mode ||
+    state->mode->hdisplay != mode->hdisplay ||
+    state->mode->vdisplay != mode->vdisplay)
+state->active_dirty = true;
+
+state->mode = mode;
+state->mode_dirty = true;
+} else if (prop == prop_fb_id) {
+struct drm_framebuffer *fb = NULL;
+
+if (state->fb_id == value)
+return 0;
+
+if (value) {
+obj = drm_mode_object_find(crtc->dev, value, DRM_MODE_OBJECT_FB);
+if (!obj) {
+printk("Unknown framebuffer ID %llu\n", value);
+return -ENOENT;
+}
+fb = obj_to_fb(obj);
+}
+
+if (state->fb && fb) {
+/* can we page flip? */
+if (state->fb->pixel_format == fb->pixel_format &&
+    state->fb->offsets[0] == fb->offsets[0] &&
+    state->fb->pitches[0] == fb->pitches[0]) {
+state->fb_id = value;
+state->fb = obj_to_fb(obj);
+state->fb_dirty = true;
+return 0;
+}
+}
+
+state->fb_id = value;
+state->fb = fb;
+state->mode_dirty = true;
+} else if (prop == prop_connector_ids) {
+const uint32_t *new_conn = blob_data;
+uint32_t count_new_conn = value / sizeof(uint32_t);
+unsigned int i;
+
+if (value & 3)
+return -EINVAL;
+
+if (count_new_conn > crtc->dev->mode_config.num_connector)
+return -ERANGE;
+
+if (count_new_conn == state->count_connectors) {
+for (i = 0; i < count_new_conn; i++) {
+if (state->connectors[i]->base.id != new_conn[i])
+break;
+}
+/* no change */
+if (i == count_new_conn)
+return 0;
+}
+
+if (!count_new_conn) {
+state->count_connectors = 0;
+state->mode_dirty = true;
+return 0;
+}
+
+for (i = 0; i < count_new_conn; i++) {
+obj = drm_mode_object_find(crtc->dev, new_conn[i], DRM_MODE_OBJECT_CONNECTOR);
+if (!obj) {
+printk("Unknown connector ID %u\n", new_conn[i]);
+return -ENOENT;
+}
+
+state->connectors[i] = obj_to_connector(obj);
+}
+state->count_connectors = count_new_conn;
+state->mode_dirty = true;
+} else
+return -ENOENT;
+
+return 0;
+}
+
+static struct intel_plane_state *get_plane_state(struct intel_atomic_state *state,
+ struct drm_plane *plane)
+{
+int i;
+
+for (i = 0; i < ARRAY_SIZE(state->plane); i++)
+if (plane == state->plane[i].plane)
+return &state->plane[i];
+
+return NULL;
+}
+
+static struct intel_crtc_state *get_crtc_state(struct intel_atomic_state *state,
+       struct drm_crtc *crtc)
+{
+int i;
+
+for (i = 0; i < ARRAY_SIZE(state->crtc); i++)
+if (crtc == state->crtc[i].crtc)
+return &state->crtc[i];
+
+return NULL;
+}
+
+static int intel_atomic_set(struct drm_device *dev,
+    void *state,
+    struct drm_mode_object *obj,
+    struct drm_property *prop,
+    uint64_t value, void *blob_data)
+{
+struct intel_atomic_state *s = state;
+int ret = -EINVAL;
+
+switch (obj->type) {
+case DRM_MODE_OBJECT_PLANE:
+ret = plane_set(get_plane_state(s, obj_to_plane(obj)), prop, value);
+break;
+case DRM_MODE_OBJECT_CRTC:
+ret = crtc_set(get_crtc_state(s, obj_to_crtc(obj)), prop, value, blob_data);
+break;
+default:
+break;
+}
+
+kfree(blob_data);
+
+if (ret)
+return ret;
+
+s->dirty = true;
+
+return 0;
+}
+
+static int check_plane(struct intel_plane_state *state)
+{
+/* FIXME check everything */
+
+return 0;
+}
+
+static void dirty_planes(struct intel_atomic_state *state,
+ struct drm_crtc *crtc)
+{
+int i;
+
+for (i = 0; i < ARRAY_SIZE(state->plane); i++) {
+if (state->plane[i].crtc == crtc)
+state->plane[i].dirty = true;
+}
+}
+
+static int check_crtc(struct intel_atomic_state *state,
+      struct intel_crtc_state *s)
+{
+/*
+ * Mark all planes on this CRTC as dirty if the active video
+ * area changed so that the planes will get reclipped correctly.
+ */
+if (s->active_dirty)
+dirty_planes(state, s->crtc);
+
+/* FIXME check mode and fb if dirty */
+
+return 0;
+}
+
+static int intel_atomic_check(struct drm_device *dev, void *state)
+{
+struct intel_atomic_state *s = state;
+int i;
+
+if (!s->dirty)
+return 0;
+
+for (i = 0; i < ARRAY_SIZE(s->crtc); i++) {
+if (!s->crtc[i].fb_dirty && !s->crtc[i].mode_dirty)
+continue;
+
+check_crtc(s, &s->crtc[i]);
+}
+
+for (i = 0; i < ARRAY_SIZE(s->plane); i++) {
+if (!s->plane[i].dirty)
+continue;
+
+check_plane(&s->plane[i]);
+}
+
+return 0;
+}
+
+static void update_plane_props(struct intel_plane_state *state)
+{
+struct drm_mode_object *obj = &state->plane->base;
+
+if (prop_src_x)
+drm_object_property_set_value(obj, prop_src_x, state->src_x);
+if (prop_src_y)
+drm_object_property_set_value(obj, prop_src_y, state->src_y);
+if (prop_src_w)
+drm_object_property_set_value(obj, prop_src_w, state->src_w);
+if (prop_src_h)
+drm_object_property_set_value(obj, prop_src_h, state->src_h);
+
+if (prop_crtc_x)
+drm_object_property_set_value(obj, prop_crtc_x, state->crtc_x);
+if (prop_crtc_y)
+drm_object_property_set_value(obj, prop_crtc_y, state->crtc_y);
+if (prop_crtc_w)
+drm_object_property_set_value(obj, prop_crtc_w, state->crtc_w);
+if (prop_crtc_h)
+drm_object_property_set_value(obj, prop_crtc_h, state->crtc_h);
+
+if (prop_fb_id)
+drm_object_property_set_value(obj, prop_fb_id, state->fb_id);
+
+if (prop_crtc_id)
+drm_object_property_set_value(obj, prop_crtc_id, state->crtc_id);
+}
+
+static void update_crtc_props(struct intel_crtc_state *state)
+{
+struct drm_mode_object *obj = &state->crtc->base;
+struct drm_device *dev = state->crtc->dev;
+unsigned int i;
+
+if (prop_src_x)
+drm_object_property_set_value(obj, prop_src_x, state->x);
+if (prop_src_y)
+drm_object_property_set_value(obj, prop_src_y, state->y);
+
+if (prop_fb_id)
+drm_object_property_set_value(obj, prop_fb_id, state->fb_id);
+
+/* FIXME if mode is user specifiec via old setcrtc ioctl prop value should be -1 */
+if (prop_mode_id)
+drm_object_property_set_value(obj, prop_mode_id,
+      state->mode ? state->mode->base.id : 0);
+
+if (!prop_connector_ids || !connector_ids)
+return;
+
+if (blob_connector_ids)
+drm_property_destroy_blob(dev, blob_connector_ids);
+
+for (i = 0; i < state->count_connectors; i++)
+connector_ids[i] = state->connectors[i]->base.id;
+
+blob_connector_ids = drm_property_create_blob(dev,
+      state->count_connectors * sizeof connector_ids[0],
+      connector_ids);
+if (!blob_connector_ids)
+drm_object_property_set_value(obj, prop_connector_ids,
+      blob_connector_ids->base.id);
+else
+drm_object_property_set_value(obj, prop_connector_ids, 0);
+}
+
+static void update_props(struct intel_atomic_state *s)
+{
+int i;
+
+for (i = 0; i < ARRAY_SIZE(s->crtc); i++) {
+if (!s->crtc[i].fb_dirty && !s->crtc[i].mode_dirty)
+continue;
+
+update_crtc_props(&s->crtc[i]);
+}
+
+for (i = 0; i < ARRAY_SIZE(s->plane); i++) {
+if (!s->plane[i].dirty)
+continue;
+
+update_plane_props(&s->plane[i]);
+}
+}
+
+static int update_crtc(struct intel_crtc_state *state)
+{
+struct drm_crtc *crtc = state->crtc;
+struct drm_mode_set set;
+int i;
+
+if (!state->mode_dirty)
+return crtc->funcs->page_flip(crtc, state->fb, NULL);
+
+set.crtc = state->crtc;
+set.x = state->x;
+set.y = state->y;
+set.mode = state->mode;
+set.connectors = state->connectors;
+set.num_connectors = state->count_connectors;
+set.fb = state->fb;
+
+#if 0
+printk("CRTC %u\n"
+       " x = %d\n"
+       " y = %d\n",
+       crtc->base.id,
+       set.x,
+       set.y);
+
+if (set.mode) {
+printk(" mode %u\n"
+       "  hdisplay = %d\n"
+       "  hsync_start = %d\n"
+       "  hsync_end = %d\n"
+       "  htotal = %d\n"
+       "  hdisplay = %d\n"
+       "  hsync_start = %d\n"
+       "  hsync_end = %d\n"
+       "  htotal = %d\n"
+       "  clock = %d\n"
+       "  vrefresh = %d\n",
+       set.mode->base.id,
+       set.mode->hdisplay,
+       set.mode->hsync_start,
+       set.mode->hsync_end,
+       set.mode->htotal,
+       set.mode->vdisplay,
+       set.mode->vsync_start,
+       set.mode->vsync_end,
+       set.mode->vtotal,
+       set.mode->clock,
+       set.mode->vrefresh);
+} else
+printk(" no mode\n");
+
+if (set.num_connectors) {
+printk(" connectors:");
+for (i = 0; i < set.num_connectors; i++)
+printk(" %u", set.connectors[i]->base.id);
+printk("\n");
+} else
+printk(" no connectors\n");
+#endif
+
+return crtc->funcs->set_config(&set);
+}
+
+static int update_plane(struct intel_plane_state *state)
+{
+struct drm_plane *plane = state->plane;
+int ret;
+
+if (state->fb && state->crtc)
+ret = plane->funcs->update_plane(plane,
+ state->crtc,
+ state->fb,
+ state->crtc_x,
+ state->crtc_y,
+ state->crtc_w,
+ state->crtc_h,
+ state->src_x,
+ state->src_y,
+ state->src_w,
+ state->src_h);
+else
+ret = plane->funcs->disable_plane(plane);
+
+if (ret)
+return ret;
+
+plane->fb = state->fb;
+plane->crtc = state->crtc;
+plane->crtc_x = state->crtc_x;
+plane->crtc_y = state->crtc_y;
+plane->crtc_w = state->crtc_w;
+plane->crtc_h = state->crtc_h;
+plane->src_x = state->src_x;
+plane->src_y = state->src_y;
+plane->src_w = state->src_w;
+plane->src_h = state->src_h;
+
+return 0;
+}
+
+static int intel_atomic_commit(struct drm_device *dev, void *state)
+{
+struct intel_atomic_state *s = state;
+int i;
+int ret = 0;
+
+if (!s->dirty)
+return 0;
+
+for (i = 0; i < ARRAY_SIZE(s->crtc); i++) {
+if (!s->crtc[i].mode_dirty)
+continue;
+
+//intel_disable_crtc();
+}
+
+for (i = 0; i < ARRAY_SIZE(s->plane); i++) {
+if (!s->plane[i].dirty)
+continue;
+
+ret = update_plane(&s->plane[i]);
+if (ret)
+return ret;
+}
+
+for (i = 0; i < ARRAY_SIZE(s->crtc); i++) {
+if (!s->crtc[i].mode_dirty && !s->crtc[i].fb_dirty)
+continue;
+
+ret = update_crtc(&s->crtc[i]);
+if (ret)
+return ret;
+}
+
+update_props(s);
+
+return ret;
+}
+
+static void intel_atomic_end(struct drm_device *dev, void *state)
+{
+kfree(state);
+}
+
+static const struct drm_atomic_funcs intel_atomic_funcs = {
+.begin = intel_atomic_begin,
+.set = intel_atomic_set,
+.check = intel_atomic_check,
+.commit = intel_atomic_commit,
+.end = intel_atomic_end,
+};
+
+int intel_atomic_init(struct drm_device *dev)
+{
+struct drm_crtc *crtc;
+struct drm_plane *plane;
+void *state;
+
+connector_ids = kcalloc(dev->mode_config.num_connector, sizeof connector_ids[0], GFP_KERNEL);
+if (!connector_ids)
+return -ENOMEM;
+
+prop_src_x = drm_property_create_range(dev, 0, "SRC_X", 0, UINT_MAX);
+prop_src_y = drm_property_create_range(dev, 0, "SRC_Y", 0, UINT_MAX);
+prop_src_w = drm_property_create_range(dev, 0, "SRC_W", 0, UINT_MAX);
+prop_src_h = drm_property_create_range(dev, 0, "SRC_H", 0, UINT_MAX);
+
+// fixme signed values needed
+prop_crtc_x = drm_property_create_range(dev, 0, "CRTC_X", INT_MIN, INT_MAX);
+prop_crtc_y = drm_property_create_range(dev, 0, "CRTC_Y", INT_MIN, INT_MAX);
+prop_crtc_w = drm_property_create_range(dev, 0, "CRTC_W", 0, INT_MAX);
+prop_crtc_h = drm_property_create_range(dev, 0, "CRTC_H", 0, INT_MAX);
+
+prop_fb_id = drm_property_create_range(dev, 0, "FB_ID", 0, UINT_MAX);
+prop_crtc_id = drm_property_create_range(dev, 0, "CRTC_ID", 0, UINT_MAX);
+prop_mode_id = drm_property_create_range(dev, 0, "MODE_ID", 0, UINT_MAX);
+
+prop_connector_ids = drm_property_create(dev, DRM_MODE_PROP_BLOB, "CONNECTOR_IDS", 0);
+
+list_for_each_entry(plane, &dev->mode_config.plane_list, head) {
+struct drm_mode_object *obj = &plane->base;
+
+if (prop_src_x)
+drm_object_attach_property(obj, prop_src_x, 0);
+if (prop_src_y)
+drm_object_attach_property(obj, prop_src_y, 0);
+if (prop_src_w)
+drm_object_attach_property(obj, prop_src_w, 0);
+if (prop_src_h)
+drm_object_attach_property(obj, prop_src_h, 0);
+
+if (prop_crtc_x)
+drm_object_attach_property(obj, prop_crtc_x, 0);
+if (prop_crtc_y)
+drm_object_attach_property(obj, prop_crtc_y, 0);
+if (prop_crtc_w)
+drm_object_attach_property(obj, prop_crtc_w, 0);
+if (prop_crtc_h)
+drm_object_attach_property(obj, prop_crtc_h, 0);
+
+if (prop_fb_id)
+drm_object_attach_property(obj, prop_fb_id, 0);
+if (prop_crtc_id)
+drm_object_attach_property(obj, prop_crtc_id, 0);
+}
+
+list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+struct drm_mode_object *obj = &crtc->base;
+
+if (prop_src_x)
+drm_object_attach_property(obj, prop_src_x, 0);
+if (prop_src_y)
+drm_object_attach_property(obj, prop_src_y, 0);
+
+if (prop_fb_id)
+drm_object_attach_property(obj, prop_fb_id, 0);
+if (prop_mode_id)
+drm_object_attach_property(obj, prop_mode_id, 0);
+if (prop_connector_ids)
+drm_object_attach_property(obj, prop_connector_ids, 0);
+}
+
+dev->driver->atomic_funcs = &intel_atomic_funcs;
+
+/* quick way to pre-populate the properties... */
+state = intel_atomic_begin(dev, 0);
+if (state) {
+update_props(state);
+intel_atomic_end(dev, state);
+}
+
+return 0;
+}
+
+void intel_atomic_fini(struct drm_device *dev)
+{
+kfree(connector_ids);
+
+if (blob_connector_ids)
+drm_property_destroy_blob(dev, blob_connector_ids);
+
+drm_property_destroy(dev, prop_src_x);
+drm_property_destroy(dev, prop_src_y);
+drm_property_destroy(dev, prop_src_w);
+drm_property_destroy(dev, prop_src_h);
+
+drm_property_destroy(dev, prop_crtc_x);
+drm_property_destroy(dev, prop_crtc_y);
+drm_property_destroy(dev, prop_crtc_w);
+drm_property_destroy(dev, prop_crtc_h);
+
+drm_property_destroy(dev, prop_fb_id);
+drm_property_destroy(dev, prop_crtc_id);
+drm_property_destroy(dev, prop_mode_id);
+drm_property_destroy(dev, prop_connector_ids);
+}
diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c
index aec6cac..3ff6ae9 100644
--- a/drivers/gpu/drm/i915/intel_display.c
+++ b/drivers/gpu/drm/i915/intel_display.c
< at >< at > -7049,6 +7049,9 < at >< at > void intel_modeset_init_hw(struct drm_device *dev)
 ivb_pch_pwm_override(dev);
 }
 
+void intel_atomic_init(struct drm_device *dev);
+void intel_atomic_fini(struct drm_device *dev);
+
 void intel_modeset_init(struct drm_device *dev)
 {
 struct drm_i915_private *dev_priv = dev->dev_private;
< at >< at > -7103,6 +7106,8 < at >< at > void intel_modeset_init(struct drm_device *dev)
 INIT_WORK(&dev_priv->idle_work, intel_idle_update);
 setup_timer(&dev_priv->idle_timer, intel_gpu_idle_timer,
     (unsigned long)dev);
+
+intel_atomic_init(dev);
 }
 
 void intel_modeset_gem_init(struct drm_device *dev)
< at >< at > -7118,6 +7123,8 < at >< at > void intel_modeset_cleanup(struct drm_device *dev)
 struct drm_crtc *crtc;
 struct intel_crtc *intel_crtc;
 
+intel_atomic_fini(dev);
+
 drm_kms_helper_poll_fini(dev);
 mutex_lock(&dev->struct_mutex);

[RFC][PATCH 5/6] WIP: drm: Atomic modeset ioctl

2012-05-24T20:16:46

From: Ville Syrjälä <ville.syrjala< at >linux.intel.com>

First draft.

The ioctl simply takes a list of object IDs and property IDs and their
values. For setting values to blob properties, the property value
indicates the length of the data, and the actual data is passed via
another blob pointer.

Detailed error reporting is missing, as is completion event support.
---
 drivers/gpu/drm/drm_crtc.c |  133 ++++++++++++++++++++++++++++++++++++++++++++
 drivers/gpu/drm/drm_drv.c  |    1 +
 include/drm/drm.h          |    1 +
 include/drm/drmP.h         |    2 +
 include/drm/drm_crtc.h     |   12 ++++
 include/drm/drm_mode.h     |   14 +++++
 6 files changed, 163 insertions(+), 0 deletions(-)

diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c
index 958a4b0..0dc94c5 100644
--- a/drivers/gpu/drm/drm_crtc.c
+++ b/drivers/gpu/drm/drm_crtc.c
< at >< at > -4124,3 +4124,136 < at >< at > int drm_calc_vscale(struct drm_region *src, struct drm_region *dst,
 return vscale;
 }
 EXPORT_SYMBOL(drm_calc_vscale);
+
+int drm_mode_atomic_ioctl(struct drm_device *dev,
+  void *data, struct drm_file *file_priv)
+{
+struct drm_mode_atomic *arg = data;
+uint32_t __user *objs_ptr = (uint32_t __user *)(unsigned long)(arg->objs_ptr);
+uint32_t __user *count_props_ptr = (uint32_t __user *)(unsigned long)(arg->count_props_ptr);
+uint32_t __user *props_ptr = (uint32_t __user *)(unsigned long)(arg->props_ptr);
+uint64_t __user *prop_values_ptr = (uint64_t __user *)(unsigned long)(arg->prop_values_ptr);
+uint64_t __user *blob_values_ptr = (uint64_t __user *)(unsigned long)(arg->blob_values_ptr);
+unsigned int copied_objs = 0;
+unsigned int copied_props = 0;
+unsigned int copied_blobs = 0;
+void *state;
+int ret = 0;
+unsigned int i, j;
+
+if (!dev->driver->atomic_funcs ||
+    !dev->driver->atomic_funcs->begin ||
+    !dev->driver->atomic_funcs->set ||
+    !dev->driver->atomic_funcs->check ||
+    !dev->driver->atomic_funcs->commit ||
+    !dev->driver->atomic_funcs->end)
+return -ENOSYS;
+
+if (arg->flags & ~DRM_ATOMIC_TEST_ONLY)
+return -EINVAL;
+
+mutex_lock(&dev->mode_config.mutex);
+
+state = dev->driver->atomic_funcs->begin(dev, arg->flags);
+if (IS_ERR(state)) {
+ret = PTR_ERR(state);
+goto unlock;
+}
+
+for (i = 0; i < arg->count_objs; i++) {
+uint32_t obj_id, count_props;
+struct drm_mode_object *obj;
+
+if (get_user(obj_id, objs_ptr + copied_objs)) {
+ret = -EFAULT;
+goto out;
+}
+
+obj = drm_mode_object_find(dev, obj_id, DRM_MODE_OBJECT_ANY);
+if (!obj || !obj->properties) {
+ret = -ENOENT;
+goto out;
+}
+
+if (get_user(count_props, count_props_ptr + copied_objs)) {
+ret = -EFAULT;
+goto out;
+}
+
+copied_objs++;
+
+for (j = 0; j < count_props; j++) {
+uint32_t prop_id;
+uint64_t prop_value;
+struct drm_mode_object *prop_obj;
+struct drm_property *prop;
+void *blob_data = NULL;
+
+if (get_user(prop_id, props_ptr + copied_props)) {
+ret = -EFAULT;
+goto out;
+}
+
+if (!object_has_prop(obj, prop_id)) {
+ret = -EINVAL;
+goto out;
+}
+
+prop_obj = drm_mode_object_find(dev, prop_id, DRM_MODE_OBJECT_PROPERTY);
+if (!prop_obj) {
+ret = -ENOENT;
+goto out;
+}
+prop = obj_to_property(prop_obj);
+
+if (get_user(prop_value, prop_values_ptr + copied_props)) {
+ret = -EFAULT;
+goto out;
+}
+
+if (!drm_property_change_is_valid(prop, prop_value)) {
+ret = -EINVAL;
+goto out;
+}
+
+if (prop->flags & DRM_MODE_PROP_BLOB && prop_value) {
+blob_data = kmalloc(prop_value, GFP_KERNEL);
+if (!blob_data) {
+ret = -ENOMEM;
+goto out;
+}
+
+if (copy_from_user(blob_data, blob_values_ptr + copied_blobs, prop_value)) {
+kfree(blob_data);
+ret = -EFAULT;
+goto out;
+}
+
+copied_blobs++;
+}
+
+/* The driver will be in charge of blob_data from now on. */
+ret = dev->driver->atomic_funcs->set(dev, state, obj, prop, prop_value, blob_data);
+if (ret)
+goto out;
+
+copied_props++;
+}
+}
+
+ret = dev->driver->atomic_funcs->check(dev, state);
+if (ret)
+goto out;
+
+if (arg->flags & DRM_ATOMIC_TEST_ONLY)
+goto out;
+
+ret = dev->driver->atomic_funcs->commit(dev, state);
+
+ out:
+dev->driver->atomic_funcs->end(dev, state);
+ unlock:
+mutex_unlock(&dev->mode_config.mutex);
+
+return ret;
+}
diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c
index 8a9d079..3e32c8a 100644
--- a/drivers/gpu/drm/drm_drv.c
+++ b/drivers/gpu/drm/drm_drv.c
< at >< at > -166,6 +166,7 < at >< at > static struct drm_ioctl_desc drm_ioctls[] = {
 DRM_IOCTL_DEF(DRM_IOCTL_MODE_DESTROY_DUMB, drm_mode_destroy_dumb_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
 DRM_IOCTL_DEF(DRM_IOCTL_MODE_OBJ_GETPROPERTIES, drm_mode_obj_get_properties_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
 DRM_IOCTL_DEF(DRM_IOCTL_MODE_OBJ_SETPROPERTY, drm_mode_obj_set_property_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
+DRM_IOCTL_DEF(DRM_IOCTL_MODE_ATOMIC, drm_mode_atomic_ioctl, DRM_MASTER|DRM_CONTROL_ALLOW|DRM_UNLOCKED),
 };
 
 #define DRM_CORE_IOCTL_COUNTARRAY_SIZE( drm_ioctls )
diff --git a/include/drm/drm.h b/include/drm/drm.h
index e51035a..b179169 100644
--- a/include/drm/drm.h
+++ b/include/drm/drm.h
< at >< at > -732,6 +732,7 < at >< at > struct drm_prime_handle {
 #define DRM_IOCTL_MODE_ADDFB2DRM_IOWR(0xB8, struct drm_mode_fb_cmd2)
 #define DRM_IOCTL_MODE_OBJ_GETPROPERTIESDRM_IOWR(0xB9, struct drm_mode_obj_get_properties)
 #define DRM_IOCTL_MODE_OBJ_SETPROPERTYDRM_IOWR(0xBA, struct drm_mode_obj_set_property)
+#define DRM_IOCTL_MODE_ATOMICDRM_IOWR(0xBB, struct drm_mode_atomic)
 
 /**
  * Device specific ioctls should only be in their respective headers
diff --git a/include/drm/drmP.h b/include/drm/drmP.h
index 31ad880..7bff96d 100644
--- a/include/drm/drmP.h
+++ b/include/drm/drmP.h
< at >< at > -964,6 +964,8 < at >< at > struct drm_driver {
 
 /* List of devices hanging off this driver */
 struct list_head device_list;
+
+const struct drm_atomic_funcs *atomic_funcs;
 };
 
 #define DRM_MINOR_UNASSIGNED 0
diff --git a/include/drm/drm_crtc.h b/include/drm/drm_crtc.h
index 8b1f173..b3d6545 100644
--- a/include/drm/drm_crtc.h
+++ b/include/drm/drm_crtc.h
< at >< at > -1063,6 +1063,8 < at >< at > extern int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data,
      struct drm_file *file_priv);
 extern int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data,
    struct drm_file *file_priv);
+extern int drm_mode_atomic_ioctl(struct drm_device *dev,
+ void *data, struct drm_file *file_priv);
 
 extern void drm_fb_get_bpp_depth(uint32_t format, unsigned int *depth,
  int *bpp);
< at >< at > -1099,4 +1101,14 < at >< at > extern int drm_calc_hscale(struct drm_region *src, struct drm_region *dst,
 extern int drm_calc_vscale(struct drm_region *src, struct drm_region *dst,
    int min_vscale, int max_vscale);
 
+struct drm_atomic_funcs {
+void *(*begin)(struct drm_device *dev, uint32_t flags);
+int (*set)(struct drm_device *dev, void *state,
+   struct drm_mode_object *obj, struct drm_property *prop,
+   uint64_t value, void *blob_data);
+int (*check)(struct drm_device *dev, void *state);
+int (*commit)(struct drm_device *dev, void *state);
+void (*end)(struct drm_device *dev, void *state);
+};
+
 #endif /* __DRM_CRTC_H__ */
diff --git a/include/drm/drm_mode.h b/include/drm/drm_mode.h
index 5581980..ed776b4 100644
--- a/include/drm/drm_mode.h
+++ b/include/drm/drm_mode.h
< at >< at > -459,4 +459,18 < at >< at > struct drm_mode_destroy_dumb {
 uint32_t handle;
 };
 
+
+#define DRM_ATOMIC_TEST_ONLY (1<<0)
+
+/* FIXME come up with some sane error reporting mechanism? */
+struct drm_mode_atomic {
+__u32 flags;
+__u32 count_objs;
+__u64 objs_ptr;
+__u64 count_props_ptr;
+__u64 props_ptr;
+__u64 prop_values_ptr;
+__u64 blob_values_ptr;
+};
+
 #endif

[RFC][PATCH 3/6] drm: Allow drm_mode_object_find() to look up anobject of any type

2012-05-24T20:16:44

From: Ville Syrjälä <ville.syrjala< at >linux.intel.com>

To avoid having to pass object types from userspace for atomic mode
setting ioctl, allow drm_mode_object_find() to look up an object of any
type. This will only work as long as the all object types share the ID
space.

Signed-off-by: Ville Syrjälä <ville.syrjala< at >linux.intel.com>
---
 drivers/gpu/drm/drm_crtc.c |    3 ++-
 include/drm/drm_crtc.h     |    1 +
 2 files changed, 3 insertions(+), 1 deletions(-)

diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c
index cc18ae6..9945e4b 100644
--- a/drivers/gpu/drm/drm_crtc.c
+++ b/drivers/gpu/drm/drm_crtc.c
< at >< at > -268,7 +268,8 < at >< at > struct drm_mode_object *drm_mode_object_find(struct drm_device *dev,
 
 mutex_lock(&dev->mode_config.idr_mutex);
 obj = idr_find(&dev->mode_config.crtc_idr, id);
-if (!obj || (obj->type != type) || (obj->id != id))
+if (!obj || (type != DRM_MODE_OBJECT_ANY && obj->type != type) ||
+    (obj->id != id))
 obj = NULL;
 mutex_unlock(&dev->mode_config.idr_mutex);
 
diff --git a/include/drm/drm_crtc.h b/include/drm/drm_crtc.h
index 70554c3..8b1f173 100644
--- a/include/drm/drm_crtc.h
+++ b/include/drm/drm_crtc.h
< at >< at > -47,6 +47,7 < at >< at > struct drm_object_properties;
 #define DRM_MODE_OBJECT_FB 0xfbfbfbfb
 #define DRM_MODE_OBJECT_BLOB 0xbbbbbbbb
 #define DRM_MODE_OBJECT_PLANE 0xeeeeeeee
+#define DRM_MODE_OBJECT_ANY 0
 
 struct drm_mode_object {
 uint32_t id;

[RFC][PATCH 4/6] drm: Refactor object property check code

2012-05-24T20:16:45

From: Ville Syrjälä <ville.syrjala< at >linux.intel.com>

Refactor the code to check whether an object has a specific property
to a new function.

Signed-off-by: Ville Syrjälä <ville.syrjala< at >linux.intel.com>
---
 drivers/gpu/drm/drm_crtc.c |   20 ++++++++++++++------
 1 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c
index 9945e4b..958a4b0 100644
--- a/drivers/gpu/drm/drm_crtc.c
+++ b/drivers/gpu/drm/drm_crtc.c
< at >< at > -3301,6 +3301,19 < at >< at > out:
 return ret;
 }
 
+static bool object_has_prop(const struct drm_mode_object *obj, u32 prop_id)
+{
+int i;
+
+if (!obj->properties)
+return false;
+
+for (i = 0; i < obj->properties->count; i++)
+if (obj->properties->ids[i] == prop_id)
+return true;
+return false;
+}
+
 int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data,
     struct drm_file *file_priv)
 {
< at >< at > -3309,7 +3322,6 < at >< at > int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data,
 struct drm_mode_object *prop_obj;
 struct drm_property *property;
 int ret = -EINVAL;
-int i;
 
 if (!drm_core_check_feature(dev, DRIVER_MODESET))
 return -EINVAL;
< at >< at > -3322,11 +3334,7 < at >< at > int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data,
 if (!arg_obj->properties)
 goto out;
 
-for (i = 0; i < arg_obj->properties->count; i++)
-if (arg_obj->properties->ids[i] == arg->prop_id)
-break;
-
-if (i == arg_obj->properties->count)
+if (!object_has_prop(arg_obj, arg->prop_id))
 goto out;
 
 prop_obj = drm_mode_object_find(dev, arg->prop_id,

[RFC][PATCH 2/6] drm: Allow signed values for range properties

2012-05-24T20:16:43

From: Ville Syrjälä <ville.syrjala< at >linux.intel.com>

Treat a range property as signed when the unsigned minimum value is
larger than the unsigned maximum value.

Signed-off-by: Ville Syrjälä <ville.syrjala< at >linux.intel.com>
---
 drivers/gpu/drm/drm_crtc.c |   17 ++++++++++++++---
 1 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c
index ce0f446..cc18ae6 100644
--- a/drivers/gpu/drm/drm_crtc.c
+++ b/drivers/gpu/drm/drm_crtc.c
< at >< at > -3143,14 +3143,25 < at >< at > int drm_mode_connector_update_edid_property(struct drm_connector *connector,
 }
 EXPORT_SYMBOL(drm_mode_connector_update_edid_property);
 
-static bool drm_property_change_is_valid(struct drm_property *property,
+static bool range_property_is_signed(const struct drm_property *property)
+{
+return property->values[0] > property->values[1];
+}
+
+static bool drm_property_change_is_valid(const struct drm_property *property,
  uint64_t value)
 {
 if (property->flags & DRM_MODE_PROP_IMMUTABLE)
 return false;
 if (property->flags & DRM_MODE_PROP_RANGE) {
-if (value < property->values[0] || value > property->values[1])
-return false;
+if (range_property_is_signed(property)) {
+if ((int64_t)value < (int64_t)property->values[0] ||
+    (int64_t)value > (int64_t)property->values[1])
+return false;
+} else {
+if (value < property->values[0] || value > property->values[1])
+return false;
+}
 return true;
 } else if (property->flags & DRM_MODE_PROP_BITMASK) {
 int i;

[RFC][PATCH 1/6] drm: Export drm_property_create_blob() anddrm_property_destroy_blob()

2012-05-24T20:16:42

From: Ville Syrjälä <ville.syrjala< at >linux.intel.com>

Signed-off-by: Ville Syrjälä <ville.syrjala< at >linux.intel.com>
---
 drivers/gpu/drm/drm_crtc.c |    8 +++++---
 include/drm/drm_crtc.h     |    4 ++++
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c
index 6dafb99..ce0f446 100644
--- a/drivers/gpu/drm/drm_crtc.c
+++ b/drivers/gpu/drm/drm_crtc.c
< at >< at > -3044,8 +3044,8 < at >< at > done:
 return ret;
 }
 
-static struct drm_property_blob *drm_property_create_blob(struct drm_device *dev, int length,
-  void *data)
+struct drm_property_blob *drm_property_create_blob(struct drm_device *dev, int length,
+   void *data)
 {
 struct drm_property_blob *blob;
 int ret;
< at >< at > -3070,14 +3070,16 < at >< at > static struct drm_property_blob *drm_property_create_blob(struct drm_device *dev
 list_add_tail(&blob->head, &dev->mode_config.property_blob_list);
 return blob;
 }
+EXPORT_SYMBOL(drm_property_create_blob);
 
-static void drm_property_destroy_blob(struct drm_device *dev,
+void drm_property_destroy_blob(struct drm_device *dev,
        struct drm_property_blob *blob)
 {
 drm_mode_object_put(dev, &blob->base);
 list_del(&blob->head);
 kfree(blob);
 }
+EXPORT_SYMBOL(drm_property_destroy_blob);
 
 int drm_mode_getblob_ioctl(struct drm_device *dev,
    void *data, struct drm_file *file_priv)
diff --git a/include/drm/drm_crtc.h b/include/drm/drm_crtc.h
index 3261492..70554c3 100644
--- a/include/drm/drm_crtc.h
+++ b/include/drm/drm_crtc.h
< at >< at > -952,6 +952,10 < at >< at > struct drm_property *drm_property_create_range(struct drm_device *dev, int flags
  const char *name,
  uint64_t min, uint64_t max);
 extern void drm_property_destroy(struct drm_device *dev, struct drm_property *property);
+extern struct drm_property_blob *drm_property_create_blob(struct drm_device *dev,
+  int length, void *data);
+extern void drm_property_destroy_blob(struct drm_device *dev,
+      struct drm_property_blob *blob);
 extern int drm_property_add_enum(struct drm_property *property, int index,
  uint64_t value, const char *name);
 extern int drm_mode_create_dvi_i_properties(struct drm_device *dev);

[RFC][PATCH 0/6] WIP: drm: Atomic mode setting idea

2012-05-24T20:16:41

This is some very early demo code for the atomic modesetting feature.

According to my current plan there would be just one ioctl. You simply feed
it an arbitrary list of object properties and the implementation will decice
how it can apply those (for example, whether it can complete the operation
truly atomically and/or asynchronously). So everything is a property. This
means the ioctl should be able to handle all future requirements just as
long as they can be expressed using properties that fit the current model.

In order to be able to feed connector lists, gamma tables, etc. the ioctl has
to accepts blobs. Just one blob per property for now. Not sure if that would be
enough. I also extended range propeties to support signed values.

The implementation has to provide five function pointers, and the
operation goes roughly like this:

ioctl() {
 funcs->begin
 for_each_prop
 funcs->set
 funcs->check
 if (!check_only)
 funcs->commit
 funcs->end
}

The begin function allocates some kind of state object that will be used to
collect all the modified state from all the properties. The approach I used
in the demo implementation is to have the full state contained in the state
object, and then keep modifying it according to the new property values.
Finally the whole state gets checked as an atomic unit, and commited to
hardware if everything is OK.

The demo implementation I included does work, albeit not atomically and it
doesn't actually do any real state checking. It just calls the pre-existing
crtc helper and plane funcs from the commit hook.


I'm still pondering about the error reporting. One crazy idea would be to
return an error value for each modified property. That way the driver could
more accurately inform user space why the state is invalid.


Another missing thing is the completion event support. I'm thinking it
should perhaps just contain one timestamp, that being for the time when
the whole operation has completed. If the user wants accurate per-CRTC
timestamps he'd have to issue separate ioctls. The other approach would
be per-object timestamps. Or should it perhaps send out a separate event
for each modified object?

Also it would be nice if the completion event would contain a list of
framebuffer objects that became available when the operation completed.
That would be useful for triple buffering use, since you can't tell
beforehand which framebuffer gets replaced with the new one when you
issue flips faster than the refresh rate.

Some kind of event cookie could also be nice to have, to associate
each event with the ioctl request that spawned it.

Re: [PATCH 0/4] drm/i915: Make video sprites survive a modeset

Ville Syrjälä — 2012-05-24T19:34:26

Mainly I just dislike incoherent behaviour.

One use case might be flipping to another framebuffer using the
setcrtc ioctl, in case the page flip ioctl isn't provided, or can't
be used. With the current code the result depends on various
implementation specific details like whether the driver implements
a set_base type of optimization in a certain way. From the user
space POV it's just a setcrtc ioctl, but there's no sensible way
to know whether the operation will destroy some unrelated state
or not.