sungmg/mutter-performance-source
1
0
Fork 0
Code Activity

backends: Split out CRTC/output management to MetaGpu

Browse source 
In order to eventually support multilpe GPUs with their own connectors,
split out related meta data management (i.e. outputs, CRTCs and CRTC
modes) into a new MetaGpu GObject.

The Xrandr backend always assumes there is always only a single "GPU" as
the GPU is abstracted by the X server; only the native backend (aside
from the test backend) will eventually see more than one GPU.

The Xrandr backend still moves some management to MetaGpuXrandr, in
order to behave more similarly to the KMS counterparts.

https://bugzilla.gnome.org/show_bug.cgi?id=785381
This commit is contained in:
Jonas Ådahl 2017-07-10 18:19:32 +08:00
parent 18ec86bd90
commit c1683073f1
36 changed files with 2397 additions and 1414 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
src/Makefile.am
View file

@ -109,6 +109,8 @@ libmutter_@LIBMUTTER_API_VERSION@_la_SOURCES = \
backends/meta-egl.c \
backends/meta-egl.h \
backends/meta-egl-ext.h \
backends/meta-gpu.c \
backends/meta-gpu.h \
backends/meta-display-config-shared.h \
backends/meta-idle-monitor.c \
backends/meta-idle-monitor-private.h \
@ -157,6 +159,8 @@ libmutter_@LIBMUTTER_API_VERSION@_la_SOURCES = \
backends/x11/meta-crtc-xrandr.h \
backends/x11/meta-cursor-renderer-x11.c \
backends/x11/meta-cursor-renderer-x11.h \
backends/x11/meta-gpu-xrandr.c \
backends/x11/meta-gpu-xrandr.h \
backends/x11/cm/meta-backend-x11-cm.c \
backends/x11/cm/meta-backend-x11-cm.h \
backends/x11/cm/meta-renderer-x11-cm.c \
@ -455,6 +459,8 @@ libmutter_@LIBMUTTER_API_VERSION@_la_SOURCES += \
backends/native/meta-cursor-renderer-native.c \
backends/native/meta-cursor-renderer-native.h \
backends/native/meta-default-modes.h \
backends/native/meta-gpu-kms.c \
backends/native/meta-gpu-kms.h \
backends/native/meta-idle-monitor-native.c \
backends/native/meta-idle-monitor-native.h \
backends/native/meta-input-settings-native.c \

6
src/backends/meta-crtc.c
View file

@ -25,10 +25,10 @@ G_DEFINE_TYPE (MetaCrtc, meta_crtc, G_TYPE_OBJECT)
G_DEFINE_TYPE (MetaCrtcMode, meta_crtc_mode, G_TYPE_OBJECT)
MetaMonitorManager *
meta_crtc_get_monitor_manager (MetaCrtc *crtc)
MetaGpu *
meta_crtc_get_gpu (MetaCrtc *crtc)
{
return crtc->monitor_manager;
return crtc->gpu;
}
static void

6
src/backends/meta-crtc.h
View file

