#include <xf86drm.h>
#include <xf86drmMode.h>
+#include <gbm.h>
+
#include "compositor.h"
struct drm_compositor {
struct {
int fd;
} drm;
+ struct gbm_device *gbm;
uint32_t crtc_allocator;
uint32_t connector_allocator;
struct tty *tty;
+};
- PFNEGLCREATEDRMIMAGEMESA create_drm_image;
- PFNEGLEXPORTDRMIMAGEMESA export_drm_image;
+struct drm_mode {
+ struct wlsc_mode base;
+ drmModeModeInfo mode_info;
};
struct drm_output {
struct wlsc_output base;
- drmModeModeInfo mode;
uint32_t crtc_id;
uint32_t connector_id;
GLuint rbo[2];
uint32_t fb_id[2];
EGLImageKHR image[2];
+ struct gbm_bo *bo[2];
uint32_t current;
struct wlsc_surface *scanout_surface;
EGLint handle, stride;
int ret;
uint32_t fb_id = 0;
+ struct gbm_bo *bo;
if (es->x != output->base.x ||
es->y != output->base.y ||
- es->width != output->base.width ||
- es->height != output->base.height ||
+ es->width != output->base.current->width ||
+ es->height != output->base.current->height ||
es->image == EGL_NO_IMAGE_KHR)
return -1;
- c->export_drm_image(c->base.display,
- es->image, NULL, &handle, &stride);
+ bo = gbm_bo_create_from_egl_image(c->gbm,
+ c->base.display, es->image,
+ es->width, es->height,
+ GBM_BO_USE_SCANOUT);
+
+ handle = gbm_bo_get_handle(bo).s32;
+ stride = gbm_bo_get_pitch(bo);
+
+ gbm_bo_destroy(bo);
if (handle == 0)
return -1;
ret = drmModeAddFB(c->drm.fd,
- output->base.width, output->base.height,
+ output->base.current->width,
+ output->base.current->height,
32, 32, stride, handle, &fb_id);
if (ret)
EGLint handle, stride;
int ret = -1;
pixman_region32_t cursor_region;
+ struct gbm_bo *bo;
if (eid == NULL) {
drmModeSetCursor(c->drm.fd, output->crtc_id, 0, 0, 0);
pixman_region32_intersect_rect(&cursor_region, &cursor_region,
output->base.x, output->base.y,
- output->base.width, output->base.height);
+ output->base.current->width,
+ output->base.current->height);
- if (!pixman_region32_not_empty(&cursor_region)) {
- ret = 0;
+ if (!pixman_region32_not_empty(&cursor_region))
goto out;
- }
if (eid->sprite->image == EGL_NO_IMAGE_KHR)
goto out;
if (eid->sprite->width > 64 || eid->sprite->height > 64)
goto out;
- c->export_drm_image(c->base.display, eid->sprite->image,
- NULL, &handle, &stride);
+ bo = gbm_bo_create_from_egl_image(c->gbm,
+ c->base.display,
+ eid->sprite->image, 64, 64,
+ GBM_BO_USE_CURSOR_64X64);
+
+ handle = gbm_bo_get_handle(bo).s32;
+ stride = gbm_bo_get_pitch(bo);
+
+ gbm_bo_destroy(bo);
if (stride != 64 * 4) {
fprintf(stderr, "info: cursor stride is != 64\n");
goto out;
}
- printf("info: set hardware cursor\n");
-
out:
pixman_region32_fini(&cursor_region);
if (ret)
return -1;
}
+ setenv("EGL_PLATFORM", "drm", 1);
ec->drm.fd = fd;
- ec->base.display = eglGetDisplay(FD_TO_EGL_NATIVE_DPY(ec->drm.fd));
+ ec->gbm = gbm_create_device(ec->drm.fd);
+ ec->base.display = eglGetDisplay(ec->gbm);
if (ec->base.display == NULL) {
fprintf(stderr, "failed to create display\n");
return -1;
"1024x768"
};
+
+static int
+drm_output_add_mode(struct drm_output *output, drmModeModeInfo *info)
+{
+ struct drm_mode *mode;
+
+ mode = malloc(sizeof *mode);
+ if (mode == NULL)
+ return -1;
+
+ mode->base.flags = 0;
+ mode->base.width = info->hdisplay;
+ mode->base.height = info->vdisplay;
+ mode->base.refresh = info->vrefresh;
+ mode->mode_info = *info;
+ wl_list_insert(output->base.mode_list.prev, &mode->base.link);
+
+ return 0;
+}
+
+static int
+drm_subpixel_to_wayland(int drm_value)
+{
+ switch (drm_value) {
+ default:
+ case DRM_MODE_SUBPIXEL_UNKNOWN:
+ return WL_OUTPUT_SUBPIXEL_UNKNOWN;
+ case DRM_MODE_SUBPIXEL_NONE:
+ return WL_OUTPUT_SUBPIXEL_NONE;
+ case DRM_MODE_SUBPIXEL_HORIZONTAL_RGB:
+ return WL_OUTPUT_SUBPIXEL_HORIZONTAL_RGB;
+ case DRM_MODE_SUBPIXEL_HORIZONTAL_BGR:
+ return WL_OUTPUT_SUBPIXEL_HORIZONTAL_BGR;
+ case DRM_MODE_SUBPIXEL_VERTICAL_RGB:
+ return WL_OUTPUT_SUBPIXEL_VERTICAL_RGB;
+ case DRM_MODE_SUBPIXEL_VERTICAL_BGR:
+ return WL_OUTPUT_SUBPIXEL_VERTICAL_BGR;
+ }
+}
+
static int
create_output_for_connector(struct drm_compositor *ec,
drmModeRes *resources,
int x, int y)
{
struct drm_output *output;
+ struct drm_mode *drm_mode;
drmModeEncoder *encoder;
- drmModeModeInfo *mode;
int i, ret;
- EGLint handle, stride, attribs[] = {
- EGL_WIDTH, 0,
- EGL_HEIGHT, 0,
- EGL_DRM_BUFFER_FORMAT_MESA, EGL_DRM_BUFFER_FORMAT_ARGB32_MESA,
- EGL_DRM_BUFFER_USE_MESA, EGL_DRM_BUFFER_USE_SCANOUT_MESA,
- EGL_NONE
- };
-
- output = malloc(sizeof *output);
- if (output == NULL)
- return -1;
-
- if (connector->count_modes > 0)
- mode = &connector->modes[0];
- else
- mode = &builtin_1024x768;
+ unsigned handle, stride;
encoder = drmModeGetEncoder(ec->drm.fd, connector->encoders[0]);
if (encoder == NULL) {
return -1;
}
+ output = malloc(sizeof *output);
+ if (output == NULL)
+ return -1;
+
memset(output, 0, sizeof *output);
- wlsc_output_init(&output->base, &ec->base, x, y,
- mode->hdisplay, mode->vdisplay, 0);
+ output->base.subpixel = drm_subpixel_to_wayland(connector->subpixel);
+ output->base.make = "unknown";
+ output->base.model = "unknown";
+ wl_list_init(&output->base.mode_list);
output->crtc_id = resources->crtcs[i];
ec->crtc_allocator |= (1 << output->crtc_id);
-
output->connector_id = connector->connector_id;
ec->connector_allocator |= (1 << output->connector_id);
- output->mode = *mode;
+
+ for (i = 0; i < connector->count_modes; i++)
+ drm_output_add_mode(output, &connector->modes[i]);
+ if (connector->count_modes == 0)
+ drm_output_add_mode(output, &builtin_1024x768);
+
+ drm_mode = container_of(output->base.mode_list.next,
+ struct drm_mode, base.link);
+ output->base.current = &drm_mode->base;
+ drm_mode->base.flags =
+ WL_OUTPUT_MODE_CURRENT | WL_OUTPUT_MODE_PREFERRED;
+
+ wlsc_output_init(&output->base, &ec->base, x, y,
+ connector->mmWidth, connector->mmHeight, 0);
+
+ wl_list_insert(ec->base.output_list.prev, &output->base.link);
drmModeFreeEncoder(encoder);
for (i = 0; i < 2; i++) {
glBindRenderbuffer(GL_RENDERBUFFER, output->rbo[i]);
- attribs[1] = output->base.width;
- attribs[3] = output->base.height;
- output->image[i] =
- ec->create_drm_image(ec->base.display, attribs);
+ output->bo[i] =
+ gbm_bo_create(ec->gbm,
+ output->base.current->width,
+ output->base.current->height,
+ GBM_BO_FORMAT_XRGB8888,
+ GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING);
+ output->image[i] = ec->base.create_image(ec->base.display,
+ NULL,
+ EGL_NATIVE_PIXMAP_KHR,
+ output->bo[i], NULL);
+
+
ec->base.image_target_renderbuffer_storage(GL_RENDERBUFFER,
output->image[i]);
- ec->export_drm_image(ec->base.display, output->image[i],
- NULL, &handle, &stride);
+ stride = gbm_bo_get_pitch(output->bo[i]);
+ handle = gbm_bo_get_handle(output->bo[i]).u32;
ret = drmModeAddFB(ec->drm.fd,
- output->base.width, output->base.height,
+ output->base.current->width,
+ output->base.current->height,
32, 32, stride, handle, &output->fb_id[i]);
if (ret) {
fprintf(stderr, "failed to add fb %d: %m\n", i);
output->rbo[output->current]);
ret = drmModeSetCrtc(ec->drm.fd, output->crtc_id,
output->fb_id[output->current ^ 1], 0, 0,
- &output->connector_id, 1, &output->mode);
+ &output->connector_id, 1,
+ &drm_mode->mode_info);
if (ret) {
fprintf(stderr, "failed to set mode: %m\n");
return -1;
drm_output_prepare_scanout_surface;
output->base.set_hardware_cursor = drm_output_set_cursor;
- wl_list_insert(ec->base.output_list.prev, &output->base.link);
-
return 0;
}
if (connector->connection == DRM_MODE_CONNECTED &&
(option_connector == 0 ||
- connector->connector_id == option_connector))
+ connector->connector_id == option_connector)) {
if (create_output_for_connector(ec, resources,
connector, x, y) < 0)
return -1;
- x += container_of(ec->base.output_list.prev, struct wlsc_output,
- link)->width;
+ x += container_of(ec->base.output_list.prev,
+ struct wlsc_output,
+ link)->current->width;
+ }
drmModeFreeConnector(connector);
}
/* XXX: not yet needed, we die with 0 outputs */
if (!wl_list_empty(&ec->base.output_list))
- x = last_output->x + last_output->width;
+ x = last_output->x + last_output->current->width;
else
x = 0;
y = 0;
disconnects &= ~(1 << output->connector_id);
printf("connector %d disconnected\n",
output->connector_id);
- x_offset += output->base.width;
+ x_offset += output->base.current->width;
destroy_output(output);
}
}
drm_compositor_create_cursor_image(struct wlsc_compositor *ec,
int32_t width, int32_t height)
{
- static const EGLint image_attribs[] = {
- EGL_WIDTH, 64,
- EGL_HEIGHT, 64,
- EGL_DRM_BUFFER_FORMAT_MESA, EGL_DRM_BUFFER_FORMAT_ARGB32_MESA,
- EGL_DRM_BUFFER_USE_MESA, EGL_DRM_BUFFER_USE_CURSOR_MESA,
- EGL_NONE
- };
struct drm_compositor *c = (struct drm_compositor *) ec;
+ struct gbm_bo *bo;
+ EGLImageKHR image;
+ uint32_t *pixels;
+ GLuint tex;
if (width > 64 || height > 64)
return EGL_NO_IMAGE_KHR;
- return c->create_drm_image(ec->display, image_attribs);
+ bo = gbm_bo_create(c->gbm,
+ /* width, height, */ 64, 64,
+ GBM_BO_FORMAT_ARGB8888,
+ GBM_BO_USE_CURSOR_64X64 | GBM_BO_USE_RENDERING);
+
+ image = ec->create_image(c->base.display, NULL,
+ EGL_NATIVE_PIXMAP_KHR, bo, NULL);
+ gbm_bo_destroy(bo);
+
+ /* If the requested size is smaller than the allocated one, make the
+ * whole image transparent. */
+ if (width != 64 || height != 64) {
+ pixels = calloc(64 * 64, sizeof *pixels);
+
+ glGenTextures(1, &tex);
+ glBindTexture(GL_TEXTURE_2D, tex);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+ c->base.image_target_texture_2d(GL_TEXTURE_2D, image);
+ glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 64, 64,
+ GL_BGRA_EXT, GL_UNSIGNED_BYTE, pixels);
+
+ glDeleteTextures(1, &tex);
+ free(pixels);
+ }
+
+ return image;
}
static void
free(d);
}
+static void
+vt_func(struct wlsc_compositor *compositor, int event)
+{
+ struct drm_compositor *ec = (struct drm_compositor *) compositor;
+ struct wlsc_output *output;
+
+ switch (event) {
+ case TTY_ENTER_VT:
+ compositor->focus = 1;
+ drmSetMaster(ec->drm.fd);
+ compositor->state = WLSC_COMPOSITOR_ACTIVE;
+ wlsc_compositor_damage_all(compositor);
+ break;
+ case TTY_LEAVE_VT:
+ compositor->focus = 0;
+ compositor->state = WLSC_COMPOSITOR_SLEEPING;
+ drmDropMaster(ec->drm.fd);
+
+ wl_list_for_each(output, &ec->base.output_list, link)
+ drm_output_set_cursor(output, NULL);
+
+ break;
+ };
+}
+
+static const char default_seat[] = "seat0";
+
static struct wlsc_compositor *
-drm_compositor_create(struct wl_display *display, int connector)
+drm_compositor_create(struct wl_display *display,
+ int connector, const char *seat)
{
struct drm_compositor *ec;
struct udev_enumerate *e;
struct udev_list_entry *entry;
- struct udev_device *device;
- const char *path;
+ struct udev_device *device, *drm_device;
+ const char *path, *device_seat;
struct wl_event_loop *loop;
ec = malloc(sizeof *ec);
e = udev_enumerate_new(ec->udev);
udev_enumerate_add_match_subsystem(e, "drm");
- udev_enumerate_add_match_property(e, "WAYLAND_SEAT", "1");
+
udev_enumerate_scan_devices(e);
- device = NULL;
+ drm_device = NULL;
udev_list_entry_foreach(entry, udev_enumerate_get_list_entry(e)) {
path = udev_list_entry_get_name(entry);
device = udev_device_new_from_syspath(ec->udev, path);
- break;
+ device_seat =
+ udev_device_get_property_value(device, "ID_SEAT");
+ if (!device_seat)
+ device_seat = default_seat;
+ if (strcmp(device_seat, seat) == 0) {
+ drm_device = device;
+ break;
+ }
+ udev_device_unref(device);
}
+
udev_enumerate_unref(e);
- if (device == NULL) {
+ if (drm_device == NULL) {
fprintf(stderr, "no drm device found\n");
return NULL;
}
ec->base.wl_display = display;
- if (init_egl(ec, device) < 0) {
+ if (init_egl(ec, drm_device) < 0) {
fprintf(stderr, "failed to initialize egl\n");
return NULL;
}
+ udev_device_unref(drm_device);
+
ec->base.destroy = drm_destroy;
ec->base.create_cursor_image = drm_compositor_create_cursor_image;
glGenFramebuffers(1, &ec->base.fbo);
glBindFramebuffer(GL_FRAMEBUFFER, ec->base.fbo);
- ec->create_drm_image =
- (void *) eglGetProcAddress("eglCreateDRMImageMESA");
- ec->export_drm_image =
- (void *) eglGetProcAddress("eglExportDRMImageMESA");
-
/* Can't init base class until we have a current egl context */
if (wlsc_compositor_init(&ec->base, display) < 0)
return NULL;
return NULL;
}
- evdev_input_add_devices(&ec->base, ec->udev);
+ evdev_input_add_devices(&ec->base, ec->udev, seat);
loop = wl_display_get_event_loop(ec->base.wl_display);
ec->drm_source =
wl_event_loop_add_fd(loop, ec->drm.fd,
WL_EVENT_READABLE, on_drm_input, ec);
- ec->tty = tty_create(&ec->base);
+ ec->tty = tty_create(&ec->base, vt_func);
ec->udev_monitor = udev_monitor_new_from_netlink(ec->udev, "udev");
if (ec->udev_monitor == NULL) {
backend_init(struct wl_display *display, char *options)
{
int connector = 0, i;
+ const char *seat;
char *p, *value;
- static char * const tokens[] = { "connector", NULL };
+ static char * const tokens[] = { "connector", "seat", NULL };
p = options;
+ seat = default_seat;
while (i = getsubopt(&p, tokens, &value), i != -1) {
switch (i) {
case 0:
connector = strtol(value, NULL, 0);
break;
+ case 1:
+ seat = value;
+ break;
}
}
- return drm_compositor_create(display, connector);
+ return drm_compositor_create(display, connector, seat);
}
projects / profile / ivi / weston.git / blobdiff