@ -22,7 +22,7 @@
#include <glib-object.h>
#include "backends/meta-monitor-manager-private.h"
#include "backends/meta-gpu.h"
/* Same as KMS mode flags and X11 randr flags */
typedef enum _MetaCrtcModeFlag
@ -50,7 +50,7 @@ struct _MetaCrtc
{
GObject parent;
MetaMonitorManager *monitor_manager;
MetaGpu *gpu;
glong crtc_id;
MetaRectangle rect;
@ -93,6 +93,6 @@ G_DECLARE_FINAL_TYPE (MetaCrtc, meta_crtc, META, CRTC, GObject)
#define META_TYPE_CRTC_MODE (meta_crtc_mode_get_type ())
G_DECLARE_FINAL_TYPE (MetaCrtcMode, meta_crtc_mode, META, CRTC_MODE, GObject)
MetaMonitorManager * meta_crtc_get_monitor_manager (MetaCrtc *crtc);
MetaGpu * meta_crtc_get_gpu (MetaCrtc *crtc);
#endif /* META_CRTC_H */

224
src/backends/meta-gpu.c Normal file
View file

@ -0,0 +1,224 @@
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/*
* Copyright (C) 2017 Red Hat
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*/
#include "config.h"
#include "backends/meta-gpu.h"
#include "backends/meta-output.h"
enum
{
PROP_0,
PROP_MONITOR_MANAGER,
PROP_LAST
};
static GParamSpec *obj_props[PROP_LAST];
typedef struct _MetaGpuPrivate
{
MetaMonitorManager *monitor_manager;
GList *outputs;
GList *crtcs;
GList *modes;
} MetaGpuPrivate;
G_DEFINE_TYPE_WITH_PRIVATE (MetaGpu, meta_gpu, G_TYPE_OBJECT)
gboolean
meta_gpu_has_hotplug_mode_update (MetaGpu *gpu)
{
MetaGpuPrivate *priv = meta_gpu_get_instance_private (gpu);
GList *l;
for (l = priv->outputs; l; l = l->next)
{
MetaOutput *output = l->data;
if (output->hotplug_mode_update)
return TRUE;
}
return FALSE;
}
gboolean
meta_gpu_read_current (MetaGpu *gpu,
GError **error)
{
MetaGpuPrivate *priv = meta_gpu_get_instance_private (gpu);
gboolean ret;
GList *old_outputs;
GList *old_crtcs;
GList *old_modes;
/* TODO: Get rid of this when objects incref:s what they need instead */
old_outputs = priv->outputs;
old_crtcs = priv->crtcs;
old_modes = priv->modes;
ret = META_GPU_GET_CLASS (gpu)->read_current (gpu, error);
g_list_free_full (old_outputs, g_object_unref);
g_list_free_full (old_modes, g_object_unref);
g_list_free_full (old_crtcs, g_object_unref);
return ret;
}
MetaMonitorManager *
meta_gpu_get_monitor_manager (MetaGpu *gpu)
{
MetaGpuPrivate *priv = meta_gpu_get_instance_private (gpu);
return priv->monitor_manager;
}
GList *
meta_gpu_get_outputs (MetaGpu *gpu)
{
MetaGpuPrivate *priv = meta_gpu_get_instance_private (gpu);
return priv->outputs;
}
GList *
meta_gpu_get_crtcs (MetaGpu *gpu)
{
MetaGpuPrivate *priv = meta_gpu_get_instance_private (gpu);
return priv->crtcs;
}
GList *
meta_gpu_get_modes (MetaGpu *gpu)
{
MetaGpuPrivate *priv = meta_gpu_get_instance_private (gpu);
return priv->modes;
}
void
meta_gpu_take_outputs (MetaGpu *gpu,
GList *outputs)
{
MetaGpuPrivate *priv = meta_gpu_get_instance_private (gpu);
priv->outputs = outputs;
}
void
meta_gpu_take_crtcs (MetaGpu *gpu,
GList *crtcs)
{
MetaGpuPrivate *priv = meta_gpu_get_instance_private (gpu);
priv->crtcs = crtcs;
}
void
meta_gpu_take_modes (MetaGpu *gpu,
GList *modes)
{
MetaGpuPrivate *priv = meta_gpu_get_instance_private (gpu);
priv->modes = modes;
}
static void
meta_gpu_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
MetaGpu *gpu = META_GPU (object);
MetaGpuPrivate *priv = meta_gpu_get_instance_private (gpu);
switch (prop_id)
{
case PROP_MONITOR_MANAGER:
priv->monitor_manager = g_value_get_object (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
meta_gpu_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
MetaGpu *gpu = META_GPU (object);
MetaGpuPrivate *priv = meta_gpu_get_instance_private (gpu);
switch (prop_id)
{
case PROP_MONITOR_MANAGER:
g_value_set_object (value, priv->monitor_manager);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
meta_gpu_finalize (GObject *object)
{
MetaGpu *gpu = META_GPU (object);
MetaGpuPrivate *priv = meta_gpu_get_instance_private (gpu);
g_list_free_full (priv->outputs, g_object_unref);
g_list_free_full (priv->modes, g_object_unref);
g_list_free_full (priv->crtcs, g_object_unref);
G_OBJECT_CLASS (meta_gpu_parent_class)->finalize (object);
}
static void
meta_gpu_init (MetaGpu *gpu)
{
}
static void
meta_gpu_class_init (MetaGpuClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->set_property = meta_gpu_set_property;
object_class->get_property = meta_gpu_get_property;
object_class->finalize = meta_gpu_finalize;
obj_props[PROP_MONITOR_MANAGER] =
g_param_spec_object ("monitor-manager",
"monitor-manager",
"MetaMonitorManager",
META_TYPE_MONITOR_MANAGER,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS);
g_object_class_install_properties (object_class, PROP_LAST, obj_props);
}

66
src/backends/meta-gpu.h Normal file
View file

@ -0,0 +1,66 @@
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/*
* Copyright (C) 2017 Red Hat
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*/
#ifndef META_GPU_H
#define META_GPU_H
#include <glib-object.h>
#include "backends/meta-monitor-manager-private.h"
#define META_TYPE_GPU (meta_gpu_get_type ())
G_DECLARE_DERIVABLE_TYPE (MetaGpu, meta_gpu, META, GPU, GObject)
struct _MetaGpuClass
{
GObjectClass parent_class;
gboolean (* read_current) (MetaGpu *gpu,
GError **error);
};
int meta_gpu_get_kms_fd (MetaGpu *gpu);
const char * meta_gpu_get_kms_file_path (MetaGpu *gpu);
gboolean meta_gpu_read_current (MetaGpu *gpu,
GError **error);
gboolean meta_gpu_has_hotplug_mode_update (MetaGpu *gpu);
MetaMonitorManager * meta_gpu_get_monitor_manager (MetaGpu *gpu);
GList * meta_gpu_get_outputs (MetaGpu *gpu);
GList * meta_gpu_get_crtcs (MetaGpu *gpu);
GList * meta_gpu_get_modes (MetaGpu *gpu);
void meta_gpu_take_outputs (MetaGpu *gpu,
GList *outputs);
void meta_gpu_take_crtcs (MetaGpu *gpu,
GList *crtcs);
void meta_gpu_take_modes (MetaGpu *gpu,
GList *modes);
#endif /* META_GPU_H */

69
src/backends/meta-monitor-manager-dummy.c
View file

@ -47,6 +47,8 @@ struct _MetaMonitorManagerDummy
{
MetaMonitorManager parent_instance;
MetaGpu *gpu;
gboolean is_transform_handled;
};
@ -62,6 +64,13 @@ typedef struct _MetaOutputDummy
G_DEFINE_TYPE (MetaMonitorManagerDummy, meta_monitor_manager_dummy, META_TYPE_MONITOR_MANAGER);
struct _MetaGpuDummy
{
MetaGpu parent;
};
G_DEFINE_TYPE (MetaGpuDummy, meta_gpu_dummy, META_TYPE_GPU)
static void
meta_output_dummy_notify_destroy (MetaOutput *output);
@ -95,6 +104,8 @@ append_monitor (MetaMonitorManager *manager,
GList **outputs,
float scale)
{
MetaMonitorManagerDummy *manager_dummy = META_MONITOR_MANAGER_DUMMY (manager);
MetaGpu *gpu = manager_dummy->gpu;
CrtcModeSpec mode_specs[] = {
{
.width = 800,
@ -141,7 +152,7 @@ append_monitor (MetaMonitorManager *manager,
number = g_list_length (*outputs) + 1;
output->monitor_manager = manager;
output->gpu = gpu;
output->winsys_id = number;
output->name = g_strdup_printf ("LVDS%d", number);
output->vendor = g_strdup ("MetaProducts Inc.");
@ -182,6 +193,8 @@ append_tiled_monitor (MetaMonitorManager *manager,
GList **outputs,
int scale)
{
MetaMonitorManagerDummy *manager_dummy = META_MONITOR_MANAGER_DUMMY (manager);
MetaGpu *gpu = manager_dummy->gpu;
CrtcModeSpec mode_specs[] = {
{
.width = 800,
@ -218,7 +231,7 @@ append_tiled_monitor (MetaMonitorManager *manager,
MetaCrtc *crtc;
crtc = g_object_new (META_TYPE_CRTC, NULL);
crtc->monitor_manager = manager;
crtc->gpu = gpu;
crtc->crtc_id = g_list_length (*crtcs) + i + 1;
crtc->all_transforms = ALL_TRANSFORMS;
new_crtcs = g_list_append (new_crtcs, crtc);
@ -246,7 +259,7 @@ append_tiled_monitor (MetaMonitorManager *manager,
output = g_object_new (META_TYPE_OUTPUT, NULL);
output->monitor_manager = manager;
output->gpu = gpu;
output->winsys_id = number;
output->name = g_strdup_printf ("LVDS%d", number);
output->vendor = g_strdup ("MetaProducts Inc.");
@ -305,6 +318,8 @@ meta_output_dummy_notify_destroy (MetaOutput *output)
static void
meta_monitor_manager_dummy_read_current (MetaMonitorManager *manager)
{
MetaMonitorManagerDummy *manager_dummy = META_MONITOR_MANAGER_DUMMY (manager);
MetaGpu *gpu = manager_dummy->gpu;
unsigned int num_monitors = 1;
float *monitor_scales = NULL;
const char *num_monitors_str;
@ -396,9 +411,9 @@ meta_monitor_manager_dummy_read_current (MetaMonitorManager *manager)
append_monitor (manager, &modes, &crtcs, &outputs, monitor_scales[i]);
}
manager->modes = modes;
manager->crtcs = crtcs;
manager->outputs = outputs;
meta_gpu_take_modes (gpu, modes);
meta_gpu_take_crtcs (gpu, crtcs);
meta_gpu_take_outputs (gpu, outputs);
}
static void
@ -421,6 +436,7 @@ apply_crtc_assignments (MetaMonitorManager *manager,
MetaOutputInfo **outputs,
unsigned int n_outputs)
{
MetaMonitorManagerDummy *manager_dummy = META_MONITOR_MANAGER_DUMMY (manager);
GList *l;
unsigned i;
@ -485,7 +501,7 @@ apply_crtc_assignments (MetaMonitorManager *manager,
}
/* Disable CRTCs not mentioned in the list */
for (l = manager->crtcs; l; l = l->next)
for (l = meta_gpu_get_crtcs (manager_dummy->gpu); l; l = l->next)
{
MetaCrtc *crtc = l->data;
@ -505,7 +521,7 @@ apply_crtc_assignments (MetaMonitorManager *manager,
}
/* Disable outputs not mentioned in the list */
for (l = manager->outputs; l; l = l->next)
for (l = meta_gpu_get_outputs (manager_dummy->gpu); l; l = l->next)
{
MetaOutput *output = l->data;
@ -702,7 +718,6 @@ meta_monitor_manager_dummy_class_init (MetaMonitorManagerDummyClass *klass)
{
MetaMonitorManagerClass *manager_class = META_MONITOR_MANAGER_CLASS (klass);
manager_class->read_current = meta_monitor_manager_dummy_read_current;
manager_class->ensure_initial_config = meta_monitor_manager_dummy_ensure_initial_config;
manager_class->apply_monitors_config = meta_monitor_manager_dummy_apply_monitors_config;
manager_class->is_transform_handled = meta_monitor_manager_dummy_is_transform_handled;
@ -714,14 +729,44 @@ meta_monitor_manager_dummy_class_init (MetaMonitorManagerDummyClass *klass)
}
static void
meta_monitor_manager_dummy_init (MetaMonitorManagerDummy *manager)
meta_monitor_manager_dummy_init (MetaMonitorManagerDummy *manager_dummy)
{
MetaMonitorManager *manager = META_MONITOR_MANAGER (manager_dummy);
const char *nested_offscreen_transform;
nested_offscreen_transform =
g_getenv ("MUTTER_DEBUG_NESTED_OFFSCREEN_TRANSFORM");
if (g_strcmp0 (nested_offscreen_transform, "1") == 0)
manager->is_transform_handled = FALSE;
manager_dummy->is_transform_handled = FALSE;
else
manager->is_transform_handled = TRUE;
manager_dummy->is_transform_handled = TRUE;
manager_dummy->gpu = g_object_new (META_TYPE_GPU_DUMMY,
"monitor-manager", manager,
NULL);
meta_monitor_manager_add_gpu (manager, manager_dummy->gpu);
}
static gboolean
meta_gpu_dummy_read_current (MetaGpu *gpu,
GError **error)
{
MetaMonitorManager *manager = meta_gpu_get_monitor_manager (gpu);
meta_monitor_manager_dummy_read_current (manager);
return TRUE;
}
static void
meta_gpu_dummy_init (MetaGpuDummy *gpu_dummy)
{
}
static void
meta_gpu_dummy_class_init (MetaGpuDummyClass *klass)
{
MetaGpuClass *gpu_class = META_GPU_CLASS (klass);
gpu_class->read_current = meta_gpu_dummy_read_current;
}

4
src/backends/meta-monitor-manager-dummy.h
View file

@ -24,9 +24,13 @@
#define META_MONITOR_MANAGER_DUMMY_H
#include "meta-monitor-manager-private.h"
#include "backends/meta-gpu.h"
#define META_TYPE_MONITOR_MANAGER_DUMMY (meta_monitor_manager_dummy_get_type ())
G_DECLARE_FINAL_TYPE (MetaMonitorManagerDummy, meta_monitor_manager_dummy,
META, MONITOR_MANAGER_DUMMY, MetaMonitorManager)
#define META_TYPE_GPU_DUMMY (meta_gpu_dummy_get_type ())
G_DECLARE_FINAL_TYPE (MetaGpuDummy, meta_gpu_dummy, META, GPU_DUMMY, MetaGpu)
#endif /* META_MONITOR_MANAGER_DUMMY_H */

18
src/backends/meta-monitor-manager-private.h
View file

@ -60,6 +60,8 @@ typedef struct _MetaLogicalMonitor MetaLogicalMonitor;
typedef struct _MetaMonitorMode MetaMonitorMode;
typedef struct _MetaGpu MetaGpu;
typedef struct _MetaCrtc MetaCrtc;
typedef struct _MetaOutput MetaOutput;
typedef struct _MetaCrtcMode MetaCrtcMode;
@ -164,14 +166,7 @@ struct _MetaMonitorManager
int screen_width;
int screen_height;
/* Outputs refer to physical screens,
CRTCs refer to stuff that can drive outputs
(like encoders, but less tied to the HW),
while logical_monitors refer to logical ones.
*/
GList *outputs;
GList *crtcs;
GList *modes;
GList *gpus;
GList *monitors;
@ -196,8 +191,6 @@ struct _MetaMonitorManagerClass
{
MetaDBusDisplayConfigSkeletonClass parent_class;
void (*read_current) (MetaMonitorManager *);
char* (*get_edid_file) (MetaMonitorManager *,
MetaOutput *);
GBytes* (*read_edid) (MetaMonitorManager *,
@ -302,9 +295,10 @@ MetaMonitor * meta_monitor_manager_get_monitor_from_connector (MetaMonitor
GList * meta_monitor_manager_get_monitors (MetaMonitorManager *manager);
GList * meta_monitor_manager_get_outputs (MetaMonitorManager *manager);
void meta_monitor_manager_add_gpu (MetaMonitorManager *manager,
MetaGpu *gpu);
GList * meta_monitor_manager_get_crtcs (MetaMonitorManager *manager);
GList * meta_monitor_manager_get_gpus (MetaMonitorManager *manager);
void meta_monitor_manager_get_screen_size (MetaMonitorManager *manager,
int *width,

156
src/backends/meta-monitor-manager.c
View file

@ -467,11 +467,11 @@ meta_monitor_manager_has_hotplug_mode_update (MetaMonitorManager *manager)
{
GList *l;
for (l = manager->outputs; l; l = l->next)
for (l = manager->gpus; l; l = l->next)
{
MetaOutput *output = l->data;
MetaGpu *gpu = l->data;
if (output->hotplug_mode_update)
if (meta_gpu_has_hotplug_mode_update (gpu))
return TRUE;
}
@ -747,9 +747,7 @@ meta_monitor_manager_finalize (GObject *object)
{
MetaMonitorManager *manager = META_MONITOR_MANAGER (object);
g_list_free_full (manager->outputs, g_object_unref);
g_list_free_full (manager->modes, g_object_unref);
g_list_free_full (manager->crtcs, g_object_unref);
g_list_free_full (manager->gpus, g_object_unref);
g_list_free_full (manager->logical_monitors, g_object_unref);
g_signal_handler_disconnect (manager->backend,
@ -957,23 +955,47 @@ get_connector_type_name (MetaConnectorType connector_type)
}
}
static GList *
combine_gpu_lists (MetaMonitorManager *manager,
GList * (*list_getter) (MetaGpu *gpu))
{
GList *list = NULL;
GList *l;
for (l = manager->gpus; l; l = l->next)
{
MetaGpu *gpu = l->data;
list = g_list_concat (list, g_list_copy (list_getter (gpu)));
}
return list;
}
static gboolean
meta_monitor_manager_handle_get_resources (MetaDBusDisplayConfig *skeleton,
GDBusMethodInvocation *invocation)
{
MetaMonitorManager *manager = META_MONITOR_MANAGER (skeleton);
MetaMonitorManagerClass *manager_class = META_MONITOR_MANAGER_GET_CLASS (skeleton);
GList *combined_modes;
GList *combined_outputs;
GList *combined_crtcs;
GVariantBuilder crtc_builder, output_builder, mode_builder;
GList *l;
unsigned int i, j;
int max_screen_width;
int max_screen_height;
combined_modes = combine_gpu_lists (manager, meta_gpu_get_modes);
combined_outputs = combine_gpu_lists (manager, meta_gpu_get_outputs);
combined_crtcs = combine_gpu_lists (manager, meta_gpu_get_crtcs);
g_variant_builder_init (&crtc_builder, G_VARIANT_TYPE ("a(uxiiiiiuaua{sv})"));
g_variant_builder_init (&output_builder, G_VARIANT_TYPE ("a(uxiausauaua{sv})"));
g_variant_builder_init (&mode_builder, G_VARIANT_TYPE ("a(uxuudu)"));
for (l = manager->crtcs, i = 0; l; l = l->next, i++)
for (l = combined_crtcs, i = 0; l; l = l->next, i++)
{
MetaCrtc *crtc = l->data;
GVariantBuilder transforms;
@ -985,7 +1007,7 @@ meta_monitor_manager_handle_get_resources (MetaDBusDisplayConfig *skeleton,
g_variant_builder_add (&transforms, "u", j);
if (crtc->current_mode)
current_mode_index = g_list_index (manager->modes, crtc->current_mode);
current_mode_index = g_list_index (combined_modes, crtc->current_mode);
else
current_mode_index = -1;
g_variant_builder_add (&crtc_builder, "(uxiiiiiuaua{sv})",
@ -1001,7 +1023,7 @@ meta_monitor_manager_handle_get_resources (MetaDBusDisplayConfig *skeleton,
NULL /* properties */);
}
for (l = manager->outputs; l; l = l->next)
for (l = combined_outputs; l; l = l->next)
{
MetaOutput *output = l->data;
GVariantBuilder crtcs, modes, clones, properties;
@ -1015,7 +1037,7 @@ meta_monitor_manager_handle_get_resources (MetaDBusDisplayConfig *skeleton,
MetaCrtc *possible_crtc = output->possible_crtcs[j];
unsigned possible_crtc_index;
possible_crtc_index = g_list_index (manager->crtcs, possible_crtc);
possible_crtc_index = g_list_index (combined_crtcs, possible_crtc);
g_variant_builder_add (&crtcs, "u", possible_crtc_index);
}
@ -1024,7 +1046,7 @@ meta_monitor_manager_handle_get_resources (MetaDBusDisplayConfig *skeleton,
{
unsigned mode_index;
mode_index = g_list_index (manager->modes, output->modes[j]);
mode_index = g_list_index (combined_modes, output->modes[j]);
g_variant_builder_add (&modes, "u", mode_index);
}
@ -1033,7 +1055,7 @@ meta_monitor_manager_handle_get_resources (MetaDBusDisplayConfig *skeleton,
{
unsigned int possible_clone_index;
possible_clone_index = g_list_index (manager->outputs,
possible_clone_index = g_list_index (combined_outputs,
output->possible_clones[j]);
g_variant_builder_add (&clones, "u", possible_clone_index);
}
@ -1100,7 +1122,7 @@ meta_monitor_manager_handle_get_resources (MetaDBusDisplayConfig *skeleton,
output->tile_info.tile_h));
}
crtc_index = output->crtc ? g_list_index (manager->crtcs, output->crtc)
crtc_index = output->crtc ? g_list_index (combined_crtcs, output->crtc)
: -1;
g_variant_builder_add (&output_builder, "(uxiausauaua{sv})",
i, /* ID */
@ -1113,7 +1135,7 @@ meta_monitor_manager_handle_get_resources (MetaDBusDisplayConfig *skeleton,
&properties);
}
for (l = manager->modes, i = 0; l; l = l->next, i++)
for (l = combined_modes, i = 0; l; l = l->next, i++)
{
MetaCrtcMode *mode = l->data;
@ -1143,6 +1165,11 @@ meta_monitor_manager_handle_get_resources (MetaDBusDisplayConfig *skeleton,
g_variant_builder_end (&mode_builder),
max_screen_width,
max_screen_height);
g_list_free (combined_modes);
g_list_free (combined_outputs);
g_list_free (combined_crtcs);
return TRUE;
}
@ -2042,6 +2069,7 @@ meta_monitor_manager_handle_change_backlight (MetaDBusDisplayConfig *skeleton,
gint value)
{
MetaMonitorManager *manager = META_MONITOR_MANAGER (skeleton);
GList *combined_outputs;
MetaOutput *output;
if (serial != manager->serial)
@ -2052,14 +2080,18 @@ meta_monitor_manager_handle_change_backlight (MetaDBusDisplayConfig *skeleton,
return TRUE;
}
if (output_index >= g_list_length (manager->outputs))
combined_outputs = combine_gpu_lists (manager, meta_gpu_get_outputs);
if (output_index >= g_list_length (combined_outputs))
{
g_list_free (combined_outputs);
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
G_DBUS_ERROR_INVALID_ARGS,
"Invalid output id");
return TRUE;
}
output = g_list_nth_data (manager->outputs, output_index);
output = g_list_nth_data (combined_outputs, output_index);
g_list_free (combined_outputs);
if (value < 0 || value > 100)
{
@ -2092,6 +2124,7 @@ meta_monitor_manager_handle_get_crtc_gamma (MetaDBusDisplayConfig *skeleton,
{
MetaMonitorManager *manager = META_MONITOR_MANAGER (skeleton);
MetaMonitorManagerClass *klass;
GList *combined_crtcs;
MetaCrtc *crtc;
gsize size;
unsigned short *red;
@ -2108,15 +2141,18 @@ meta_monitor_manager_handle_get_crtc_gamma (MetaDBusDisplayConfig *skeleton,
return TRUE;
}
if (crtc_id >= g_list_length (manager->crtcs))
combined_crtcs = combine_gpu_lists (manager, meta_gpu_get_crtcs);
if (crtc_id >= g_list_length (combined_crtcs))
{
g_list_free (combined_crtcs);
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
G_DBUS_ERROR_INVALID_ARGS,
"Invalid crtc id");
return TRUE;
}
crtc = g_list_nth_data (manager->crtcs, crtc_id);
crtc = g_list_nth_data (combined_crtcs, crtc_id);
g_list_free (combined_crtcs);
klass = META_MONITOR_MANAGER_GET_CLASS (manager);
if (klass->get_crtc_gamma)
@ -2156,6 +2192,7 @@ meta_monitor_manager_handle_set_crtc_gamma (MetaDBusDisplayConfig *skeleton,
{
MetaMonitorManager *manager = META_MONITOR_MANAGER (skeleton);
MetaMonitorManagerClass *klass;
GList *combined_crtcs;
MetaCrtc *crtc;
gsize size, dummy;
unsigned short *red;
@ -2171,15 +2208,19 @@ meta_monitor_manager_handle_set_crtc_gamma (MetaDBusDisplayConfig *skeleton,
return TRUE;
}
if (crtc_id >= g_list_length (manager->crtcs))
combined_crtcs = combine_gpu_lists (manager, meta_gpu_get_crtcs);
if (crtc_id >= g_list_length (combined_crtcs))
{
g_list_free (combined_crtcs);
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
G_DBUS_ERROR_INVALID_ARGS,
"Invalid crtc id");
return TRUE;
}
crtc = g_list_nth_data (manager->crtcs, crtc_id);
crtc = g_list_nth_data (combined_crtcs, crtc_id);
g_list_free (combined_crtcs);
red_bytes = g_variant_get_data_as_bytes (red_v);
green_bytes = g_variant_get_data_as_bytes (green_v);
@ -2449,16 +2490,17 @@ meta_monitor_manager_get_monitors (MetaMonitorManager *manager)
return manager->monitors;
}
GList *
meta_monitor_manager_get_outputs (MetaMonitorManager *manager)
void
meta_monitor_manager_add_gpu (MetaMonitorManager *manager,
MetaGpu *gpu)
{
return manager->outputs;
manager->gpus = g_list_append (manager->gpus, gpu);
}
GList *
meta_monitor_manager_get_crtcs (MetaMonitorManager *manager)
meta_monitor_manager_get_gpus (MetaMonitorManager *manager)
{
return manager->crtcs;
return manager->gpus;
}
void
@ -2481,28 +2523,34 @@ rebuild_monitors (MetaMonitorManager *manager)
manager->monitors = NULL;
}
for (l = manager->outputs; l; l = l->next)
for (l = manager->gpus; l; l = l->next)
{
MetaOutput *output = l->data;
MetaGpu *gpu = l->data;
GList *k;
if (output->tile_info.group_id)
for (k = meta_gpu_get_outputs (gpu); k; k = k->next)
{
if (is_main_tiled_monitor_output (output))
MetaOutput *output = k->data;
if (output->tile_info.group_id)
{
MetaMonitorTiled *monitor_tiled;
if (is_main_tiled_monitor_output (output))
{
MetaMonitorTiled *monitor_tiled;
monitor_tiled = meta_monitor_tiled_new (manager, output);
manager->monitors = g_list_append (manager->monitors,
monitor_tiled);
monitor_tiled = meta_monitor_tiled_new (gpu, output);
manager->monitors = g_list_append (manager->monitors,
monitor_tiled);
}
}
}
else
{
MetaMonitorNormal *monitor_normal;
else
{
MetaMonitorNormal *monitor_normal;
monitor_normal = meta_monitor_normal_new (manager, output);
manager->monitors = g_list_append (manager->monitors,
monitor_normal);
monitor_normal = meta_monitor_normal_new (gpu, output);
manager->monitors = g_list_append (manager->monitors,
monitor_normal);
}
}
}
}
@ -2543,25 +2591,23 @@ meta_monitor_manager_is_transform_handled (MetaMonitorManager *manager,
void
meta_monitor_manager_read_current_state (MetaMonitorManager *manager)
{
GList *old_outputs;
GList *old_crtcs;
GList *old_modes;
/* Some implementations of read_current use the existing information
* we have available, so don't free the old configuration until after
* read_current finishes. */
old_outputs = manager->outputs;
old_crtcs = manager->crtcs;
old_modes = manager->modes;
GList *l;
manager->serial++;
META_MONITOR_MANAGER_GET_CLASS (manager)->read_current (manager);
for (l = manager->gpus; l; l = l->next)
{
MetaGpu *gpu = l->data;
GError *error = NULL;
if (!meta_gpu_read_current (gpu, &error))
{
g_warning ("Failed to read current KMS state: %s", error->message);
g_clear_error (&error);
}
}
rebuild_monitors (manager);
g_list_free_full (old_outputs, g_object_unref);
g_list_free_full (old_modes, g_object_unref);
g_list_free_full (old_crtcs, g_object_unref);
}
static void

29
src/backends/meta-monitor.c
View file

@ -25,6 +25,7 @@
#include "backends/meta-backend-private.h"
#include "backends/meta-crtc.h"
#include "backends/meta-gpu.h"
#include "backends/meta-monitor-manager-private.h"
#include "backends/meta-settings-private.h"
#include "backends/meta-output.h"
@ -54,7 +55,7 @@ typedef struct _MetaMonitorModeTiled
typedef struct _MetaMonitorPrivate
{
MetaMonitorManager *monitor_manager;
MetaGpu *gpu;
GList *outputs;
GList *modes;
@ -450,8 +451,8 @@ meta_monitor_normal_generate_modes (MetaMonitorNormal *monitor_normal)
}
MetaMonitorNormal *
meta_monitor_normal_new (MetaMonitorManager *monitor_manager,
MetaOutput *output)
meta_monitor_normal_new (MetaGpu *gpu,
MetaOutput *output)
{
MetaMonitorNormal *monitor_normal;
MetaMonitor *monitor;
@ -461,7 +462,7 @@ meta_monitor_normal_new (MetaMonitorManager *monitor_manager,
monitor = META_MONITOR (monitor_normal);
monitor_priv = meta_monitor_get_instance_private (monitor);
monitor_priv->monitor_manager = monitor_manager;
monitor_priv->gpu = gpu;
monitor_priv->outputs = g_list_append (NULL, output);
monitor_priv->winsys_id = output->winsys_id;
@ -557,15 +558,15 @@ meta_monitor_get_suggested_position (MetaMonitor *monitor,
}
static void
add_tiled_monitor_outputs (MetaMonitorManager *monitor_manager,
MetaMonitorTiled *monitor_tiled)
add_tiled_monitor_outputs (MetaGpu *gpu,
MetaMonitorTiled *monitor_tiled)
{
MetaMonitorPrivate *monitor_priv =
meta_monitor_get_instance_private (META_MONITOR (monitor_tiled));
GList *outputs;
GList *l;
outputs = monitor_manager->outputs;
outputs = meta_gpu_get_outputs (gpu);
for (l = outputs; l; l = l->next)
{
MetaOutput *output = l->data;
@ -1084,9 +1085,10 @@ meta_monitor_tiled_generate_modes (MetaMonitorTiled *monitor_tiled)
}
MetaMonitorTiled *
meta_monitor_tiled_new (MetaMonitorManager *monitor_manager,
MetaOutput *output)
meta_monitor_tiled_new (MetaGpu *gpu,
MetaOutput *output)
{
MetaMonitorManager *monitor_manager;
MetaMonitorTiled *monitor_tiled;
MetaMonitor *monitor;
MetaMonitorPrivate *monitor_priv;
@ -1095,18 +1097,19 @@ meta_monitor_tiled_new (MetaMonitorManager *monitor_manager,
monitor = META_MONITOR (monitor_tiled);
monitor_priv = meta_monitor_get_instance_private (monitor);
monitor_priv->monitor_manager = monitor_manager;
monitor_priv->gpu = gpu;
monitor_tiled->tile_group_id = output->tile_info.group_id;
monitor_priv->winsys_id = output->winsys_id;
monitor_tiled->origin_output = output;
add_tiled_monitor_outputs (monitor_manager, monitor_tiled);
add_tiled_monitor_outputs (gpu, monitor_tiled);
monitor_tiled->main_output = find_untiled_output (monitor_tiled);
meta_monitor_generate_spec (monitor);
monitor_manager = meta_gpu_get_monitor_manager (gpu);
meta_monitor_manager_tiled_monitor_added (monitor_manager,
META_MONITOR (monitor_tiled));
@ -1193,8 +1196,10 @@ meta_monitor_tiled_finalize (GObject *object)
MetaMonitor *monitor = META_MONITOR (object);
MetaMonitorPrivate *monitor_priv =
meta_monitor_get_instance_private (monitor);
MetaMonitorManager *monitor_manager;
meta_monitor_manager_tiled_monitor_removed (monitor_priv->monitor_manager,
monitor_manager = meta_gpu_get_monitor_manager (monitor_priv->gpu);
meta_monitor_manager_tiled_monitor_removed (monitor_manager,
monitor);
G_OBJECT_CLASS (meta_monitor_tiled_parent_class)->finalize (object);

8
src/backends/meta-monitor.h
View file

@ -93,11 +93,11 @@ G_DECLARE_FINAL_TYPE (MetaMonitorTiled, meta_monitor_tiled,
META, MONITOR_TILED,
MetaMonitor)
MetaMonitorTiled * meta_monitor_tiled_new (MetaMonitorManager *monitor_manager,
MetaOutput *main_output);
MetaMonitorTiled * meta_monitor_tiled_new (MetaGpu *gpu,
MetaOutput *output);
MetaMonitorNormal * meta_monitor_normal_new (MetaMonitorManager *monitor_manager,
MetaOutput *output);
MetaMonitorNormal * meta_monitor_normal_new (MetaGpu *gpu,
MetaOutput *output);
MetaMonitorSpec * meta_monitor_get_spec (MetaMonitor *monitor);

6
src/backends/meta-output.c
View file

@ -23,10 +23,10 @@
G_DEFINE_TYPE (MetaOutput, meta_output, G_TYPE_OBJECT)
MetaMonitorManager *
meta_output_get_monitor_manager (MetaOutput *output)
MetaGpu *
meta_output_get_gpu (MetaOutput *output)
{
return output->monitor_manager;
return output->gpu;
}
static void

6
src/backends/meta-output.h
View file

@ -22,7 +22,7 @@
#include <glib-object.h>
#include "backends/meta-monitor-manager-private.h"
#include "backends/meta-gpu.h"
struct _MetaTileInfo
{
@ -62,7 +62,7 @@ struct _MetaOutput
{
GObject parent;
MetaMonitorManager *monitor_manager;
MetaGpu *gpu;
/* The CRTC driving this output, NULL if the output is not enabled */
MetaCrtc *crtc;
@ -119,6 +119,6 @@ struct _MetaOutput
#define META_TYPE_OUTPUT (meta_output_get_type ())
G_DECLARE_FINAL_TYPE (MetaOutput, meta_output, META, OUTPUT, GObject)
MetaMonitorManager * meta_output_get_monitor_manager (MetaOutput *output);
MetaGpu * meta_output_get_gpu (MetaOutput *output);
#endif /* META_OUTPUT_H */

63
src/backends/native/meta-crtc-kms.c
View file

@ -24,7 +24,7 @@
#include "backends/native/meta-crtc-kms.h"
#include "backends/meta-backend-private.h"
#include "backends/native/meta-monitor-manager-kms.h"
#include "backends/native/meta-gpu-kms.h"
#define ALL_TRANSFORMS (META_MONITOR_TRANSFORM_FLIPPED_270 + 1)
#define ALL_TRANSFORMS_MASK ((1 << ALL_TRANSFORMS) - 1)
@ -57,13 +57,12 @@ void
meta_crtc_kms_apply_transform (MetaCrtc *crtc)
{
MetaCrtcKms *crtc_kms = crtc->driver_private;
MetaMonitorManager *monitor_manager = meta_crtc_get_monitor_manager (crtc);
MetaMonitorManagerKms *monitor_manager_kms =
META_MONITOR_MANAGER_KMS (monitor_manager);
MetaGpu *gpu = meta_crtc_get_gpu (crtc);
MetaGpuKms *gpu_kms = META_GPU_KMS (gpu);
int kms_fd;
MetaMonitorTransform hw_transform;
kms_fd = meta_monitor_manager_kms_get_fd (monitor_manager_kms);
kms_fd = meta_gpu_kms_get_fd (gpu_kms);
if (crtc_kms->all_hw_transforms & (1 << crtc->transform))
hw_transform = crtc->transform;
@ -91,15 +90,14 @@ meta_crtc_kms_set_underscan (MetaCrtc *crtc,
gboolean is_underscanning)
{
MetaCrtcKms *crtc_kms = crtc->driver_private;
MetaMonitorManager *monitor_manager = meta_crtc_get_monitor_manager (crtc);
MetaMonitorManagerKms *monitor_manager_kms =
META_MONITOR_MANAGER_KMS (monitor_manager);
MetaGpu *gpu = meta_crtc_get_gpu (crtc);
MetaGpuKms *gpu_kms = META_GPU_KMS (gpu);
int kms_fd;
if (!crtc_kms->underscan_prop_id)
return;
kms_fd = meta_monitor_manager_kms_get_fd (monitor_manager_kms);
kms_fd = meta_gpu_kms_get_fd (gpu_kms);
if (is_underscanning)
{
@ -136,17 +134,16 @@ meta_crtc_kms_set_underscan (MetaCrtc *crtc,
}
static int
find_property_index (MetaMonitorManager *monitor_manager,
find_property_index (MetaGpu *gpu,
drmModeObjectPropertiesPtr props,
const char *prop_name,
drmModePropertyPtr *out_prop)
{
MetaMonitorManagerKms *monitor_manager_kms =
META_MONITOR_MANAGER_KMS (monitor_manager);
MetaGpuKms *gpu_kms = META_GPU_KMS (gpu);
int kms_fd;
unsigned int i;
kms_fd = meta_monitor_manager_kms_get_fd (monitor_manager_kms);
kms_fd = meta_gpu_kms_get_fd (gpu_kms);
for (i = 0; i < props->count_props; i++)
{
@ -197,13 +194,13 @@ parse_transforms (MetaCrtc *crtc,
}
static gboolean
is_primary_plane (MetaMonitorManager *monitor_manager,
is_primary_plane (MetaGpu *gpu,
drmModeObjectPropertiesPtr props)
{
drmModePropertyPtr prop;
int idx;
idx = find_property_index (monitor_manager, props, "type", &prop);
idx = find_property_index (gpu, props, "type", &prop);
if (idx < 0)
return FALSE;
@ -212,19 +209,18 @@ is_primary_plane (MetaMonitorManager *monitor_manager,
}
static void
init_crtc_rotations (MetaCrtc *crtc,
MetaMonitorManager *monitor_manager)
init_crtc_rotations (MetaCrtc *crtc,
MetaGpu *gpu)
{
MetaCrtcKms *crtc_kms = crtc->driver_private;
MetaMonitorManagerKms *monitor_manager_kms =
META_MONITOR_MANAGER_KMS (monitor_manager);
MetaGpuKms *gpu_kms = META_GPU_KMS (gpu);
int kms_fd;
drmModeObjectPropertiesPtr props;
drmModePlaneRes *planes;
drmModePlane *drm_plane;
unsigned int i;
kms_fd = meta_monitor_manager_kms_get_fd (monitor_manager_kms);
kms_fd = meta_gpu_kms_get_fd (gpu_kms);
planes = drmModeGetPlaneResources (kms_fd);
if (planes == NULL)
@ -245,12 +241,12 @@ init_crtc_rotations (MetaCrtc *crtc,
drm_plane->plane_id,
DRM_MODE_OBJECT_PLANE);
if (props && is_primary_plane (monitor_manager, props))
if (props && is_primary_plane (gpu, props))
{
int rotation_idx;
crtc_kms->primary_plane_id = drm_plane->plane_id;
rotation_idx = find_property_index (monitor_manager, props,
rotation_idx = find_property_index (gpu, props,
"rotation", &prop);
if (rotation_idx >= 0)
{
@ -273,15 +269,15 @@ init_crtc_rotations (MetaCrtc *crtc,
}
static void
find_crtc_properties (MetaCrtc *crtc,
MetaMonitorManagerKms *monitor_manager_kms)
find_crtc_properties (MetaCrtc *crtc,
MetaGpuKms *gpu_kms)
{
MetaCrtcKms *crtc_kms = crtc->driver_private;
int kms_fd;
drmModeObjectPropertiesPtr props;
unsigned int i;
kms_fd = meta_monitor_manager_kms_get_fd (monitor_manager_kms);
kms_fd = meta_gpu_kms_get_fd (gpu_kms);
props = drmModeObjectGetProperties (kms_fd, crtc->crtc_id,
DRM_MODE_OBJECT_CRTC);
if (!props)
@ -314,18 +310,17 @@ meta_crtc_destroy_notify (MetaCrtc *crtc)
}
MetaCrtc *
meta_create_kms_crtc (MetaMonitorManager *monitor_manager,
drmModeCrtc *drm_crtc,
unsigned int crtc_index)
meta_create_kms_crtc (MetaGpuKms *gpu_kms,
drmModeCrtc *drm_crtc,
unsigned int crtc_index)
{
MetaMonitorManagerKms *monitor_manager_kms =
META_MONITOR_MANAGER_KMS (monitor_manager);
MetaGpu *gpu = META_GPU (gpu_kms);
MetaCrtc *crtc;
MetaCrtcKms *crtc_kms;
crtc = g_object_new (META_TYPE_CRTC, NULL);
crtc->monitor_manager = monitor_manager;
crtc->gpu = gpu;
crtc->crtc_id = drm_crtc->crtc_id;
crtc->rect.x = drm_crtc->x;
crtc->rect.y = drm_crtc->y;
@ -340,7 +335,7 @@ meta_create_kms_crtc (MetaMonitorManager *monitor_manager,
{
GList *l;
for (l = monitor_manager->modes; l; l = l->next)
for (l = meta_gpu_get_modes (gpu); l; l = l->next)
{
MetaCrtcMode *mode = l->data;
@ -358,8 +353,8 @@ meta_create_kms_crtc (MetaMonitorManager *monitor_manager,
crtc->driver_private = crtc_kms;
crtc->driver_notify = (GDestroyNotify) meta_crtc_destroy_notify;
find_crtc_properties (crtc, monitor_manager_kms);
init_crtc_rotations (crtc, monitor_manager);
find_crtc_properties (crtc, gpu_kms);
init_crtc_rotations (crtc, gpu);
return crtc;
}

8
src/backends/native/meta-crtc-kms.h
View file

@ -26,6 +26,8 @@
#include <xf86drmMode.h>
#include "backends/meta-crtc.h"
#include "backends/meta-gpu.h"
#include "backends/native/meta-gpu-kms.h"
gboolean meta_crtc_kms_is_transform_handled (MetaCrtc *crtc,
MetaMonitorTransform transform);
@ -35,8 +37,8 @@ void meta_crtc_kms_apply_transform (MetaCrtc *crtc);
void meta_crtc_kms_set_underscan (MetaCrtc *crtc,
gboolean is_underscanning);
MetaCrtc * meta_create_kms_crtc (MetaMonitorManager *monitor_manager,
drmModeCrtc *drm_crtc,
unsigned int crtc_index);
MetaCrtc * meta_create_kms_crtc (MetaGpuKms *gpu_kms,
drmModeCrtc *drm_crtc,
unsigned int crtc_index);
#endif /* META_CRTC_KMS_H */

25
src/backends/native/meta-cursor-renderer-native.c
View file

@ -488,6 +488,7 @@ should_have_hw_cursor (MetaCursorRenderer *renderer,
{
MetaCursorRendererNative *native = META_CURSOR_RENDERER_NATIVE (renderer);
MetaCursorRendererNativePrivate *priv = meta_cursor_renderer_native_get_instance_private (native);
GList *gpus;
CoglTexture *texture;
if (priv->hw_cursor_broken)
@ -496,6 +497,10 @@ should_have_hw_cursor (MetaCursorRenderer *renderer,
if (!cursor_sprite)
return FALSE;
gpus = meta_monitor_manager_get_gpus (priv->monitor_manager);
if (g_list_length (gpus) != 1)
return FALSE;
if (cursor_over_transformed_logical_monitor (renderer, cursor_sprite))
return FALSE;
@ -853,24 +858,26 @@ on_monitors_changed (MetaMonitorManager *monitors,
}
static void
init_hw_cursor_support (MetaCursorRendererNative *cursor_renderer_native,
MetaBackend *backend)
init_hw_cursor_support (MetaCursorRendererNative *cursor_renderer_native)
{
MetaRendererNative *renderer_native =
META_RENDERER_NATIVE (meta_backend_get_renderer (backend));
MetaCursorRendererNativePrivate *priv =
meta_cursor_renderer_native_get_instance_private (cursor_renderer_native);
MetaMonitorManagerKms *monitor_manager_kms =
META_MONITOR_MANAGER_KMS (priv->monitor_manager);
GList *gpus;
MetaGpuKms *gpu_kms;
uint64_t width, height;
struct gbm_device *gbm_device;
gbm_device = meta_renderer_native_get_gbm (renderer_native);
gpus = meta_monitor_manager_get_gpus (priv->monitor_manager);
if (g_list_length (gpus) != 1)
return;
gpu_kms = META_GPU_KMS (gpus->data);
gbm_device = meta_gbm_device_from_gpu (gpu_kms);
if (!gbm_device)
return;
priv->gbm = gbm_device;
priv->drm_fd = meta_monitor_manager_kms_get_fd (monitor_manager_kms);
priv->drm_fd = meta_gpu_kms_get_fd (gpu_kms);
if (drmGetCap (priv->drm_fd, DRM_CAP_CURSOR_WIDTH, &width) == 0 &&
drmGetCap (priv->drm_fd, DRM_CAP_CURSOR_HEIGHT, &height) == 0)
@ -905,7 +912,7 @@ meta_cursor_renderer_native_new (MetaBackend *backend)
priv->monitor_manager = monitor_manager;
priv->hw_state_invalidated = TRUE;
init_hw_cursor_support (cursor_renderer_native, backend);
init_hw_cursor_support (cursor_renderer_native);
return cursor_renderer_native;
}

759
src/backends/native/meta-gpu-kms.c Normal file
View file

@ -0,0 +1,759 @@
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/*
* Copyright (C) 2017 Red Hat
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*/
#include "config.h"
#include "backends/native/meta-gpu-kms.h"
#include <drm.h>
#include <errno.h>
#include <string.h>
#include <xf86drm.h>
#include <xf86drmMode.h>
#include "backends/meta-crtc.h"
#include "backends/meta-monitor-manager-private.h"
#include "backends/meta-output.h"
#include "backends/native/meta-backend-native.h"
#include "backends/native/meta-crtc-kms.h"
#include "backends/native/meta-launcher.h"
#include "backends/native/meta-output-kms.h"
#include "backends/native/meta-default-modes.h"
typedef struct _MetaKmsSource
{
GSource source;
gpointer fd_tag;
MetaGpuKms *gpu_kms;
} MetaKmsSource;
struct _MetaGpuKms
{
MetaGpu parent;
int fd;
char *file_path;
GSource *source;
drmModeConnector **connectors;
unsigned int n_connectors;
int max_buffer_width;
int max_buffer_height;
gboolean page_flips_not_supported;
};
G_DEFINE_TYPE (MetaGpuKms, meta_gpu_kms, META_TYPE_GPU)
static gboolean
kms_event_check (GSource *source)
{
MetaKmsSource *kms_source = (MetaKmsSource *) source;
return g_source_query_unix_fd (source, kms_source->fd_tag) & G_IO_IN;
}
static gboolean
kms_event_dispatch (GSource *source,
GSourceFunc callback,
gpointer user_data)
{
MetaKmsSource *kms_source = (MetaKmsSource *) source;
meta_gpu_kms_wait_for_flip (kms_source->gpu_kms);
return G_SOURCE_CONTINUE;
}
static GSourceFuncs kms_event_funcs = {
NULL,
kms_event_check,
kms_event_dispatch
};
static void
get_crtc_drm_connectors (MetaGpu *gpu,
MetaCrtc *crtc,
uint32_t **connectors,
unsigned int *n_connectors)
{
GArray *connectors_array = g_array_new (FALSE, FALSE, sizeof (uint32_t));
GList *l;
for (l = meta_gpu_get_outputs (gpu); l; l = l->next)
{
MetaOutput *output = l->data;
if (output->crtc == crtc)
g_array_append_val (connectors_array, output->winsys_id);
}
*n_connectors = connectors_array->len;
*connectors = (uint32_t *) g_array_free (connectors_array, FALSE);
}
gboolean
meta_gpu_kms_apply_crtc_mode (MetaGpuKms *gpu_kms,
MetaCrtc *crtc,
int x,
int y,
uint32_t fb_id)
{
MetaGpu *gpu = meta_crtc_get_gpu (crtc);
int kms_fd = meta_gpu_kms_get_fd (gpu_kms);
uint32_t *connectors;
unsigned int n_connectors;
drmModeModeInfo *mode;
get_crtc_drm_connectors (gpu, crtc, &connectors, &n_connectors);
if (connectors)
mode = crtc->current_mode->driver_private;
else
mode = NULL;
if (drmModeSetCrtc (kms_fd,
crtc->crtc_id,
fb_id,
x, y,
connectors, n_connectors,
mode) != 0)
{
g_warning ("Failed to set CRTC mode %s: %m", crtc->current_mode->name);
return FALSE;
}
g_free (connectors);
return TRUE;
}
static void
invoke_flip_closure (GClosure *flip_closure)
{
GValue param = G_VALUE_INIT;
g_value_init (&param, G_TYPE_POINTER);
g_value_set_pointer (&param, flip_closure);
g_closure_invoke (flip_closure, NULL, 1, &param, NULL);
g_closure_unref (flip_closure);
}
gboolean
meta_gpu_kms_is_crtc_active (MetaGpuKms *gpu_kms,
MetaCrtc *crtc)
{
MetaGpu *gpu = META_GPU (gpu_kms);
MetaMonitorManager *monitor_manager = meta_gpu_get_monitor_manager (gpu);
GList *l;
gboolean connected_crtc_found;
if (monitor_manager->power_save_mode != META_POWER_SAVE_ON)
return FALSE;
connected_crtc_found = FALSE;
for (l = meta_gpu_get_outputs (gpu); l; l = l->next)
{
MetaOutput *output = l->data;
if (output->crtc == crtc)
{
connected_crtc_found = TRUE;
break;
}
}
if (!connected_crtc_found)
return FALSE;
return TRUE;
}
gboolean
meta_gpu_kms_flip_crtc (MetaGpuKms *gpu_kms,
MetaCrtc *crtc,
int x,
int y,
uint32_t fb_id,
GClosure *flip_closure,
gboolean *fb_in_use)
{
MetaGpu *gpu = META_GPU (gpu_kms);
MetaMonitorManager *monitor_manager = meta_gpu_get_monitor_manager (gpu);
uint32_t *connectors;
unsigned int n_connectors;
int ret = -1;
g_assert (meta_crtc_get_gpu (crtc) == gpu);
g_assert (monitor_manager->power_save_mode == META_POWER_SAVE_ON);
get_crtc_drm_connectors (gpu, crtc, &connectors, &n_connectors);
g_assert (n_connectors > 0);
if (!gpu_kms->page_flips_not_supported)
{
int kms_fd = meta_gpu_kms_get_fd (gpu_kms);
ret = drmModePageFlip (kms_fd,
crtc->crtc_id,
fb_id,
DRM_MODE_PAGE_FLIP_EVENT,
flip_closure);
if (ret != 0 && ret != -EACCES)
{
g_warning ("Failed to flip: %s", strerror (-ret));
gpu_kms->page_flips_not_supported = TRUE;
}
}
if (gpu_kms->page_flips_not_supported)
{
if (meta_gpu_kms_apply_crtc_mode (gpu_kms, crtc, x, y, fb_id))
{
*fb_in_use = TRUE;
return FALSE;
}
}
if (ret != 0)
return FALSE;
*fb_in_use = TRUE;
g_closure_ref (flip_closure);
return TRUE;
}
static void
page_flip_handler (int fd,
unsigned int frame,
unsigned int sec,
unsigned int usec,
void *user_data)
{
GClosure *flip_closure = user_data;
invoke_flip_closure (flip_closure);
}
void
meta_gpu_kms_wait_for_flip (MetaGpuKms *gpu_kms)
{
drmEventContext evctx;
if (gpu_kms->page_flips_not_supported)
return;
memset (&evctx, 0, sizeof evctx);
evctx.version = DRM_EVENT_CONTEXT_VERSION;
evctx.page_flip_handler = page_flip_handler;
drmHandleEvent (gpu_kms->fd, &evctx);
}
void
meta_gpu_kms_get_max_buffer_size (MetaGpuKms *gpu_kms,
int *max_width,
int *max_height)
{
*max_width = gpu_kms->max_buffer_width;
*max_height = gpu_kms->max_buffer_height;
}
int
meta_gpu_kms_get_fd (MetaGpuKms *gpu_kms)
{
return gpu_kms->fd;
}
const char *
meta_gpu_kms_get_file_path (MetaGpuKms *gpu_kms)
{
return gpu_kms->file_path;
}
void
meta_gpu_kms_set_power_save_mode (MetaGpuKms *gpu_kms,
uint64_t state)
{
GList *l;
for (l = meta_gpu_get_outputs (META_GPU (gpu_kms)); l; l = l->next)
{
MetaOutput *output = l->data;
meta_output_kms_set_power_save_mode (output, state);
}
}
static void
free_resources (MetaGpuKms *gpu_kms)
{
unsigned i;
for (i = 0; i < gpu_kms->n_connectors; i++)
drmModeFreeConnector (gpu_kms->connectors[i]);
g_free (gpu_kms->connectors);
}
static int
compare_outputs (gconstpointer one,
gconstpointer two)
{
const MetaOutput *o_one = one, *o_two = two;
return strcmp (o_one->name, o_two->name);
}
static void
meta_crtc_mode_destroy_notify (MetaCrtcMode *mode)
{
g_slice_free (drmModeModeInfo, mode->driver_private);
}
gboolean
meta_drm_mode_equal (const drmModeModeInfo *one,
const drmModeModeInfo *two)
{
return (one->clock == two->clock &&
one->hdisplay == two->hdisplay &&
one->hsync_start == two->hsync_start &&
one->hsync_end == two->hsync_end &&
one->htotal == two->htotal &&
one->hskew == two->hskew &&
one->vdisplay == two->vdisplay &&
one->vsync_start == two->vsync_start &&
one->vsync_end == two->vsync_end &&
one->vtotal == two->vtotal &&
one->vscan == two->vscan &&
one->vrefresh == two->vrefresh &&
one->flags == two->flags &&
one->type == two->type &&
strncmp (one->name, two->name, DRM_DISPLAY_MODE_LEN) == 0);
}
static guint
drm_mode_hash (gconstpointer ptr)
{
const drmModeModeInfo *mode = ptr;
guint hash = 0;
/*
* We don't include the name in the hash because it's generally
* derived from the other fields (hdisplay, vdisplay and flags)
*/
hash ^= mode->clock;
hash ^= mode->hdisplay ^ mode->hsync_start ^ mode->hsync_end;
hash ^= mode->vdisplay ^ mode->vsync_start ^ mode->vsync_end;
hash ^= mode->vrefresh;
hash ^= mode->flags ^ mode->type;
return hash;
}
MetaCrtcMode *
meta_gpu_kms_get_mode_from_drm_mode (MetaGpuKms *gpu_kms,
const drmModeModeInfo *drm_mode)
{
MetaGpu *gpu = META_GPU (gpu_kms);
GList *l;
for (l = meta_gpu_get_modes (gpu); l; l = l->next)
{
MetaCrtcMode *mode = l->data;
if (meta_drm_mode_equal (drm_mode, mode->driver_private))
return mode;
}
g_assert_not_reached ();
return NULL;
}
float
meta_calculate_drm_mode_refresh_rate (const drmModeModeInfo *mode)
{
float refresh = 0.0;
if (mode->htotal > 0 && mode->vtotal > 0)
{
/* Calculate refresh rate in milliHz first for extra precision. */
refresh = (mode->clock * 1000000LL) / mode->htotal;
refresh += (mode->vtotal / 2);
refresh /= mode->vtotal;
if (mode->vscan > 1)
refresh /= mode->vscan;
refresh /= 1000.0;
}
return refresh;
}
static MetaCrtcMode *
create_mode (const drmModeModeInfo *drm_mode,
long mode_id)
{
MetaCrtcMode *mode;
mode = g_object_new (META_TYPE_CRTC_MODE, NULL);
mode->mode_id = mode_id;
mode->name = g_strndup (drm_mode->name, DRM_DISPLAY_MODE_LEN);
mode->width = drm_mode->hdisplay;
mode->height = drm_mode->vdisplay;
mode->flags = drm_mode->flags;
mode->refresh_rate = meta_calculate_drm_mode_refresh_rate (drm_mode);
mode->driver_private = g_slice_dup (drmModeModeInfo, drm_mode);
mode->driver_notify = (GDestroyNotify) meta_crtc_mode_destroy_notify;
return mode;
}
static MetaOutput *
find_output_by_id (GList *outputs,
glong id)
{
GList *l;
for (l = outputs; l; l = l->next)
{
MetaOutput *output = l->data;
if (output->winsys_id == id)
return output;
}
return NULL;
}
static void
setup_output_clones (MetaGpu *gpu)
{
GList *l;
for (l = meta_gpu_get_outputs (gpu); l; l = l->next)
{
MetaOutput *output = l->data;
GList *k;
for (k = meta_gpu_get_outputs (gpu); k; k = k->next)
{
MetaOutput *other_output = k->data;
if (other_output == output)
continue;
if (meta_output_kms_can_clone (output, other_output))
{
output->n_possible_clones++;
output->possible_clones = g_renew (MetaOutput *,
output->possible_clones,
output->n_possible_clones);
output->possible_clones[output->n_possible_clones - 1] =
other_output;
}
}
}
}
static void
init_connectors (MetaGpuKms *gpu_kms,
drmModeRes *resources)
{
unsigned int i;
gpu_kms->n_connectors = resources->count_connectors;
gpu_kms->connectors = g_new (drmModeConnector *, gpu_kms->n_connectors);
for (i = 0; i < gpu_kms->n_connectors; i++)
{
drmModeConnector *drm_connector;
drm_connector = drmModeGetConnector (gpu_kms->fd,
resources->connectors[i]);
gpu_kms->connectors[i] = drm_connector;
}
}
static void
init_modes (MetaGpuKms *gpu_kms,
drmModeRes *resources)
{
MetaGpu *gpu = META_GPU (gpu_kms);
GHashTable *modes_table;
GList *modes;
GHashTableIter iter;
drmModeModeInfo *drm_mode;
unsigned int i;
long mode_id;
/*
* Gather all modes on all connected connectors.
*/
modes_table = g_hash_table_new (drm_mode_hash, (GEqualFunc) meta_drm_mode_equal);
for (i = 0; i < gpu_kms->n_connectors; i++)
{
drmModeConnector *drm_connector;
drm_connector = gpu_kms->connectors[i];
if (drm_connector && drm_connector->connection == DRM_MODE_CONNECTED)
{
unsigned int j;
for (j = 0; j < (unsigned int) drm_connector->count_modes; j++)
g_hash_table_add (modes_table, &drm_connector->modes[j]);
}
}
modes = NULL;
g_hash_table_iter_init (&iter, modes_table);
mode_id = 0;
while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &drm_mode))
{
MetaCrtcMode *mode;
mode = create_mode (drm_mode, (long) mode_id);
modes = g_list_append (modes, mode);
mode_id++;
}
g_hash_table_destroy (modes_table);
for (i = 0; i < G_N_ELEMENTS (meta_default_drm_mode_infos); i++)
{
MetaCrtcMode *mode;
mode = create_mode (&meta_default_drm_mode_infos[i], (long) mode_id);
modes = g_list_append (modes, mode);
mode_id++;
}
meta_gpu_take_modes (gpu, modes);
}
static void
init_crtcs (MetaGpuKms *gpu_kms,
MetaKmsResources *resources)
{
MetaGpu *gpu = META_GPU (gpu_kms);
GList *crtcs;
unsigned int i;
crtcs = NULL;
for (i = 0; i < (unsigned int) resources->resources->count_crtcs; i++)
{
drmModeCrtc *drm_crtc;
MetaCrtc *crtc;
drm_crtc = drmModeGetCrtc (gpu_kms->fd,
resources->resources->crtcs[i]);
crtc = meta_create_kms_crtc (gpu_kms, drm_crtc, i);
drmModeFreeCrtc (drm_crtc);
crtcs = g_list_append (crtcs, crtc);
}
meta_gpu_take_crtcs (gpu, crtcs);
}
static void
init_outputs (MetaGpuKms *gpu_kms,
MetaKmsResources *resources)
{
MetaGpu *gpu = META_GPU (gpu_kms);
GList *old_outputs;
GList *outputs;
unsigned int i;
old_outputs = meta_gpu_get_outputs (gpu);
outputs = NULL;
for (i = 0; i < gpu_kms->n_connectors; i++)
{
drmModeConnector *connector;
connector = gpu_kms->connectors[i];
if (connector && connector->connection == DRM_MODE_CONNECTED)
{
MetaOutput *output;
MetaOutput *old_output;
old_output = find_output_by_id (old_outputs, connector->connector_id);
output = meta_create_kms_output (gpu_kms, connector, resources,
old_output);
outputs = g_list_prepend (outputs, output);
}
}
/* Sort the outputs for easier handling in MetaMonitorConfig */
outputs = g_list_sort (outputs, compare_outputs);
meta_gpu_take_outputs (gpu, outputs);
setup_output_clones (gpu);
}
static void
meta_kms_resources_init (MetaKmsResources *resources,
int fd)
{
drmModeRes *drm_resources;
unsigned int i;
drm_resources = drmModeGetResources (fd);
resources->resources = drm_resources;
resources->n_encoders = (unsigned int) drm_resources->count_encoders;
resources->encoders = g_new (drmModeEncoder *, resources->n_encoders);
for (i = 0; i < resources->n_encoders; i++)
resources->encoders[i] = drmModeGetEncoder (fd, drm_resources->encoders[i]);
}
static void
meta_kms_resources_release (MetaKmsResources *resources)
{
unsigned int i;
for (i = 0; i < resources->n_encoders; i++)
drmModeFreeEncoder (resources->encoders[i]);
g_free (resources->encoders);
drmModeFreeResources (resources->resources);
}
static gboolean
meta_gpu_kms_read_current (MetaGpu *gpu,
GError **error)
{
MetaGpuKms *gpu_kms = META_GPU_KMS (gpu);
MetaMonitorManager *monitor_manager =
meta_gpu_get_monitor_manager (gpu);
MetaKmsResources resources;
meta_kms_resources_init (&resources, gpu_kms->fd);
gpu_kms->max_buffer_width = resources.resources->max_width;
gpu_kms->max_buffer_height = resources.resources->max_height;
monitor_manager->power_save_mode = META_POWER_SAVE_ON;
/* Note: we must not free the public structures (output, crtc, monitor
mode and monitor info) here, they must be kept alive until the API
users are done with them after we emit monitors-changed, and thus
are freed by the platform-independent layer. */
free_resources (gpu_kms);
init_connectors (gpu_kms, resources.resources);
init_modes (gpu_kms, resources.resources);
init_crtcs (gpu_kms, &resources);
init_outputs (gpu_kms, &resources);
meta_kms_resources_release (&resources);
return TRUE;
}
MetaGpuKms *
meta_gpu_kms_new (MetaMonitorManagerKms *monitor_manager_kms,
const char *kms_file_path,
GError **error)
{
MetaMonitorManager *monitor_manager =
META_MONITOR_MANAGER (monitor_manager_kms);
MetaBackend *backend = meta_monitor_manager_get_backend (monitor_manager);
MetaLauncher *launcher =
meta_backend_native_get_launcher (META_BACKEND_NATIVE (backend));
GSource *source;
MetaKmsSource *kms_source;
MetaGpuKms *gpu_kms;
int kms_fd;
kms_fd = meta_launcher_open_restricted (launcher, kms_file_path, error);
if (kms_fd == -1)
return FALSE;
gpu_kms = g_object_new (META_TYPE_GPU_KMS,
"monitor-manager", monitor_manager_kms,
NULL);
gpu_kms->fd = kms_fd;
gpu_kms->file_path = g_strdup (kms_file_path);
drmSetClientCap (gpu_kms->fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
source = g_source_new (&kms_event_funcs, sizeof (MetaKmsSource));
kms_source = (MetaKmsSource *) source;
kms_source->fd_tag = g_source_add_unix_fd (source,
gpu_kms->fd,
G_IO_IN | G_IO_ERR);
kms_source->gpu_kms = gpu_kms;
gpu_kms->source = source;
g_source_attach (gpu_kms->source, NULL);
return gpu_kms;
}
static void
meta_gpu_kms_finalize (GObject *object)
{
MetaGpuKms *gpu_kms = META_GPU_KMS (object);
MetaMonitorManager *monitor_manager =
meta_gpu_get_monitor_manager (META_GPU (gpu_kms));
MetaBackend *backend = meta_monitor_manager_get_backend (monitor_manager);
MetaBackendNative *backend_native = META_BACKEND_NATIVE (backend);
MetaLauncher *launcher = meta_backend_native_get_launcher (backend_native);
if (gpu_kms->fd != -1)
meta_launcher_close_restricted (launcher, gpu_kms->fd);
g_clear_pointer (&gpu_kms->file_path, g_free);
g_source_destroy (gpu_kms->source);
free_resources (gpu_kms);
G_OBJECT_CLASS (meta_gpu_kms_parent_class)->finalize (object);
}
static void
meta_gpu_kms_init (MetaGpuKms *gpu_kms)
{
gpu_kms->fd = -1;
}
static void
meta_gpu_kms_class_init (MetaGpuKmsClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
MetaGpuClass *gpu_class = META_GPU_CLASS (klass);
object_class->finalize = meta_gpu_kms_finalize;
gpu_class->read_current = meta_gpu_kms_read_current;
}

86
src/backends/native/meta-gpu-kms.h Normal file
View file

@ -0,0 +1,86 @@
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/*
* Copyright (C) 2017 Red Hat
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*/
#ifndef META_GPU_KMS_H
#define META_GPU_KMS_H
#include <glib-object.h>
#include <xf86drm.h>
#include <xf86drmMode.h>
#include "backends/meta-gpu.h"
#include "backends/native/meta-monitor-manager-kms.h"
#define META_TYPE_GPU_KMS (meta_gpu_kms_get_type ())
G_DECLARE_FINAL_TYPE (MetaGpuKms, meta_gpu_kms, META, GPU_KMS, MetaGpu)
typedef struct _MetaKmsResources
{
drmModeRes *resources;
drmModeEncoder **encoders;
unsigned int n_encoders;
} MetaKmsResources;
typedef void (*MetaKmsFlipCallback) (void *user_data);
MetaGpuKms * meta_gpu_kms_new (MetaMonitorManagerKms *monitor_manager_kms,
const char *kms_file_path,
GError **error);
gboolean meta_gpu_kms_apply_crtc_mode (MetaGpuKms *gpu_kms,
MetaCrtc *crtc,
int x,
int y,
uint32_t fb_id);
gboolean meta_gpu_kms_is_crtc_active (MetaGpuKms *gpu_kms,
MetaCrtc *crtc);
gboolean meta_gpu_kms_flip_crtc (MetaGpuKms *gpu_kms,
MetaCrtc *crtc,
int x,
int y,
uint32_t fb_id,
GClosure *flip_closure,
gboolean *fb_in_use);
void meta_gpu_kms_wait_for_flip (MetaGpuKms *gpu_kms);
int meta_gpu_kms_get_fd (MetaGpuKms *gpu_kms);
const char * meta_gpu_kms_get_file_path (MetaGpuKms *gpu_kms);
void meta_gpu_kms_get_max_buffer_size (MetaGpuKms *gpu_kms,
int *max_width,
int *max_height);
void meta_gpu_kms_set_power_save_mode (MetaGpuKms *gpu_kms,
uint64_t state);
MetaCrtcMode * meta_gpu_kms_get_mode_from_drm_mode (MetaGpuKms *gpu_kms,
const drmModeModeInfo *drm_mode);
gboolean meta_drm_mode_equal (const drmModeModeInfo *one,
const drmModeModeInfo *two);
float meta_calculate_drm_mode_refresh_rate (const drmModeModeInfo *mode);
#endif /* META_GPU_KMS_H */

767
src/backends/native/meta-monitor-manager-kms.c
View file

@ -32,6 +32,7 @@
#include "meta-backend-private.h"
#include "meta-renderer-native.h"
#include "meta-crtc-kms.h"
#include "meta-gpu-kms.h"
#include "meta-output-kms.h"
#include <string.h>
@ -49,8 +50,6 @@
#include <gudev/gudev.h>
#include "meta-default-modes.h"
#define DRM_CARD_UDEV_DEVICE_TYPE "drm_minor"
typedef struct
@ -65,20 +64,10 @@ struct _MetaMonitorManagerKms
{
MetaMonitorManager parent_instance;
int fd;
char *file_path;
MetaKmsSource *source;
drmModeConnector **connectors;
unsigned int n_connectors;
MetaGpuKms *primary_gpu;
GUdevClient *udev;
guint uevent_handler_id;
gboolean page_flips_not_supported;
int max_buffer_width;
int max_buffer_height;
};
struct _MetaMonitorManagerKmsClass
@ -94,378 +83,6 @@ G_DEFINE_TYPE_WITH_CODE (MetaMonitorManagerKms, meta_monitor_manager_kms,
G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
initable_iface_init))
int
meta_monitor_manager_kms_get_fd (MetaMonitorManagerKms *manager_kms)
{
return manager_kms->fd;
}
const char *
meta_monitor_manager_kms_get_file_path (MetaMonitorManagerKms *manager_kms)
{
return manager_kms->file_path;
}
static void
free_resources (MetaMonitorManagerKms *manager_kms)
{
unsigned i;
for (i = 0; i < manager_kms->n_connectors; i++)
drmModeFreeConnector (manager_kms->connectors[i]);
g_free (manager_kms->connectors);
}
static int
compare_outputs (gconstpointer one,
gconstpointer two)
{
const MetaOutput *o_one = one, *o_two = two;
return strcmp (o_one->name, o_two->name);
}
static void
meta_monitor_mode_destroy_notify (MetaCrtcMode *mode)
{
g_slice_free (drmModeModeInfo, mode->driver_private);
}
gboolean
meta_drm_mode_equal (const drmModeModeInfo *one,
const drmModeModeInfo *two)
{
return (one->clock == two->clock &&
one->hdisplay == two->hdisplay &&
one->hsync_start == two->hsync_start &&
one->hsync_end == two->hsync_end &&
one->htotal == two->htotal &&
one->hskew == two->hskew &&
one->vdisplay == two->vdisplay &&
one->vsync_start == two->vsync_start &&
one->vsync_end == two->vsync_end &&
one->vtotal == two->vtotal &&
one->vscan == two->vscan &&
one->vrefresh == two->vrefresh &&
one->flags == two->flags &&
one->type == two->type &&
strncmp (one->name, two->name, DRM_DISPLAY_MODE_LEN) == 0);
}
static guint
drm_mode_hash (gconstpointer ptr)
{
const drmModeModeInfo *mode = ptr;
guint hash = 0;
/* We don't include the name in the hash because it's generally
derived from the other fields (hdisplay, vdisplay and flags)
*/
hash ^= mode->clock;
hash ^= mode->hdisplay ^ mode->hsync_start ^ mode->hsync_end;
hash ^= mode->vdisplay ^ mode->vsync_start ^ mode->vsync_end;
hash ^= mode->vrefresh;
hash ^= mode->flags ^ mode->type;
return hash;
}
MetaCrtcMode *
meta_monitor_manager_kms_get_mode_from_drm_mode (MetaMonitorManagerKms *manager_kms,
const drmModeModeInfo *drm_mode)
{
MetaMonitorManager *manager = META_MONITOR_MANAGER (manager_kms);
GList *l;
for (l = manager->modes; l; l = l->next)
{
MetaCrtcMode *mode = l->data;
if (meta_drm_mode_equal (drm_mode, mode->driver_private))
return mode;
}
g_assert_not_reached ();
return NULL;
}
float
meta_calculate_drm_mode_refresh_rate (const drmModeModeInfo *mode)
{
float refresh = 0.0;
if (mode->htotal > 0 && mode->vtotal > 0)
{
/* Calculate refresh rate in milliHz first for extra precision. */
refresh = (mode->clock * 1000000LL) / mode->htotal;
refresh += (mode->vtotal / 2);
refresh /= mode->vtotal;
if (mode->vscan > 1)
refresh /= mode->vscan;
refresh /= 1000.0;
}
return refresh;
}
static MetaCrtcMode *
create_mode (const drmModeModeInfo *drm_mode,
long mode_id)
{
MetaCrtcMode *mode;
mode = g_object_new (META_TYPE_CRTC_MODE, NULL);
mode->mode_id = mode_id;
mode->name = g_strndup (drm_mode->name, DRM_DISPLAY_MODE_LEN);
mode->width = drm_mode->hdisplay;
mode->height = drm_mode->vdisplay;
mode->flags = drm_mode->flags;
mode->refresh_rate = meta_calculate_drm_mode_refresh_rate (drm_mode);
mode->driver_private = g_slice_dup (drmModeModeInfo, drm_mode);
mode->driver_notify = (GDestroyNotify) meta_monitor_mode_destroy_notify;
return mode;
}
static MetaOutput *
find_output_by_id (GList *outputs,
glong id)
{
GList *l;
for (l = outputs; l; l = l->next)
{
MetaOutput *output = l->data;
if (output->winsys_id == id)
return output;
}
return NULL;
}
static void
setup_output_clones (MetaMonitorManager *manager)
{
GList *l;
for (l = manager->outputs; l; l = l->next)
{
MetaOutput *output = l->data;
GList *k;
for (k = manager->outputs; k; k = k->next)
{
MetaOutput *other_output = k->data;
if (other_output == output)
continue;
if (meta_output_kms_can_clone (output, other_output))
{
output->n_possible_clones++;
output->possible_clones = g_renew (MetaOutput *,
output->possible_clones,
output->n_possible_clones);
output->possible_clones[output->n_possible_clones - 1] =
other_output;
}
}
}
}
static void
init_connectors (MetaMonitorManager *manager,
drmModeRes *resources)
{
MetaMonitorManagerKms *manager_kms = META_MONITOR_MANAGER_KMS (manager);
unsigned int i;
manager_kms->n_connectors = resources->count_connectors;
manager_kms->connectors = g_new (drmModeConnector *, manager_kms->n_connectors);
for (i = 0; i < manager_kms->n_connectors; i++)
{
drmModeConnector *drm_connector;
drm_connector = drmModeGetConnector (manager_kms->fd,
resources->connectors[i]);
manager_kms->connectors[i] = drm_connector;
}
}
static void
init_modes (MetaMonitorManager *manager,
drmModeRes *resources)
{
MetaMonitorManagerKms *manager_kms = META_MONITOR_MANAGER_KMS (manager);
GHashTable *modes;
GHashTableIter iter;
drmModeModeInfo *drm_mode;
unsigned int i;
long mode_id;
/*
* Gather all modes on all connected connectors.
*/
modes = g_hash_table_new (drm_mode_hash, (GEqualFunc) meta_drm_mode_equal);
for (i = 0; i < manager_kms->n_connectors; i++)
{
drmModeConnector *drm_connector;
drm_connector = manager_kms->connectors[i];
if (drm_connector && drm_connector->connection == DRM_MODE_CONNECTED)
{
unsigned int j;
for (j = 0; j < (unsigned int) drm_connector->count_modes; j++)
g_hash_table_add (modes, &drm_connector->modes[j]);
}
}
manager->modes = NULL;
g_hash_table_iter_init (&iter, modes);
mode_id = 0;
while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &drm_mode))
{
MetaCrtcMode *mode;
mode = create_mode (drm_mode, (long) mode_id);
manager->modes = g_list_append (manager->modes, mode);
mode_id++;
}
g_hash_table_destroy (modes);
for (i = 0; i < G_N_ELEMENTS (meta_default_drm_mode_infos); i++)
{
MetaCrtcMode *mode;
mode = create_mode (&meta_default_drm_mode_infos[i], (long) mode_id);
manager->modes = g_list_append (manager->modes, mode);
mode_id++;
}
}
static void
init_crtcs (MetaMonitorManager *manager,
MetaKmsResources *resources)
{
MetaMonitorManagerKms *manager_kms = META_MONITOR_MANAGER_KMS (manager);
unsigned int i;
manager->crtcs = NULL;
for (i = 0; i < (unsigned int) resources->resources->count_crtcs; i++)
{
drmModeCrtc *drm_crtc;
MetaCrtc *crtc;
drm_crtc = drmModeGetCrtc (manager_kms->fd,
resources->resources->crtcs[i]);
crtc = meta_create_kms_crtc (manager, drm_crtc, i);
drmModeFreeCrtc (drm_crtc);
manager->crtcs = g_list_append (manager->crtcs, crtc);
}
}
static void
init_outputs (MetaMonitorManager *manager,
MetaKmsResources *resources)
{
MetaMonitorManagerKms *manager_kms = META_MONITOR_MANAGER_KMS (manager);
GList *old_outputs;
unsigned int i;
old_outputs = manager->outputs;
manager->outputs = NULL;
for (i = 0; i < manager_kms->n_connectors; i++)
{
drmModeConnector *connector;
connector = manager_kms->connectors[i];
if (connector && connector->connection == DRM_MODE_CONNECTED)
{
MetaOutput *output;
MetaOutput *old_output;
old_output = find_output_by_id (old_outputs, connector->connector_id);
output = meta_create_kms_output (manager, connector, resources, old_output);
manager->outputs = g_list_prepend (manager->outputs, output);
}
}
/* Sort the outputs for easier handling in MetaMonitorConfig */
manager->outputs = g_list_sort (manager->outputs, compare_outputs);
setup_output_clones (manager);
}
static void
meta_kms_resources_init (MetaKmsResources *resources,
int fd)
{
drmModeRes *drm_resources;
unsigned int i;
drm_resources = drmModeGetResources (fd);
resources->resources = drm_resources;
resources->n_encoders = (unsigned int) drm_resources->count_encoders;
resources->encoders = g_new (drmModeEncoder *, resources->n_encoders);
for (i = 0; i < resources->n_encoders; i++)
resources->encoders[i] = drmModeGetEncoder (fd, drm_resources->encoders[i]);
}
static void
meta_kms_resources_release (MetaKmsResources *resources)
{
unsigned int i;
for (i = 0; i < resources->n_encoders; i++)
drmModeFreeEncoder (resources->encoders[i]);
g_free (resources->encoders);
drmModeFreeResources (resources->resources);
}
static void
meta_monitor_manager_kms_read_current (MetaMonitorManager *manager)
{
MetaMonitorManagerKms *manager_kms = META_MONITOR_MANAGER_KMS (manager);
MetaKmsResources resources;
meta_kms_resources_init (&resources, manager_kms->fd);
manager_kms->max_buffer_width = resources.resources->max_width;
manager_kms->max_buffer_height = resources.resources->max_height;
manager->power_save_mode = META_POWER_SAVE_ON;
/* Note: we must not free the public structures (output, crtc, monitor
mode and monitor info) here, they must be kept alive until the API
users are done with them after we emit monitors-changed, and thus
are freed by the platform-independent layer. */
free_resources (manager_kms);
init_connectors (manager, resources.resources);
init_modes (manager, resources.resources);
init_crtcs (manager, &resources);
init_outputs (manager, &resources);
meta_kms_resources_release (&resources);
}
static GBytes *
meta_monitor_manager_kms_read_edid (MetaMonitorManager *manager,
MetaOutput *output)
@ -497,11 +114,11 @@ meta_monitor_manager_kms_set_power_save_mode (MetaMonitorManager *manager,
return;
}
for (l = manager->outputs; l; l = l->next)
for (l = manager->gpus; l; l = l->next)
{
MetaOutput *output = l->data;
MetaGpuKms *gpu_kms = l->data;
meta_output_kms_set_power_save_mode (output, state);
meta_gpu_kms_set_power_save_mode (gpu_kms, state);
}
}
@ -579,23 +196,29 @@ apply_crtc_assignments (MetaMonitorManager *manager,
}
/* Disable CRTCs not mentioned in the list (they have is_dirty == FALSE,
because they weren't seen in the first loop) */
for (l = manager->crtcs; l; l = l->next)
for (l = manager->gpus; l; l = l->next)
{
MetaCrtc *crtc = l->data;
MetaGpu *gpu = l->data;
GList *k;
crtc->logical_monitor = NULL;
if (crtc->is_dirty)
for (k = meta_gpu_get_crtcs (gpu); k; k = k->next)
{
crtc->is_dirty = FALSE;
continue;
}
MetaCrtc *crtc = k->data;
crtc->rect.x = 0;
crtc->rect.y = 0;
crtc->rect.width = 0;
crtc->rect.height = 0;
crtc->current_mode = NULL;
crtc->logical_monitor = NULL;
if (crtc->is_dirty)
{
crtc->is_dirty = FALSE;
continue;
}
crtc->rect.x = 0;
crtc->rect.y = 0;
crtc->rect.width = 0;
crtc->rect.height = 0;
crtc->current_mode = NULL;
}
}
for (i = 0; i < n_outputs; i++)
@ -611,18 +234,24 @@ apply_crtc_assignments (MetaMonitorManager *manager,
}
/* Disable outputs not mentioned in the list */
for (l = manager->outputs; l; l = l->next)
for (l = manager->gpus; l; l = l->next)
{
MetaOutput *output = l->data;
MetaGpu *gpu = l->data;
GList *k;
if (output->is_dirty)
for (k = meta_gpu_get_outputs (gpu); k; k = k->next)
{
output->is_dirty = FALSE;
continue;
}
MetaOutput *output = k->data;
output->crtc = NULL;
output->is_primary = FALSE;
if (output->is_dirty)
{
output->is_dirty = FALSE;
continue;
}
output->crtc = NULL;
output->is_primary = FALSE;
}
}
}
@ -707,17 +336,18 @@ meta_monitor_manager_kms_get_crtc_gamma (MetaMonitorManager *manager,
unsigned short **green,
unsigned short **blue)
{
MetaMonitorManagerKms *manager_kms = META_MONITOR_MANAGER_KMS (manager);
MetaGpu *gpu = meta_crtc_get_gpu (crtc);
int kms_fd = meta_gpu_kms_get_fd (META_GPU_KMS (gpu));
drmModeCrtc *kms_crtc;
kms_crtc = drmModeGetCrtc (manager_kms->fd, crtc->crtc_id);
kms_crtc = drmModeGetCrtc (kms_fd, crtc->crtc_id);
*size = kms_crtc->gamma_size;
*red = g_new (unsigned short, *size);
*green = g_new (unsigned short, *size);
*blue = g_new (unsigned short, *size);
drmModeCrtcGetGamma (manager_kms->fd, crtc->crtc_id, *size, *red, *green, *blue);
drmModeCrtcGetGamma (kms_fd, crtc->crtc_id, *size, *red, *green, *blue);
drmModeFreeCrtc (kms_crtc);
}
@ -730,9 +360,10 @@ meta_monitor_manager_kms_set_crtc_gamma (MetaMonitorManager *manager,
unsigned short *green,
unsigned short *blue)
{
MetaMonitorManagerKms *manager_kms = META_MONITOR_MANAGER_KMS (manager);
MetaGpu *gpu = meta_crtc_get_gpu (crtc);
int kms_fd = meta_gpu_kms_get_fd (META_GPU_KMS (gpu));
drmModeCrtcSetGamma (manager_kms->fd, crtc->crtc_id, size, red, green, blue);
drmModeCrtcSetGamma (kms_fd, crtc->crtc_id, size, red, green, blue);
}
static void
@ -757,32 +388,6 @@ on_uevent (GUdevClient *client,
handle_hotplug_event (manager);
}
static gboolean
kms_event_check (GSource *source)
{
MetaKmsSource *kms_source = (MetaKmsSource *) source;
return g_source_query_unix_fd (source, kms_source->fd_tag) & G_IO_IN;
}
static gboolean
kms_event_dispatch (GSource *source,
GSourceFunc callback,
gpointer user_data)
{
MetaKmsSource *kms_source = (MetaKmsSource *) source;
meta_monitor_manager_kms_wait_for_flip (kms_source->manager_kms);
return G_SOURCE_CONTINUE;
}
static GSourceFuncs kms_event_funcs = {
NULL,
kms_event_check,
kms_event_dispatch
};
static void
meta_monitor_manager_kms_connect_uevent_handler (MetaMonitorManagerKms *manager_kms)
{
@ -815,182 +420,6 @@ meta_monitor_manager_kms_resume (MetaMonitorManagerKms *manager_kms)
handle_hotplug_event (manager);
}
static void
get_crtc_connectors (MetaMonitorManager *manager,
MetaCrtc *crtc,
uint32_t **connectors,
unsigned int *n_connectors)
{
GArray *connectors_array = g_array_new (FALSE, FALSE, sizeof (uint32_t));
GList *l;
for (l = manager->outputs; l; l = l->next)
{
MetaOutput *output = l->data;
if (output->crtc == crtc)
g_array_append_val (connectors_array, output->winsys_id);
}
*n_connectors = connectors_array->len;
*connectors = (uint32_t *) g_array_free (connectors_array, FALSE);
}
gboolean
meta_monitor_manager_kms_apply_crtc_mode (MetaMonitorManagerKms *manager_kms,
MetaCrtc *crtc,
int x,
int y,
uint32_t fb_id)
{
MetaMonitorManager *manager = META_MONITOR_MANAGER (manager_kms);
uint32_t *connectors;
unsigned int n_connectors;
drmModeModeInfo *mode;
get_crtc_connectors (manager, crtc, &connectors, &n_connectors);
if (connectors)
mode = crtc->current_mode->driver_private;
else
mode = NULL;
if (drmModeSetCrtc (manager_kms->fd,
crtc->crtc_id,
fb_id,
x, y,
connectors, n_connectors,
mode) != 0)
{
g_warning ("Failed to set CRTC mode %s: %m", crtc->current_mode->name);
return FALSE;
}
g_free (connectors);
return TRUE;
}
static void
invoke_flip_closure (GClosure *flip_closure)
{
GValue param = G_VALUE_INIT;
g_value_init (&param, G_TYPE_POINTER);
g_value_set_pointer (&param, flip_closure);
g_closure_invoke (flip_closure, NULL, 1, &param, NULL);
g_closure_unref (flip_closure);
}
gboolean
meta_monitor_manager_kms_is_crtc_active (MetaMonitorManagerKms *manager_kms,
MetaCrtc *crtc)
{
MetaMonitorManager *manager = META_MONITOR_MANAGER (manager_kms);
GList *l;
gboolean connected_crtc_found;
if (manager->power_save_mode != META_POWER_SAVE_ON)
return FALSE;
connected_crtc_found = FALSE;
for (l = manager->outputs; l; l = l->next)
{
MetaOutput *output = l->data;
if (output->crtc == crtc)
{
connected_crtc_found = TRUE;
break;
}
}
if (!connected_crtc_found)
return FALSE;
return TRUE;
}
gboolean
meta_monitor_manager_kms_flip_crtc (MetaMonitorManagerKms *manager_kms,
MetaCrtc *crtc,
int x,
int y,
uint32_t fb_id,
GClosure *flip_closure,
gboolean *fb_in_use)
{
MetaMonitorManager *manager = META_MONITOR_MANAGER (manager_kms);
uint32_t *connectors;
unsigned int n_connectors;
int ret = -1;
g_assert (manager->power_save_mode == META_POWER_SAVE_ON);
get_crtc_connectors (manager, crtc, &connectors, &n_connectors);
g_assert (n_connectors > 0);
if (!manager_kms->page_flips_not_supported)
{
ret = drmModePageFlip (manager_kms->fd,
crtc->crtc_id,
fb_id,
DRM_MODE_PAGE_FLIP_EVENT,
flip_closure);
if (ret != 0 && ret != -EACCES)
{
g_warning ("Failed to flip: %s", strerror (-ret));
manager_kms->page_flips_not_supported = TRUE;
}
}
if (manager_kms->page_flips_not_supported)
{
if (meta_monitor_manager_kms_apply_crtc_mode (manager_kms,
crtc,
x, y,
fb_id))
{
*fb_in_use = TRUE;
return FALSE;
}
}
if (ret != 0)
return FALSE;
*fb_in_use = TRUE;
g_closure_ref (flip_closure);
return TRUE;
}
static void
page_flip_handler (int fd,
unsigned int frame,
unsigned int sec,
unsigned int usec,
void *data)
{
GClosure *flip_closure = data;
invoke_flip_closure (flip_closure);
}
void
meta_monitor_manager_kms_wait_for_flip (MetaMonitorManagerKms *manager_kms)
{
drmEventContext evctx;
if (manager_kms->page_flips_not_supported)
return;
memset (&evctx, 0, sizeof evctx);
evctx.version = DRM_EVENT_CONTEXT_VERSION;
evctx.page_flip_handler = page_flip_handler;
drmHandleEvent (manager_kms->fd, &evctx);
}
static gboolean
meta_monitor_manager_kms_is_transform_handled (MetaMonitorManager *manager,
MetaCrtc *crtc,
@ -1046,16 +475,8 @@ meta_monitor_manager_kms_get_capabilities (MetaMonitorManager *manager)
META_EXPERIMENTAL_FEATURE_SCALE_MONITOR_FRAMEBUFFER))
capabilities |= META_MONITOR_MANAGER_CAPABILITY_LAYOUT_MODE;
switch (meta_renderer_native_get_mode (renderer_native))
{
case META_RENDERER_NATIVE_MODE_GBM:
capabilities |= META_MONITOR_MANAGER_CAPABILITY_MIRRORING;
break;
#ifdef HAVE_EGL_DEVICE
case META_RENDERER_NATIVE_MODE_EGL_DEVICE:
break;
#endif
}
if (meta_renderer_native_supports_mirroring (renderer_native))
capabilities |= META_MONITOR_MANAGER_CAPABILITY_MIRRORING;
return capabilities;
}
@ -1070,8 +491,8 @@ meta_monitor_manager_kms_get_max_screen_size (MetaMonitorManager *manager,
if (meta_is_stage_views_enabled ())
return FALSE;
*max_width = manager_kms->max_buffer_width;
*max_height = manager_kms->max_buffer_height;
meta_gpu_kms_get_max_buffer_size (manager_kms->primary_gpu,
max_width, max_height);
return TRUE;
}
@ -1093,6 +514,12 @@ meta_monitor_manager_kms_get_default_layout_mode (MetaMonitorManager *manager)
return META_LOGICAL_MONITOR_LAYOUT_MODE_PHYSICAL;
}
MetaGpuKms *
meta_monitor_manager_kms_get_primary_gpu (MetaMonitorManagerKms *manager_kms)
{
return manager_kms->primary_gpu;
}
static guint
count_devices_with_connectors (const char *seat_id,
GList *devices)
@ -1256,64 +683,34 @@ out:
}
static gboolean
open_primary_gpu (MetaMonitorManagerKms *manager_kms,
int *fd_out,
char **kms_file_path_out,
GError **error)
meta_monitor_manager_kms_initable_init (GInitable *initable,
GCancellable *cancellable,
GError **error)
{
MetaMonitorManager *manager = META_MONITOR_MANAGER (manager_kms);
MetaBackend *backend = meta_monitor_manager_get_backend (manager);
MetaBackendNative *backend_native = META_BACKEND_NATIVE (backend);
MetaLauncher *launcher = meta_backend_native_get_launcher (backend_native);
g_autofree char *path = NULL;
int fd;
MetaMonitorManagerKms *manager_kms = META_MONITOR_MANAGER_KMS (initable);
const char *subsystems[2] = { "drm", NULL };
g_autofree char *primary_gpu_path;
path = get_primary_gpu_path (manager_kms);
if (!path)
manager_kms->udev = g_udev_client_new (subsystems);
primary_gpu_path = get_primary_gpu_path (manager_kms);
if (!primary_gpu_path)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND,
"Could not find drm kms device");
return FALSE;
}
fd = meta_launcher_open_restricted (launcher, path, error);
if (fd == -1)
manager_kms->primary_gpu = meta_gpu_kms_new (manager_kms,
primary_gpu_path,
error);
if (!manager_kms->primary_gpu)
return FALSE;
*fd_out = fd;
*kms_file_path_out = g_steal_pointer (&path);
return TRUE;
}
static gboolean
meta_monitor_manager_kms_initable_init (GInitable *initable,
GCancellable *cancellable,
GError **error)
{
MetaMonitorManagerKms *manager_kms = META_MONITOR_MANAGER_KMS (initable);
GSource *source;
const char *subsystems[2] = { "drm", NULL };
manager_kms->udev = g_udev_client_new (subsystems);
if (!open_primary_gpu (manager_kms,
&manager_kms->fd,
&manager_kms->file_path,
error))
return FALSE;
drmSetClientCap (manager_kms->fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
meta_monitor_manager_kms_connect_uevent_handler (manager_kms);
source = g_source_new (&kms_event_funcs, sizeof (MetaKmsSource));
manager_kms->source = (MetaKmsSource *) source;
manager_kms->source->fd_tag = g_source_add_unix_fd (source,
manager_kms->fd,
G_IO_IN | G_IO_ERR);
manager_kms->source->manager_kms = manager_kms;
g_source_attach (source, NULL);
meta_monitor_manager_add_gpu (META_MONITOR_MANAGER (manager_kms),
META_GPU (manager_kms->primary_gpu));
return TRUE;
}
@ -1334,29 +731,9 @@ meta_monitor_manager_kms_dispose (GObject *object)
G_OBJECT_CLASS (meta_monitor_manager_kms_parent_class)->dispose (object);
}
static void
meta_monitor_manager_kms_finalize (GObject *object)
{
MetaMonitorManagerKms *manager_kms = META_MONITOR_MANAGER_KMS (object);
MetaMonitorManager *manager = META_MONITOR_MANAGER (manager_kms);
MetaBackend *backend = meta_monitor_manager_get_backend (manager);
MetaBackendNative *backend_native = META_BACKEND_NATIVE (backend);
MetaLauncher *launcher = meta_backend_native_get_launcher (backend_native);
if (manager_kms->fd != -1)
meta_launcher_close_restricted (launcher, manager_kms->fd);
g_clear_pointer (&manager_kms->file_path, g_free);
free_resources (manager_kms);
g_source_destroy ((GSource *) manager_kms->source);
G_OBJECT_CLASS (meta_monitor_manager_kms_parent_class)->finalize (object);
}
static void
meta_monitor_manager_kms_init (MetaMonitorManagerKms *manager_kms)
{
manager_kms->fd = -1;
}
static void
@ -1366,9 +743,7 @@ meta_monitor_manager_kms_class_init (MetaMonitorManagerKmsClass *klass)
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->dispose = meta_monitor_manager_kms_dispose;
object_class->finalize = meta_monitor_manager_kms_finalize;
manager_class->read_current = meta_monitor_manager_kms_read_current;
manager_class->read_edid = meta_monitor_manager_kms_read_edid;
manager_class->ensure_initial_config = meta_monitor_manager_kms_ensure_initial_config;
manager_class->apply_monitors_config = meta_monitor_manager_kms_apply_monitors_config;

42
src/backends/native/meta-monitor-manager-kms.h
View file

@ -28,53 +28,17 @@
#include "meta-monitor-manager-private.h"
typedef struct _MetaGpuKms MetaGpuKms;
#define META_TYPE_MONITOR_MANAGER_KMS (meta_monitor_manager_kms_get_type ())
G_DECLARE_FINAL_TYPE (MetaMonitorManagerKms, meta_monitor_manager_kms,
META, MONITOR_MANAGER_KMS,
MetaMonitorManager)
typedef struct _MetaKmsResources
{
drmModeRes *resources;
drmModeEncoder **encoders;
unsigned int n_encoders;
} MetaKmsResources;
typedef void (*MetaKmsFlipCallback) (void *user_data);
int meta_monitor_manager_kms_get_fd (MetaMonitorManagerKms *manager_kms);
const char * meta_monitor_manager_kms_get_file_path (MetaMonitorManagerKms *manager_kms);
gboolean meta_drm_mode_equal (const drmModeModeInfo *one,
const drmModeModeInfo *two);
MetaCrtcMode * meta_monitor_manager_kms_get_mode_from_drm_mode (MetaMonitorManagerKms *manager_kms,
const drmModeModeInfo *drm_mode);
gboolean meta_monitor_manager_kms_apply_crtc_mode (MetaMonitorManagerKms *manager_kms,
MetaCrtc *crtc,
int x,
int y,
uint32_t fb_id);
gboolean meta_monitor_manager_kms_is_crtc_active (MetaMonitorManagerKms *manager_kms,
MetaCrtc *crtc);
gboolean meta_monitor_manager_kms_flip_crtc (MetaMonitorManagerKms *manager_kms,
MetaCrtc *crtc,
int x,
int y,
uint32_t fb_id,
GClosure *flip_closure,
gboolean *fb_in_use);
void meta_monitor_manager_kms_wait_for_flip (MetaMonitorManagerKms *manager_kms);
MetaGpuKms * meta_monitor_manager_kms_get_primary_gpu (MetaMonitorManagerKms *manager_kms);
void meta_monitor_manager_kms_pause (MetaMonitorManagerKms *manager_kms);
void meta_monitor_manager_kms_resume (MetaMonitorManagerKms *manager_kms);
float meta_calculate_drm_mode_refresh_rate (const drmModeModeInfo *mode);
#endif /* META_MONITOR_MANAGER_KMS_H */

90
src/backends/native/meta-output-kms.c
View file

@ -30,7 +30,6 @@
#include "backends/meta-crtc.h"
#include "backends/native/meta-crtc-kms.h"
#include "backends/native/meta-default-modes.h"
#include "backends/native/meta-monitor-manager-kms.h"
#define SYNC_TOLERANCE 0.01 /* 1 percent */
@ -77,16 +76,14 @@ meta_output_kms_set_power_save_mode (MetaOutput *output,
uint64_t state)
{
MetaOutputKms *output_kms = output->driver_private;
MetaMonitorManager *monitor_manager =
meta_output_get_monitor_manager (output);
MetaMonitorManagerKms *monitor_manager_kms =
META_MONITOR_MANAGER_KMS (monitor_manager);
MetaGpu *gpu = meta_output_get_gpu (output);
MetaGpuKms *gpu_kms = META_GPU_KMS (gpu);
if (output_kms->dpms_prop_id != 0)
{
int fd;
fd = meta_monitor_manager_kms_get_fd (monitor_manager_kms);
fd = meta_gpu_kms_get_fd (gpu_kms);
if (drmModeObjectSetProperty (fd, output->winsys_id,
DRM_MODE_OBJECT_CONNECTOR,
output_kms->dpms_prop_id, state) < 0)
@ -113,14 +110,14 @@ meta_output_kms_can_clone (MetaOutput *output,
}
static drmModePropertyBlobPtr
read_edid_blob (MetaMonitorManagerKms *monitor_manager_kms,
uint32_t edid_blob_id,
GError **error)
read_edid_blob (MetaGpuKms *gpu_kms,
uint32_t edid_blob_id,
GError **error)
{
int fd;
drmModePropertyBlobPtr edid_blob = NULL;
fd = meta_monitor_manager_kms_get_fd (monitor_manager_kms);
fd = meta_gpu_kms_get_fd (gpu_kms);
edid_blob = drmModeGetPropertyBlob (fd, edid_blob_id);
if (!edid_blob)
{
@ -133,16 +130,16 @@ read_edid_blob (MetaMonitorManagerKms *monitor_manager_kms,
}
static GBytes *
read_output_edid (MetaMonitorManagerKms *monitor_manager_kms,
MetaOutput *output,
GError **error)
read_output_edid (MetaGpuKms *gpu_kms,
MetaOutput *output,
GError **error)
{
MetaOutputKms *output_kms = output->driver_private;
drmModePropertyBlobPtr edid_blob;
g_assert (output_kms->edid_blob_id != 0);
edid_blob = read_edid_blob (monitor_manager_kms, output_kms->edid_blob_id, error);
edid_blob = read_edid_blob (gpu_kms, output_kms->edid_blob_id, error);
if (!edid_blob)
return NULL;
@ -159,8 +156,8 @@ read_output_edid (MetaMonitorManagerKms *monitor_manager_kms,
}
static gboolean
output_get_tile_info (MetaMonitorManagerKms *monitor_manager_kms,
MetaOutput *output)
output_get_tile_info (MetaGpuKms *gpu_kms,
MetaOutput *output)
{
MetaOutputKms *output_kms = output->driver_private;
int fd;
@ -169,7 +166,7 @@ output_get_tile_info (MetaMonitorManagerKms *monitor_manager_kms,
if (output_kms->tile_blob_id == 0)
return FALSE;
fd = meta_monitor_manager_kms_get_fd (monitor_manager_kms);
fd = meta_gpu_kms_get_fd (gpu_kms);
tile_blob = drmModeGetPropertyBlob (fd, output_kms->tile_blob_id);
if (!tile_blob)
{
@ -211,17 +208,15 @@ GBytes *
meta_output_kms_read_edid (MetaOutput *output)
{
MetaOutputKms *output_kms = output->driver_private;
MetaMonitorManager *monitor_manager =
meta_output_get_monitor_manager (output);
MetaMonitorManagerKms *monitor_manager_kms =
META_MONITOR_MANAGER_KMS (monitor_manager);
MetaGpu *gpu = meta_output_get_gpu (output);
MetaGpuKms *gpu_kms = META_GPU_KMS (gpu);
GError *error = NULL;
GBytes *edid;
if (output_kms->edid_blob_id == 0)
return NULL;
edid = read_output_edid (monitor_manager_kms, output, &error);
edid = read_output_edid (gpu_kms, output, &error);
if (!edid)
{
g_warning ("Failed to read EDID from '%s': %s",
@ -234,14 +229,14 @@ meta_output_kms_read_edid (MetaOutput *output)
}
static void
find_connector_properties (MetaMonitorManagerKms *monitor_manager_kms,
MetaOutputKms *output_kms)
find_connector_properties (MetaGpuKms *gpu_kms,
MetaOutputKms *output_kms)
{
drmModeConnector *connector = output_kms->connector;
int fd;
int i;
fd = meta_monitor_manager_kms_get_fd (monitor_manager_kms);
fd = meta_gpu_kms_get_fd (gpu_kms);
output_kms->hotplug_mode_update = 0;
output_kms->suggested_x = -1;
@ -327,8 +322,8 @@ meta_output_destroy_notify (MetaOutput *output)
}
static void
add_common_modes (MetaOutput *output,
MetaMonitorManagerKms *monitor_manager_kms)
add_common_modes (MetaOutput *output,
MetaGpuKms *gpu_kms)
{
GPtrArray *array;
unsigned i;
@ -365,8 +360,8 @@ add_common_modes (MetaOutput *output,
refresh_rate > max_refresh_rate)
continue;
crtc_mode = meta_monitor_manager_kms_get_mode_from_drm_mode (monitor_manager_kms,
drm_mode);
crtc_mode = meta_gpu_kms_get_mode_from_drm_mode (gpu_kms,
drm_mode);
g_ptr_array_add (array, crtc_mode);
}
@ -397,8 +392,8 @@ compare_modes (const void *one,
}
static void
init_output_modes (MetaOutput *output,
MetaMonitorManagerKms *monitor_manager_kms)
init_output_modes (MetaOutput *output,
MetaGpuKms *gpu_kms)
{
MetaOutputKms *output_kms = output->driver_private;
unsigned int i;
@ -412,9 +407,7 @@ init_output_modes (MetaOutput *output,
MetaCrtcMode *crtc_mode;
drm_mode = &output_kms->connector->modes[i];
crtc_mode =
meta_monitor_manager_kms_get_mode_from_drm_mode (monitor_manager_kms,
drm_mode);
crtc_mode = meta_gpu_kms_get_mode_from_drm_mode (gpu_kms, drm_mode);
output->modes[i] = crtc_mode;
if (output_kms->connector->modes[i].type & DRM_MODE_TYPE_PREFERRED)
output->preferred_mode = output->modes[i];
@ -425,13 +418,12 @@ init_output_modes (MetaOutput *output,
}
MetaOutput *
meta_create_kms_output (MetaMonitorManager *monitor_manager,
drmModeConnector *connector,
MetaKmsResources *resources,
MetaOutput *old_output)
meta_create_kms_output (MetaGpuKms *gpu_kms,
drmModeConnector *connector,
MetaKmsResources *resources,
MetaOutput *old_output)
{
MetaMonitorManagerKms *monitor_manager_kms =
META_MONITOR_MANAGER_KMS (monitor_manager);
MetaGpu *gpu = META_GPU (gpu_kms);
MetaOutput *output;
MetaOutputKms *output_kms;
GArray *crtcs;
@ -447,7 +439,7 @@ meta_create_kms_output (MetaMonitorManager *monitor_manager,
output->driver_private = output_kms;
output->driver_notify = (GDestroyNotify) meta_output_destroy_notify;
output->monitor_manager = monitor_manager;
output->gpu = gpu;
output->winsys_id = connector->connector_id;
output->name = make_output_name (connector);
output->width_mm = connector->mmWidth;
@ -477,16 +469,16 @@ meta_create_kms_output (MetaMonitorManager *monitor_manager,
}
output_kms->connector = connector;
find_connector_properties (monitor_manager_kms, output_kms);
find_connector_properties (gpu_kms, output_kms);
init_output_modes (output, monitor_manager_kms);
init_output_modes (output, gpu_kms);
/* FIXME: MSC feature bit? */
/* Presume that if the output supports scaling, then we have
* a panel fitter capable of adjusting any mode to suit.
*/
if (output_kms->has_scaling)
add_common_modes (output, monitor_manager_kms);
add_common_modes (output, gpu_kms);
qsort (output->modes, output->n_modes,
sizeof (MetaCrtcMode *), compare_modes);
@ -494,7 +486,7 @@ meta_create_kms_output (MetaMonitorManager *monitor_manager,
output_kms->n_encoders = connector->count_encoders;
output_kms->encoders = g_new0 (drmModeEncoderPtr, output_kms->n_encoders);
fd = meta_monitor_manager_kms_get_fd (monitor_manager_kms);
fd = meta_gpu_kms_get_fd (gpu_kms);
crtc_mask = ~(unsigned int) 0;
for (i = 0; i < output_kms->n_encoders; i++)
@ -516,7 +508,7 @@ meta_create_kms_output (MetaMonitorManager *monitor_manager,
crtcs = g_array_new (FALSE, FALSE, sizeof (MetaCrtc*));
for (l = monitor_manager->crtcs, i = 0; l; l = l->next, i++)
for (l = meta_gpu_get_crtcs (gpu), i = 0; l; l = l->next, i++)
{
if (crtc_mask & (1 << i))
{
@ -531,7 +523,7 @@ meta_create_kms_output (MetaMonitorManager *monitor_manager,
if (output_kms->current_encoder && output_kms->current_encoder->crtc_id != 0)
{
for (l = monitor_manager->crtcs; l; l = l->next)
for (l = meta_gpu_get_crtcs (gpu); l; l = l->next)
{
MetaCrtc *crtc = l->data;
@ -566,7 +558,7 @@ meta_create_kms_output (MetaMonitorManager *monitor_manager,
{
GError *error = NULL;
edid = read_output_edid (monitor_manager_kms, output, &error);
edid = read_output_edid (gpu_kms, output, &error);
if (!edid)
{
g_warning ("Failed to read EDID blob from %s: %s",
@ -585,7 +577,7 @@ meta_create_kms_output (MetaMonitorManager *monitor_manager,
/* MetaConnectorType matches DRM's connector types */
output->connector_type = (MetaConnectorType) connector->connector_type;
output_get_tile_info (monitor_manager_kms, output);
output_get_tile_info (gpu_kms, output);
/* FIXME: backlight is a very driver specific thing unfortunately,
every DDX does its own thing, and the dumb KMS API does not include it.

10
src/backends/native/meta-output-kms.h
View file

@ -23,7 +23,7 @@
#define META_OUTPUT_KMS_H
#include "backends/meta-output.h"
#include "backends/native/meta-monitor-manager-kms.h"
#include "backends/native/meta-gpu-kms.h"
void meta_output_kms_set_underscan (MetaOutput *output);
@ -35,9 +35,9 @@ gboolean meta_output_kms_can_clone (MetaOutput *output,
GBytes * meta_output_kms_read_edid (MetaOutput *output);
MetaOutput * meta_create_kms_output (MetaMonitorManager *monitor_manager,
drmModeConnector *connector,
MetaKmsResources *resources,
MetaOutput *old_output);
MetaOutput * meta_create_kms_output (MetaGpuKms *gpu_kms,
drmModeConnector *connector,
MetaKmsResources *resources,
MetaOutput *old_output);
#endif /* META_OUTPUT_KMS_H */

602
src/backends/native/meta-renderer-native.c
View file

File diff suppressed because it is too large Load diff

6
src/backends/native/meta-renderer-native.h
View file

@ -25,10 +25,12 @@
#ifndef META_RENDERER_NATIVE_H
#define META_RENDERER_NATIVE_H
#include <gbm.h>
#include <glib-object.h>
#include <xf86drmMode.h>
#include "backends/meta-renderer.h"
#include "backends/native/meta-gpu-kms.h"
#include "backends/native/meta-monitor-manager-kms.h"
#define META_TYPE_RENDERER_NATIVE (meta_renderer_native_get_type ())
@ -47,9 +49,9 @@ typedef enum _MetaRendererNativeMode
MetaRendererNative * meta_renderer_native_new (MetaMonitorManagerKms *monitor_manager_kms,
GError **error);
MetaRendererNativeMode meta_renderer_native_get_mode (MetaRendererNative *renderer_native);
struct gbm_device * meta_gbm_device_from_gpu (MetaGpuKms *gpu_kms);
struct gbm_device * meta_renderer_native_get_gbm (MetaRendererNative *renderer_native);
gboolean meta_renderer_native_supports_mirroring (MetaRendererNative *renderer_native);
void meta_renderer_native_queue_modes_reset (MetaRendererNative *renderer_native);

18
src/backends/x11/meta-crtc-xrandr.c
View file

@ -39,6 +39,9 @@
#include <X11/Xlib-xcb.h>
#include <xcb/randr.h>
#include "backends/meta-crtc.h"
#include "backends/x11/meta-crtc-xrandr.h"
#include "backends/x11/meta-gpu-xrandr.h"
#include "backends/x11/meta-monitor-manager-xrandr.h"
#define ALL_TRANSFORMS ((1 << (META_MONITOR_TRANSFORM_FLIPPED_270 + 1)) - 1)
@ -55,7 +58,9 @@ meta_crtc_xrandr_set_config (MetaCrtc *crtc,
int n_outputs,
xcb_timestamp_t *out_timestamp)
{
MetaMonitorManager *monitor_manager = meta_crtc_get_monitor_manager (crtc);
MetaGpu *gpu = meta_crtc_get_gpu (crtc);
MetaGpuXrandr *gpu_xrandr = META_GPU_XRANDR (gpu);
MetaMonitorManager *monitor_manager = meta_gpu_get_monitor_manager (gpu);
MetaMonitorManagerXrandr *monitor_manager_xrandr =
META_MONITOR_MANAGER_XRANDR (monitor_manager);
Display *xdisplay;
@ -68,8 +73,7 @@ meta_crtc_xrandr_set_config (MetaCrtc *crtc,
xdisplay = meta_monitor_manager_xrandr_get_xdisplay (monitor_manager_xrandr);
xcb_conn = XGetXCBConnection (xdisplay);
resources =
meta_monitor_manager_xrandr_get_resources (monitor_manager_xrandr);
resources = meta_gpu_xrandr_get_resources (gpu_xrandr);
config_timestamp = resources->configTimestamp;
cookie = xcb_randr_set_crtc_config (xcb_conn,
xrandr_crtc,
@ -168,17 +172,18 @@ meta_monitor_transform_from_xrandr_all (Rotation rotation)
}
MetaCrtc *
meta_create_xrandr_crtc (MetaMonitorManager *monitor_manager,
meta_create_xrandr_crtc (MetaGpuXrandr *gpu_xrandr,
XRRCrtcInfo *xrandr_crtc,
RRCrtc crtc_id,
XRRScreenResources *resources)
{
MetaCrtc *crtc;
unsigned int i;
GList *modes;
crtc = g_object_new (META_TYPE_CRTC, NULL);
crtc->monitor_manager = monitor_manager;
crtc->gpu = META_GPU (gpu_xrandr);
crtc->crtc_id = crtc_id;
crtc->rect.x = xrandr_crtc->x;
crtc->rect.y = xrandr_crtc->y;
@ -190,11 +195,12 @@ meta_create_xrandr_crtc (MetaMonitorManager *monitor_manager,
crtc->all_transforms =
meta_monitor_transform_from_xrandr_all (xrandr_crtc->rotations);
modes = meta_gpu_get_modes (crtc->gpu);
for (i = 0; i < (unsigned int) resources->nmode; i++)
{
if (resources->modes[i].id == xrandr_crtc->mode)
{
crtc->current_mode = g_list_nth_data (monitor_manager->modes, i);
crtc->current_mode = g_list_nth_data (modes, i);
break;
}
}

3
src/backends/x11/meta-crtc-xrandr.h
View file

@ -26,6 +26,7 @@
#include <xcb/randr.h>
#include "backends/meta-crtc.h"
#include "backends/x11/meta-gpu-xrandr.h"
gboolean meta_crtc_xrandr_set_config (MetaCrtc *crtc,
xcb_randr_crtc_t xrandr_crtc,
@ -38,7 +39,7 @@ gboolean meta_crtc_xrandr_set_config (MetaCrtc *crtc,
int n_outputs,
xcb_timestamp_t *out_timestamp);
MetaCrtc * meta_create_xrandr_crtc (MetaMonitorManager *monitor_manager,
MetaCrtc * meta_create_xrandr_crtc (MetaGpuXrandr *gpu_xrandr,
XRRCrtcInfo *xrandr_crtc,
RRCrtc crtc_id,
XRRScreenResources *resources);

296
src/backends/x11/meta-gpu-xrandr.c Normal file
View file

@ -0,0 +1,296 @@
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/*
* Copyright (C) 2001, 2002 Havoc Pennington
* Copyright (C) 2002, 2003 Red Hat Inc.
* Some ICCCM manager selection code derived from fvwm2,
* Copyright (C) 2001 Dominik Vogt, Matthias Clasen, and fvwm2 team
* Copyright (C) 2003 Rob Adams
* Copyright (C) 2004-2006 Elijah Newren
* Copyright (C) 2013-2017 Red Hat Inc.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include "backends/x11/meta-gpu-xrandr.h"
#include <string.h>
#include <X11/extensions/dpms.h>
#include <X11/Xlibint.h>
#include "backends/meta-output.h"
#include "backends/x11/meta-crtc-xrandr.h"
#include "backends/x11/meta-monitor-manager-xrandr.h"
#include "backends/x11/meta-output-xrandr.h"
struct _MetaGpuXrandr
{
MetaGpu parent;
XRRScreenResources *resources;
int max_screen_width;
int max_screen_height;
};
G_DEFINE_TYPE (MetaGpuXrandr, meta_gpu_xrandr, META_TYPE_GPU)
XRRScreenResources *
meta_gpu_xrandr_get_resources (MetaGpuXrandr *gpu_xrandr)
{
return gpu_xrandr->resources;
}
void
meta_gpu_xrandr_get_max_screen_size (MetaGpuXrandr *gpu_xrandr,
int *max_width,
int *max_height)
{
*max_width = gpu_xrandr->max_screen_width;
*max_height = gpu_xrandr->max_screen_height;
}
static int
compare_outputs (const void *one,
const void *two)
{
const MetaOutput *o_one = one, *o_two = two;
return strcmp (o_one->name, o_two->name);
}
static char *
get_xmode_name (XRRModeInfo *xmode)
{
int width = xmode->width;
int height = xmode->height;
return g_strdup_printf ("%dx%d", width, height);
}
static gboolean
meta_gpu_xrandr_read_current (MetaGpu *gpu,
GError **error)
{
MetaGpuXrandr *gpu_xrandr = META_GPU_XRANDR (gpu);
MetaMonitorManager *monitor_manager = meta_gpu_get_monitor_manager (gpu);
MetaMonitorManagerXrandr *monitor_manager_xrandr =
META_MONITOR_MANAGER_XRANDR (monitor_manager);
Display *xdisplay =
meta_monitor_manager_xrandr_get_xdisplay (monitor_manager_xrandr);
XRRScreenResources *resources;
RROutput primary_output;
unsigned int i, j;
GList *l;
int min_width, min_height;
Screen *screen;
BOOL dpms_capable, dpms_enabled;
CARD16 dpms_state;
GList *outputs = NULL;
GList *modes = NULL;
GList *crtcs = NULL;
if (gpu_xrandr->resources)
XRRFreeScreenResources (gpu_xrandr->resources);
gpu_xrandr->resources = NULL;
dpms_capable = DPMSCapable (xdisplay);
if (dpms_capable &&
DPMSInfo (xdisplay, &dpms_state, &dpms_enabled) &&
dpms_enabled)
{
switch (dpms_state)
{
case DPMSModeOn:
monitor_manager->power_save_mode = META_POWER_SAVE_ON;
break;
case DPMSModeStandby:
monitor_manager->power_save_mode = META_POWER_SAVE_STANDBY;
break;
case DPMSModeSuspend:
monitor_manager->power_save_mode = META_POWER_SAVE_SUSPEND;
break;
case DPMSModeOff:
monitor_manager->power_save_mode = META_POWER_SAVE_OFF;
break;
default:
monitor_manager->power_save_mode = META_POWER_SAVE_UNSUPPORTED;
break;
}
}
else
{
monitor_manager->power_save_mode = META_POWER_SAVE_UNSUPPORTED;
}
XRRGetScreenSizeRange (xdisplay, DefaultRootWindow (xdisplay),
&min_width,
&min_height,
&gpu_xrandr->max_screen_width,
&gpu_xrandr->max_screen_height);
screen = ScreenOfDisplay (xdisplay, DefaultScreen (xdisplay));
/* This is updated because we called XRRUpdateConfiguration. */
monitor_manager->screen_width = WidthOfScreen (screen);
monitor_manager->screen_height = HeightOfScreen (screen);
resources = XRRGetScreenResourcesCurrent (xdisplay,
DefaultRootWindow (xdisplay));
if (!resources)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Failed to retrieve Xrandr screen resources");
return FALSE;
}
gpu_xrandr->resources = resources;
outputs = NULL;
modes = NULL;
crtcs = NULL;
for (i = 0; i < (unsigned)resources->nmode; i++)
{
XRRModeInfo *xmode = &resources->modes[i];
MetaCrtcMode *mode;
mode = g_object_new (META_TYPE_CRTC_MODE, NULL);
mode->mode_id = xmode->id;
mode->width = xmode->width;
mode->height = xmode->height;
mode->refresh_rate = (xmode->dotClock /
((float)xmode->hTotal * xmode->vTotal));
mode->flags = xmode->modeFlags;
mode->name = get_xmode_name (xmode);
modes = g_list_append (modes, mode);
}
meta_gpu_take_modes (gpu, modes);
for (i = 0; i < (unsigned)resources->ncrtc; i++)
{
XRRCrtcInfo *xrandr_crtc;
RRCrtc crtc_id;
MetaCrtc *crtc;
crtc_id = resources->crtcs[i];
xrandr_crtc = XRRGetCrtcInfo (xdisplay,
resources, crtc_id);
crtc = meta_create_xrandr_crtc (gpu_xrandr,
xrandr_crtc, crtc_id, resources);
XRRFreeCrtcInfo (xrandr_crtc);
crtcs = g_list_append (crtcs, crtc);
}
meta_gpu_take_crtcs (gpu, crtcs);
primary_output = XRRGetOutputPrimary (xdisplay,
DefaultRootWindow (xdisplay));
for (i = 0; i < (unsigned)resources->noutput; i++)
{
RROutput output_id;
XRROutputInfo *xrandr_output;
output_id = resources->outputs[i];
xrandr_output = XRRGetOutputInfo (xdisplay,
resources, output_id);
if (!xrandr_output)
continue;
if (xrandr_output->connection != RR_Disconnected)
{
MetaOutput *output;
output = meta_create_xrandr_output (gpu_xrandr,
xrandr_output,
output_id,
primary_output);
if (output)
outputs = g_list_prepend (outputs, output);
}
XRRFreeOutputInfo (xrandr_output);
}
/* Sort the outputs for easier handling in MetaMonitorConfig */
outputs = g_list_sort (outputs, compare_outputs);
meta_gpu_take_outputs (gpu, outputs);
/* Now fix the clones */
for (l = outputs; l; l = l->next)
{
MetaOutput *output = l->data;
GList *k;
for (j = 0; j < output->n_possible_clones; j++)
{
RROutput clone = GPOINTER_TO_INT (output->possible_clones[j]);
for (k = outputs; k; k = k->next)
{
MetaOutput *possible_clone = k->data;
if (clone == (XID) possible_clone->winsys_id)
{
output->possible_clones[j] = possible_clone;
break;
}
}
}
}
return TRUE;
}
MetaGpuXrandr *
meta_gpu_xrandr_new (MetaMonitorManagerXrandr *monitor_manager_xrandr)
{
return g_object_new (META_TYPE_GPU_XRANDR,
"monitor-manager", monitor_manager_xrandr,
NULL);
}
static void
meta_gpu_xrandr_finalize (GObject *object)
{
MetaGpuXrandr *gpu_xrandr = META_GPU_XRANDR (object);
g_clear_pointer (&gpu_xrandr->resources,
XRRFreeScreenResources);
G_OBJECT_CLASS (meta_gpu_xrandr_parent_class)->finalize (object);
}
static void
meta_gpu_xrandr_init (MetaGpuXrandr *gpu_xrandr)
{
}
static void
meta_gpu_xrandr_class_init (MetaGpuXrandrClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
MetaGpuClass *gpu_class = META_GPU_CLASS (klass);
object_class->finalize = meta_gpu_xrandr_finalize;
gpu_class->read_current = meta_gpu_xrandr_read_current;
}

42
src/backends/x11/meta-gpu-xrandr.h Normal file
View file

@ -0,0 +1,42 @@
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/*
* Copyright (C) 2017 Red Hat
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*/
#ifndef META_GPU_XRANDR_H
#define META_GPU_XRANDR_H
#include <glib-object.h>
#include <X11/extensions/Xrandr.h>
#include "backends/meta-gpu.h"
#include "backends/x11/meta-monitor-manager-xrandr.h"
#define META_TYPE_GPU_XRANDR (meta_gpu_xrandr_get_type ())
G_DECLARE_FINAL_TYPE (MetaGpuXrandr, meta_gpu_xrandr, META, GPU_XRANDR, MetaGpu)
XRRScreenResources * meta_gpu_xrandr_get_resources (MetaGpuXrandr *gpu_xrandr);
void meta_gpu_xrandr_get_max_screen_size (MetaGpuXrandr *gpu_xrandr,
int *max_width,
int *max_height);
MetaGpuXrandr * meta_gpu_xrandr_new (MetaMonitorManagerXrandr *monitor_manager_xrandr);
#endif /* META_GPU_XRANDR_H */

225
src/backends/x11/meta-monitor-manager-xrandr.c
View file

@ -45,6 +45,7 @@
#include "backends/meta-logical-monitor.h"
#include "backends/meta-output.h"
#include "backends/x11/meta-crtc-xrandr.h"
#include "backends/x11/meta-gpu-xrandr.h"
#include "backends/x11/meta-output-xrandr.h"
/* Look for DPI_FALLBACK in:
@ -57,19 +58,22 @@ struct _MetaMonitorManagerXrandr
MetaMonitorManager parent_instance;
Display *xdisplay;
XRRScreenResources *resources;
int rr_event_base;
int rr_error_base;
gboolean has_randr15;
/*
* The X server deals with multiple GPUs for us, soe just see what the X
* server gives us as one single GPU, even though it may actually be backed
* by multiple.
*/
MetaGpu *gpu;
xcb_timestamp_t last_xrandr_set_timestamp;
#ifdef HAVE_XRANDR15
GHashTable *tiled_monitor_atoms;
#endif /* HAVE_XRANDR15 */
int max_screen_width;
int max_screen_height;
};
struct _MetaMonitorManagerXrandrClass
@ -94,194 +98,12 @@ meta_monitor_manager_xrandr_get_xdisplay (MetaMonitorManagerXrandr *manager_xran
return manager_xrandr->xdisplay;
}
XRRScreenResources *
meta_monitor_manager_xrandr_get_resources (MetaMonitorManagerXrandr *manager_xrandr)
{
return manager_xrandr->resources;
}
gboolean
meta_monitor_manager_xrandr_has_randr15 (MetaMonitorManagerXrandr *manager_xrandr)
{
return manager_xrandr->has_randr15;
}
static int
compare_outputs (const void *one,
const void *two)
{
const MetaOutput *o_one = one, *o_two = two;
return strcmp (o_one->name, o_two->name);
}
static char *
get_xmode_name (XRRModeInfo *xmode)
{
int width = xmode->width;
int height = xmode->height;
return g_strdup_printf ("%dx%d", width, height);
}
static void
meta_monitor_manager_xrandr_read_current (MetaMonitorManager *manager)
{
MetaMonitorManagerXrandr *manager_xrandr = META_MONITOR_MANAGER_XRANDR (manager);
XRRScreenResources *resources;
RROutput primary_output;
unsigned int i, j;
GList *l;
int min_width, min_height;
Screen *screen;
BOOL dpms_capable, dpms_enabled;
CARD16 dpms_state;
if (manager_xrandr->resources)
XRRFreeScreenResources (manager_xrandr->resources);
manager_xrandr->resources = NULL;
dpms_capable = DPMSCapable (manager_xrandr->xdisplay);
if (dpms_capable &&
DPMSInfo (manager_xrandr->xdisplay, &dpms_state, &dpms_enabled) &&
dpms_enabled)
{
switch (dpms_state)
{
case DPMSModeOn:
manager->power_save_mode = META_POWER_SAVE_ON;
break;
case DPMSModeStandby:
manager->power_save_mode = META_POWER_SAVE_STANDBY;
break;
case DPMSModeSuspend:
manager->power_save_mode = META_POWER_SAVE_SUSPEND;
break;
case DPMSModeOff:
manager->power_save_mode = META_POWER_SAVE_OFF;
break;
default:
manager->power_save_mode = META_POWER_SAVE_UNSUPPORTED;
break;
}
}
else
{
manager->power_save_mode = META_POWER_SAVE_UNSUPPORTED;
}
XRRGetScreenSizeRange (manager_xrandr->xdisplay, DefaultRootWindow (manager_xrandr->xdisplay),
&min_width,
&min_height,
&manager_xrandr->max_screen_width,
&manager_xrandr->max_screen_height);
screen = ScreenOfDisplay (manager_xrandr->xdisplay,
DefaultScreen (manager_xrandr->xdisplay));
/* This is updated because we called RRUpdateConfiguration below */
manager->screen_width = WidthOfScreen (screen);
manager->screen_height = HeightOfScreen (screen);
resources = XRRGetScreenResourcesCurrent (manager_xrandr->xdisplay,
DefaultRootWindow (manager_xrandr->xdisplay));
if (!resources)
return;
manager_xrandr->resources = resources;
manager->outputs = NULL;
manager->modes = NULL;
manager->crtcs = NULL;
for (i = 0; i < (unsigned)resources->nmode; i++)
{
XRRModeInfo *xmode = &resources->modes[i];
MetaCrtcMode *mode;
mode = g_object_new (META_TYPE_CRTC_MODE, NULL);
mode->mode_id = xmode->id;
mode->width = xmode->width;
mode->height = xmode->height;
mode->refresh_rate = (xmode->dotClock /
((float)xmode->hTotal * xmode->vTotal));
mode->flags = xmode->modeFlags;
mode->name = get_xmode_name (xmode);
manager->modes = g_list_append (manager->modes, mode);
}
for (i = 0; i < (unsigned)resources->ncrtc; i++)
{
XRRCrtcInfo *xrandr_crtc;
RRCrtc crtc_id;
MetaCrtc *crtc;
crtc_id = resources->crtcs[i];
xrandr_crtc = XRRGetCrtcInfo (manager_xrandr->xdisplay,
resources, crtc_id);
crtc = meta_create_xrandr_crtc (manager, xrandr_crtc, crtc_id, resources);
XRRFreeCrtcInfo (xrandr_crtc);
manager->crtcs = g_list_append (manager->crtcs, crtc);
}
primary_output = XRRGetOutputPrimary (manager_xrandr->xdisplay,
DefaultRootWindow (manager_xrandr->xdisplay));
for (i = 0; i < (unsigned)resources->noutput; i++)
{
RROutput output_id;
XRROutputInfo *xrandr_output;
output_id = resources->outputs[i];
xrandr_output = XRRGetOutputInfo (manager_xrandr->xdisplay,
resources, output_id);
if (!xrandr_output)
continue;
if (xrandr_output->connection != RR_Disconnected)
{
MetaOutput *output;
output = meta_create_xrandr_output (manager,
xrandr_output,
output_id,
primary_output);
if (output)
manager->outputs = g_list_prepend (manager->outputs, output);
}
XRRFreeOutputInfo (xrandr_output);
}
/* Sort the outputs for easier handling in MetaMonitorConfig */
manager->outputs = g_list_sort (manager->outputs, compare_outputs);
/* Now fix the clones */
for (l = manager->outputs; l; l = l->next)
{
MetaOutput *output = l->data;
GList *k;
for (j = 0; j < output->n_possible_clones; j++)
{
RROutput clone = GPOINTER_TO_INT (output->possible_clones[j]);
for (k = manager->outputs; k; k = k->next)
{
MetaOutput *possible_clone = k->data;
if (clone == (XID) possible_clone->winsys_id)
{
output->possible_clones[j] = possible_clone;
break;
}
}
}
}
}
static GBytes *
meta_monitor_manager_xrandr_read_edid (MetaMonitorManager *manager,
MetaOutput *output)
@ -469,9 +291,11 @@ is_assignments_changed (MetaMonitorManager *manager,
MetaOutputInfo **output_infos,
unsigned int n_output_infos)
{
MetaMonitorManagerXrandr *manager_xrandr =
META_MONITOR_MANAGER_XRANDR (manager);
GList *l;
for (l = manager->crtcs; l; l = l->next)
for (l = meta_gpu_get_crtcs (manager_xrandr->gpu); l; l = l->next)
{
MetaCrtc *crtc = l->data;
@ -479,7 +303,7 @@ is_assignments_changed (MetaMonitorManager *manager,
return TRUE;
}
for (l = manager->outputs; l; l = l->next)
for (l = meta_gpu_get_outputs (manager_xrandr->gpu); l; l = l->next)
{
MetaOutput *output = l->data;
@ -564,7 +388,7 @@ apply_crtc_assignments (MetaMonitorManager *manager,
}
/* Disable CRTCs not mentioned in the list */
for (l = manager->crtcs; l; l = l->next)
for (l = meta_gpu_get_crtcs (manager_xrandr->gpu); l; l = l->next)
{
MetaCrtc *crtc = l->data;
@ -684,7 +508,7 @@ apply_crtc_assignments (MetaMonitorManager *manager,
}
/* Disable outputs not mentioned in the list */
for (l = manager->outputs; l; l = l->next)
for (l = meta_gpu_get_outputs (manager_xrandr->gpu); l; l = l->next)
{
MetaOutput *output = l->data;
@ -1038,8 +862,8 @@ meta_monitor_manager_xrandr_get_max_screen_size (MetaMonitorManager *manager,
MetaMonitorManagerXrandr *manager_xrandr =
META_MONITOR_MANAGER_XRANDR (manager);
*max_width = manager_xrandr->max_screen_width;
*max_height = manager_xrandr->max_screen_height;
meta_gpu_xrandr_get_max_screen_size (META_GPU_XRANDR (manager_xrandr->gpu),
max_width, max_height);
return TRUE;
}
@ -1061,6 +885,9 @@ meta_monitor_manager_xrandr_constructed (GObject *object)
manager_xrandr->xdisplay = meta_backend_x11_get_xdisplay (backend);
manager_xrandr->gpu = META_GPU (meta_gpu_xrandr_new (manager_xrandr));
meta_monitor_manager_add_gpu (manager, manager_xrandr->gpu);
if (!XRRQueryExtension (manager_xrandr->xdisplay,
&manager_xrandr->rr_event_base,
&manager_xrandr->rr_error_base))
@ -1099,9 +926,7 @@ meta_monitor_manager_xrandr_finalize (GObject *object)
{
MetaMonitorManagerXrandr *manager_xrandr = META_MONITOR_MANAGER_XRANDR (object);
if (manager_xrandr->resources)
XRRFreeScreenResources (manager_xrandr->resources);
manager_xrandr->resources = NULL;
g_clear_object (&manager_xrandr->gpu);
g_hash_table_destroy (manager_xrandr->tiled_monitor_atoms);
@ -1122,7 +947,6 @@ meta_monitor_manager_xrandr_class_init (MetaMonitorManagerXrandrClass *klass)
object_class->finalize = meta_monitor_manager_xrandr_finalize;
object_class->constructed = meta_monitor_manager_xrandr_constructed;
manager_class->read_current = meta_monitor_manager_xrandr_read_current;
manager_class->read_edid = meta_monitor_manager_xrandr_read_edid;
manager_class->ensure_initial_config = meta_monitor_manager_xrandr_ensure_initial_config;
manager_class->apply_monitors_config = meta_monitor_manager_xrandr_apply_monitors_config;
@ -1150,6 +974,8 @@ meta_monitor_manager_xrandr_handle_xevent (MetaMonitorManagerXrandr *manager_xra
XEvent *event)
{
MetaMonitorManager *manager = META_MONITOR_MANAGER (manager_xrandr);
MetaGpuXrandr *gpu_xrandr;
XRRScreenResources *resources;
gboolean is_hotplug;
gboolean is_our_configuration;
@ -1160,10 +986,11 @@ meta_monitor_manager_xrandr_handle_xevent (MetaMonitorManagerXrandr *manager_xra
meta_monitor_manager_read_current_state (manager);
gpu_xrandr = META_GPU_XRANDR (manager_xrandr->gpu);
resources = meta_gpu_xrandr_get_resources (gpu_xrandr);
is_hotplug = (manager_xrandr->resources->timestamp <
manager_xrandr->resources->configTimestamp);
is_our_configuration = (manager_xrandr->resources->timestamp ==
is_hotplug = resources->timestamp < resources->configTimestamp;
is_our_configuration = (resources->timestamp ==
manager_xrandr->last_xrandr_set_timestamp);
if (is_hotplug)
{

2
src/backends/x11/meta-monitor-manager-xrandr.h
View file

@ -33,8 +33,6 @@ G_DECLARE_FINAL_TYPE (MetaMonitorManagerXrandr, meta_monitor_manager_xrandr,
Display * meta_monitor_manager_xrandr_get_xdisplay (MetaMonitorManagerXrandr *manager_xrandr);
XRRScreenResources * meta_monitor_manager_xrandr_get_resources (MetaMonitorManagerXrandr *manager_xrandr);
gboolean meta_monitor_manager_xrandr_has_randr15 (MetaMonitorManagerXrandr *manager_xrandr);
gboolean meta_monitor_manager_xrandr_handle_xevent (MetaMonitorManagerXrandr *manager,

40
src/backends/x11/meta-output-xrandr.c
View file

@ -48,8 +48,8 @@
static Display *
xdisplay_from_output (MetaOutput *output)
{
MetaMonitorManager *monitor_manager =
meta_output_get_monitor_manager (output);
MetaGpu *gpu = meta_output_get_gpu (output);
MetaMonitorManager *monitor_manager = meta_gpu_get_monitor_manager (gpu);
MetaMonitorManagerXrandr *monitor_manager_xrandr =
META_MONITOR_MANAGER_XRANDR (monitor_manager);
@ -607,8 +607,8 @@ output_get_connector_type (MetaOutput *output)
static void
output_get_tile_info (MetaOutput *output)
{
MetaMonitorManager *monitor_manager =
meta_output_get_monitor_manager (output);
MetaGpu *gpu = meta_output_get_gpu (output);
MetaMonitorManager *monitor_manager = meta_gpu_get_monitor_manager (gpu);
MetaMonitorManagerXrandr *monitor_manager_xrandr =
META_MONITOR_MANAGER_XRANDR (monitor_manager);
Display *xdisplay = xdisplay_from_output (output);
@ -646,10 +646,10 @@ output_get_tile_info (MetaOutput *output)
static void
output_get_modes (MetaMonitorManager *monitor_manager,
MetaOutput *output,
XRROutputInfo *xrandr_output)
output_get_modes (MetaOutput *output,
XRROutputInfo *xrandr_output)
{
MetaGpu *gpu = meta_output_get_gpu (output);
unsigned int i;
unsigned int n_actual_modes;
@ -660,7 +660,7 @@ output_get_modes (MetaMonitorManager *monitor_manager,
{
GList *l;
for (l = monitor_manager->modes; l; l = l->next)
for (l = meta_gpu_get_modes (gpu); l; l = l->next)
{
MetaCrtcMode *mode = l->data;
@ -678,10 +678,10 @@ output_get_modes (MetaMonitorManager *monitor_manager,
}
static void
output_get_crtcs (MetaMonitorManager *monitor_manager,
MetaOutput *output,
XRROutputInfo *xrandr_output)
output_get_crtcs (MetaOutput *output,
XRROutputInfo *xrandr_output)
{
MetaGpu *gpu = meta_output_get_gpu (output);
unsigned int i;
unsigned int n_actual_crtcs;
GList *l;
@ -691,7 +691,7 @@ output_get_crtcs (MetaMonitorManager *monitor_manager,
n_actual_crtcs = 0;
for (i = 0; i < (unsigned int) xrandr_output->ncrtc; i++)
{
for (l = monitor_manager->crtcs; l; l = l->next)
for (l = meta_gpu_get_crtcs (gpu); l; l = l->next)
{
MetaCrtc *crtc = l->data;
@ -706,7 +706,7 @@ output_get_crtcs (MetaMonitorManager *monitor_manager,
output->n_possible_crtcs = n_actual_crtcs;
output->crtc = NULL;
for (l = monitor_manager->crtcs; l; l = l->next)
for (l = meta_gpu_get_crtcs (gpu); l; l = l->next)
{
MetaCrtc *crtc = l->data;
@ -719,17 +719,17 @@ output_get_crtcs (MetaMonitorManager *monitor_manager,
}
MetaOutput *
meta_create_xrandr_output (MetaMonitorManager *monitor_manager,
XRROutputInfo *xrandr_output,
RROutput output_id,
RROutput primary_output)
meta_create_xrandr_output (MetaGpuXrandr *gpu_xrandr,
XRROutputInfo *xrandr_output,
RROutput output_id,
RROutput primary_output)
{
MetaOutput *output;
GBytes *edid;
unsigned int i;
output = g_object_new (META_TYPE_OUTPUT, NULL);
output->monitor_manager = monitor_manager;
output->gpu = META_GPU (gpu_xrandr);
output->winsys_id = output_id;
output->name = g_strdup (xrandr_output->name);
@ -746,8 +746,8 @@ meta_create_xrandr_output (MetaMonitorManager *monitor_manager,
output->connector_type = output_get_connector_type (output);
output_get_tile_info (output);
output_get_modes (monitor_manager, output, xrandr_output);
output_get_crtcs (monitor_manager, output, xrandr_output);
output_get_modes (output, xrandr_output);
output_get_crtcs (output, xrandr_output);
output->n_possible_clones = xrandr_output->nclone;
output->possible_clones = g_new0 (MetaOutput *,

9
src/backends/x11/meta-output-xrandr.h
View file

@ -25,6 +25,7 @@
#include <X11/extensions/Xrandr.h>
#include "backends/meta-output.h"
#include "backends/x11/meta-gpu-xrandr.h"
#include "backends/x11/meta-monitor-manager-xrandr.h"
void meta_output_xrandr_apply_mode (MetaOutput *output);
@ -34,9 +35,9 @@ void meta_output_xrandr_change_backlight (MetaOutput *output,
GBytes * meta_output_xrandr_read_edid (MetaOutput *output);
MetaOutput * meta_create_xrandr_output (MetaMonitorManager *monitor_manager,
XRROutputInfo *xrandr_output,
RROutput output_id,
RROutput primary_output);
MetaOutput * meta_create_xrandr_output (MetaGpuXrandr *gpu_xrandr,
XRROutputInfo *xrandr_output,
RROutput output_id,
RROutput primary_output);
#endif /* META_OUTPUT_XRANDR */

12
src/tests/headless-start-test.c
View file

@ -57,10 +57,16 @@ meta_test_headless_start (void)
MetaBackend *backend = meta_get_backend ();
MetaMonitorManager *monitor_manager =
meta_backend_get_monitor_manager (backend);
GList *gpus;
MetaGpu *gpu;
g_assert_null (monitor_manager->modes);
g_assert_null (monitor_manager->outputs);
g_assert_null (monitor_manager->crtcs);
gpus = meta_monitor_manager_get_gpus (monitor_manager);
g_assert_cmpint ((int) g_list_length (gpus), ==, 1);
gpu = gpus->data;
g_assert_null (meta_gpu_get_modes (gpu));
g_assert_null (meta_gpu_get_outputs (gpu));
g_assert_null (meta_gpu_get_crtcs (gpu));
g_assert_null (monitor_manager->monitors);
g_assert_null (monitor_manager->logical_monitors);

67
src/tests/meta-monitor-manager-test.c
View file

@ -23,6 +23,7 @@
#include "backends/meta-backend-private.h"
#include "backends/meta-crtc.h"
#include "backends/meta-gpu.h"
#include "backends/meta-monitor-config-manager.h"
#include "backends/meta-output.h"
@ -30,6 +31,8 @@ struct _MetaMonitorManagerTest
{
MetaMonitorManager parent;
MetaGpu *gpu;
gboolean is_lid_closed;
gboolean handles_transforms;
@ -41,6 +44,13 @@ struct _MetaMonitorManagerTest
G_DEFINE_TYPE (MetaMonitorManagerTest, meta_monitor_manager_test,
META_TYPE_MONITOR_MANAGER)
struct _MetaGpuTest
{
MetaGpu parent;
};
G_DEFINE_TYPE (MetaGpuTest, meta_gpu_test, META_TYPE_GPU)
static MetaMonitorTestSetup *_initial_test_setup = NULL;
void
@ -49,6 +59,12 @@ meta_monitor_manager_test_init_test_setup (MetaMonitorTestSetup *test_setup)
_initial_test_setup = test_setup;
}
MetaGpu *
meta_monitor_manager_test_get_gpu (MetaMonitorManagerTest *manager_test)
{
return manager_test->gpu;
}
void
meta_monitor_manager_test_emulate_hotplug (MetaMonitorManagerTest *manager_test,
MetaMonitorTestSetup *test_setup)
@ -91,20 +107,24 @@ static void
meta_monitor_manager_test_read_current (MetaMonitorManager *manager)
{
MetaMonitorManagerTest *manager_test = META_MONITOR_MANAGER_TEST (manager);
MetaGpu *gpu = manager_test->gpu;
GList *l;
g_assert (manager_test->test_setup);
for (l = manager_test->test_setup->outputs; l; l = l->next)
META_OUTPUT (l->data)->monitor_manager = manager;
META_OUTPUT (l->data)->gpu = gpu;
for (l = manager_test->test_setup->crtcs; l; l = l->next)
META_CRTC (l->data)->monitor_manager = manager;
META_CRTC (l->data)->gpu = gpu;
manager->modes = manager_test->test_setup->modes;
meta_gpu_take_modes (manager_test->gpu,
manager_test->test_setup->modes);
manager->crtcs = manager_test->test_setup->crtcs;
meta_gpu_take_crtcs (manager_test->gpu,
manager_test->test_setup->crtcs);
manager->outputs = manager_test->test_setup->outputs;
meta_gpu_take_outputs (manager_test->gpu,
manager_test->test_setup->outputs);
}
static gboolean
@ -139,6 +159,7 @@ apply_crtc_assignments (MetaMonitorManager *manager,
MetaOutputInfo **outputs,
unsigned int n_outputs)
{
MetaMonitorManagerTest *manager_test = META_MONITOR_MANAGER_TEST (manager);
GList *l;
unsigned int i;
@ -204,7 +225,7 @@ apply_crtc_assignments (MetaMonitorManager *manager,
}
/* Disable CRTCs not mentioned in the list */
for (l = manager->crtcs; l; l = l->next)
for (l = meta_gpu_get_crtcs (manager_test->gpu); l; l = l->next)
{
MetaCrtc *crtc = l->data;
@ -224,7 +245,7 @@ apply_crtc_assignments (MetaMonitorManager *manager,
}
/* Disable outputs not mentioned in the list */
for (l = manager->outputs; l; l = l->next)
for (l = meta_gpu_get_outputs (manager_test->gpu); l; l = l->next)
{
MetaOutput *output = l->data;
@ -453,11 +474,18 @@ meta_monitor_manager_test_dispose (GObject *object)
static void
meta_monitor_manager_test_init (MetaMonitorManagerTest *manager_test)
{
MetaMonitorManager *manager = META_MONITOR_MANAGER (manager_test);
g_assert (_initial_test_setup);
manager_test->handles_transforms = TRUE;
manager_test->test_setup = _initial_test_setup;
manager_test->gpu = g_object_new (META_TYPE_GPU_TEST,
"monitor-manager", manager,
NULL);
meta_monitor_manager_add_gpu (manager, manager_test->gpu);
}
static void
@ -468,7 +496,6 @@ meta_monitor_manager_test_class_init (MetaMonitorManagerTestClass *klass)
object_class->dispose = meta_monitor_manager_test_dispose;
manager_class->read_current = meta_monitor_manager_test_read_current;
manager_class->is_lid_closed = meta_monitor_manager_test_is_lid_closed;
manager_class->ensure_initial_config = meta_monitor_manager_test_ensure_initial_config;
manager_class->apply_monitors_config = meta_monitor_manager_test_apply_monitors_config;
@ -481,3 +508,27 @@ meta_monitor_manager_test_class_init (MetaMonitorManagerTestClass *klass)
manager_class->get_max_screen_size = meta_monitor_manager_test_get_max_screen_size;
manager_class->get_default_layout_mode = meta_monitor_manager_test_get_default_layout_mode;
}
static gboolean
meta_gpu_test_read_current (MetaGpu *gpu,
GError **error)
{
MetaMonitorManager *manager = meta_gpu_get_monitor_manager (gpu);
meta_monitor_manager_test_read_current (manager);
return TRUE;
}
static void
meta_gpu_test_init (MetaGpuTest *gpu_test)
{
}
static void
meta_gpu_test_class_init (MetaGpuTestClass *klass)
{
MetaGpuClass *gpu_class = META_GPU_CLASS (klass);
gpu_class->read_current = meta_gpu_test_read_current;
}

6
src/tests/meta-monitor-manager-test.h
View file

@ -20,6 +20,7 @@
#ifndef META_MONITOR_MANAGER_TEST_H
#define META_MONITOR_MANAGER_TEST_H
#include "backends/meta-gpu.h"
#include "backends/meta-monitor-manager-private.h"
typedef struct _MetaMonitorTestSetup
@ -38,8 +39,13 @@ typedef struct _MetaOutputTest
G_DECLARE_FINAL_TYPE (MetaMonitorManagerTest, meta_monitor_manager_test,
META, MONITOR_MANAGER_TEST, MetaMonitorManager)
#define META_TYPE_GPU_TEST (meta_gpu_test_get_type ())
G_DECLARE_FINAL_TYPE (MetaGpuTest, meta_gpu_test, META, GPU_TEST, MetaGpu)
void meta_monitor_manager_test_init_test_setup (MetaMonitorTestSetup *test_setup);
MetaGpu * meta_monitor_manager_test_get_gpu (MetaMonitorManagerTest *manager_test);
void meta_monitor_manager_test_emulate_hotplug (MetaMonitorManagerTest *manager_test,
MetaMonitorTestSetup *test_setup);

29
src/tests/monitor-unit-tests.c
View file

@ -368,9 +368,12 @@ static MetaOutput *
output_from_winsys_id (MetaMonitorManager *monitor_manager,
long winsys_id)
{
MetaMonitorManagerTest *monitor_manager_test =
META_MONITOR_MANAGER_TEST (monitor_manager);
MetaGpu *gpu = meta_monitor_manager_test_get_gpu (monitor_manager_test);
GList *l;
for (l = monitor_manager->outputs; l; l = l->next)
for (l = meta_gpu_get_outputs (gpu); l; l = l->next)
{
MetaOutput *output = l->data;
@ -402,17 +405,22 @@ check_monitor_mode (MetaMonitor *monitor,
output = output_from_winsys_id (monitor_manager,
data->expect_crtc_mode_iter->output);
g_assert (monitor_crtc_mode->output == output);
expect_crtc_mode_index = data->expect_crtc_mode_iter->crtc_mode;
if (expect_crtc_mode_index == -1)
crtc_mode = NULL;
{
crtc_mode = NULL;
}
else
crtc_mode = g_list_nth_data (monitor_manager->modes,
expect_crtc_mode_index);
{
MetaGpu *gpu = meta_output_get_gpu (output);
g_assert (monitor_crtc_mode->output == output);
crtc_mode = g_list_nth_data (meta_gpu_get_modes (gpu),
expect_crtc_mode_index);
}
g_assert (monitor_crtc_mode->crtc_mode == crtc_mode);
if (crtc_mode)
{
float refresh_rate;
@ -607,6 +615,7 @@ check_monitor_configuration (MonitorTestCase *test_case)
meta_backend_get_monitor_manager (backend);
MetaMonitorManagerTest *monitor_manager_test =
META_MONITOR_MANAGER_TEST (monitor_manager);
MetaGpu *gpu = meta_monitor_manager_test_get_gpu (monitor_manager_test);
int tiled_monitor_count;
GList *monitors;
GList *crtcs;
@ -620,10 +629,10 @@ check_monitor_configuration (MonitorTestCase *test_case)
g_assert_cmpint (monitor_manager->screen_height,
==,
test_case->expect.screen_height);
g_assert_cmpint ((int) g_list_length (monitor_manager->outputs),
g_assert_cmpint ((int) g_list_length (meta_gpu_get_outputs (gpu)),
==,
test_case->expect.n_outputs);
g_assert_cmpint ((int) g_list_length (monitor_manager->crtcs),
g_assert_cmpint ((int) g_list_length (meta_gpu_get_crtcs (gpu)),
==,
test_case->expect.n_crtcs);
@ -789,7 +798,7 @@ check_monitor_configuration (MonitorTestCase *test_case)
}
g_assert_cmpint (n_logical_monitors, ==, i);
crtcs = meta_monitor_manager_get_crtcs (monitor_manager);
crtcs = meta_gpu_get_crtcs (gpu);
for (l = crtcs, i = 0; l; l = l->next, i++)
{
MetaCrtc *crtc = l->data;
@ -805,7 +814,7 @@ check_monitor_configuration (MonitorTestCase *test_case)
int crtc_x, crtc_y;
expected_current_mode =
g_list_nth_data (monitor_manager->modes,
g_list_nth_data (meta_gpu_get_modes (gpu),
test_case->expect.crtcs[i].current_mode);
g_assert (crtc->current_mode == expected_current_mode);