| /* |
| * Copyright © 2007 Red Hat, Inc. |
| * Copyright © 2008 Maarten Maathuis |
| * Copyright © 2011 Texas Instruments, Inc |
| * |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| * and/or sell copies of the Software, and to permit persons to whom the |
| * Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| * SOFTWARE. |
| * |
| * Authors: |
| * Dave Airlie <airlied@redhat.com> |
| * Ian Elliott <ianelliottus@yahoo.com> |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| #include "config.h" |
| #endif |
| |
| /* TODO cleanup #includes, remove unnecessary ones */ |
| |
| #include "xorg-server.h" |
| #include "xorgVersion.h" |
| |
| #include <sys/mman.h> |
| #include <sys/stat.h> |
| #include <sys/types.h> |
| |
| #include <string.h> |
| #include <math.h> |
| #include <errno.h> |
| #include <unistd.h> |
| #include <stdlib.h> |
| #include <fcntl.h> |
| |
| #include <linux/fb.h> |
| |
| |
| /* All drivers should typically include these */ |
| #include "xf86.h" |
| #include "xf86_OSproc.h" |
| #define PPC_MMIO_IS_BE |
| #include "compiler.h" |
| #include "mipointer.h" |
| |
| /* All drivers implementing backing store need this */ |
| #include "mibstore.h" |
| |
| #include "micmap.h" |
| |
| #include "xf86DDC.h" |
| |
| #include "xf86RandR12.h" |
| #include "dixstruct.h" |
| #include "scrnintstr.h" |
| #include "fb.h" |
| #include "xf86cmap.h" |
| #include "shadowfb.h" |
| |
| #include "xf86Cursor.h" |
| #include "xf86DDC.h" |
| |
| #include "region.h" |
| |
| #include <X11/extensions/randr.h> |
| |
| #include <X11/extensions/dpmsconst.h> |
| |
| #include "omap_driver.h" |
| |
| #include "xf86Crtc.h" |
| |
| #include "xf86drmMode.h" |
| #include "drm_fourcc.h" |
| #include "X11/Xatom.h" |
| |
| #include <sys/ioctl.h> |
| #include <libudev.h> |
| |
| typedef struct { |
| int fd; |
| struct udev_monitor *uevent_monitor; |
| InputHandlerProc uevent_handler; |
| } drmmode_rec, *drmmode_ptr; |
| |
| typedef struct { |
| drmmode_ptr drmmode; |
| uint32_t id; |
| struct omap_bo *cursor_bo; |
| } drmmode_crtc_private_rec, *drmmode_crtc_private_ptr; |
| |
| typedef struct { |
| drmModePropertyPtr mode_prop; |
| int index; /* Index within the kernel-side property arrays for |
| * this connector. */ |
| int num_atoms; /* if range prop, num_atoms == 1; if enum prop, |
| * num_atoms == num_enums + 1 */ |
| Atom *atoms; |
| } drmmode_prop_rec, *drmmode_prop_ptr; |
| |
| typedef struct { |
| drmmode_ptr drmmode; |
| int id; |
| drmModeConnectorPtr mode_output; |
| drmModePropertyBlobPtr edid_blob; |
| uint32_t dpms_id; |
| int num_props; |
| drmmode_prop_ptr props; |
| } drmmode_output_private_rec, *drmmode_output_private_ptr; |
| |
| static void drmmode_output_dpms(xf86OutputPtr output, int mode); |
| |
| static uint32_t |
| drmmode_get_prop_id(int fd, uint32_t count_props, const uint32_t props[], |
| const char *name, uint32_t flags) |
| { |
| uint32_t i; |
| uint32_t prop_id; |
| |
| for (prop_id = 0, i = 0; i < count_props && !prop_id; i++) { |
| drmModePropertyPtr prop = drmModeGetProperty(fd, props[i]); |
| if (!prop) |
| continue; |
| if (prop->flags == flags && !strcmp(prop->name, name)) |
| prop_id = props[i]; |
| drmModeFreeProperty(prop); |
| } |
| |
| return prop_id; |
| } |
| |
| static OMAPScanoutPtr |
| drmmode_scanout_from_size(OMAPScanoutPtr scanouts, int x, int y, int width, |
| int height) |
| { |
| int i; |
| for (i = 0; i < MAX_SCANOUTS; i++) { |
| if (scanouts[i].x == x && scanouts[i].y == y && |
| scanouts[i].width == width && scanouts[i].height == height) |
| return &scanouts[i]; |
| } |
| return NULL; |
| } |
| |
| static OMAPScanoutPtr |
| drmmode_scanout_from_crtc(OMAPScanoutPtr scanouts, xf86CrtcPtr crtc) |
| { |
| return drmmode_scanout_from_size(scanouts, crtc->x, crtc->y, |
| crtc->mode.HDisplay, crtc->mode.VDisplay); |
| } |
| |
| OMAPScanoutPtr |
| drmmode_scanout_from_drawable(OMAPScanoutPtr scanouts, DrawablePtr pDraw) |
| { |
| return drmmode_scanout_from_size(scanouts, pDraw->x, pDraw->y, |
| pDraw->width, pDraw->height); |
| } |
| |
| static OMAPScanoutPtr |
| drmmode_scanout_add(OMAPScanoutPtr scanouts, xf86CrtcPtr crtc, |
| struct omap_bo *bo) |
| { |
| int i; |
| for (i = 0; i < MAX_SCANOUTS; i++) { |
| OMAPScanoutPtr s = &scanouts[i]; |
| |
| if (s->bo) |
| continue; |
| |
| omap_bo_reference(bo); |
| s->x = crtc->x; |
| s->y = crtc->y; |
| s->width = crtc->mode.HDisplay; |
| s->height = crtc->mode.VDisplay; |
| s->bo = bo; |
| return s; |
| } |
| |
| return NULL; |
| } |
| |
| void |
| drmmode_scanout_set(OMAPScanoutPtr scanouts, int x, int y, struct omap_bo *bo) |
| { |
| OMAPScanoutPtr s; |
| |
| s = drmmode_scanout_from_size(scanouts, x, y, omap_bo_width(bo), |
| omap_bo_height(bo)); |
| if (!s) { |
| /* The scanout may not exist after flip, just ignore */ |
| return; |
| } |
| |
| omap_bo_reference(bo); |
| omap_bo_unreference(s->bo); |
| s->bo = bo; |
| } |
| |
| static uint32_t drmmode_crtc_id(xf86CrtcPtr crtc) |
| { |
| drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private; |
| return drmmode_crtc->id; |
| } |
| |
| int drmmode_crtc_index_from_drawable(ScrnInfoPtr pScrn, DrawablePtr pDraw) |
| { |
| xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn); |
| xf86CrtcPtr crtc; |
| DisplayModePtr mode; |
| int i; |
| |
| for (i = 0; i < xf86_config->num_crtc; i++) { |
| crtc = xf86_config->crtc[i]; |
| if (!crtc->enabled) |
| continue; |
| mode = &crtc->mode; |
| if (crtc->x == pDraw->x && crtc->y == pDraw->y && |
| mode->HDisplay == pDraw->width && |
| mode->VDisplay == pDraw->height) |
| return i; |
| } |
| return -1; |
| } |
| |
| int drmmode_crtc_id_from_drawable(ScrnInfoPtr pScrn, DrawablePtr pDraw) |
| { |
| xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn); |
| xf86CrtcPtr crtc; |
| int index; |
| |
| index = drmmode_crtc_index_from_drawable(pScrn, pDraw); |
| if (index == -1) |
| return 0; |
| crtc = xf86_config->crtc[index]; |
| return drmmode_crtc_id(crtc); |
| } |
| |
| static drmmode_ptr |
| drmmode_from_scrn(ScrnInfoPtr pScrn) |
| { |
| xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn); |
| drmmode_crtc_private_ptr drmmode_crtc; |
| |
| drmmode_crtc = xf86_config->crtc[0]->driver_private; |
| return drmmode_crtc->drmmode; |
| } |
| |
| static void |
| drmmode_ConvertFromKMode(ScrnInfoPtr pScrn, drmModeModeInfo *kmode, |
| DisplayModePtr mode) |
| { |
| memset(mode, 0, sizeof(DisplayModeRec)); |
| mode->status = MODE_OK; |
| |
| mode->Clock = kmode->clock; |
| |
| mode->HDisplay = kmode->hdisplay; |
| mode->HSyncStart = kmode->hsync_start; |
| mode->HSyncEnd = kmode->hsync_end; |
| mode->HTotal = kmode->htotal; |
| mode->HSkew = kmode->hskew; |
| |
| mode->VDisplay = kmode->vdisplay; |
| mode->VSyncStart = kmode->vsync_start; |
| mode->VSyncEnd = kmode->vsync_end; |
| mode->VTotal = kmode->vtotal; |
| mode->VScan = kmode->vscan; |
| |
| mode->Flags = kmode->flags; //& FLAG_BITS; |
| mode->name = strdup(kmode->name); |
| |
| DEBUG_MSG("copy mode %s (%p %p)", kmode->name, mode->name, mode); |
| |
| if (kmode->type & DRM_MODE_TYPE_DRIVER) |
| mode->type = M_T_DRIVER; |
| if (kmode->type & DRM_MODE_TYPE_PREFERRED) |
| mode->type |= M_T_PREFERRED; |
| |
| xf86SetModeCrtc (mode, pScrn->adjustFlags); |
| } |
| |
| static void |
| drmmode_ConvertToKMode(ScrnInfoPtr pScrn, drmModeModeInfo *kmode, |
| DisplayModePtr mode) |
| { |
| memset(kmode, 0, sizeof(*kmode)); |
| |
| kmode->clock = mode->Clock; |
| kmode->hdisplay = mode->HDisplay; |
| kmode->hsync_start = mode->HSyncStart; |
| kmode->hsync_end = mode->HSyncEnd; |
| kmode->htotal = mode->HTotal; |
| kmode->hskew = mode->HSkew; |
| |
| kmode->vdisplay = mode->VDisplay; |
| kmode->vsync_start = mode->VSyncStart; |
| kmode->vsync_end = mode->VSyncEnd; |
| kmode->vtotal = mode->VTotal; |
| kmode->vscan = mode->VScan; |
| |
| kmode->flags = mode->Flags; //& FLAG_BITS; |
| if (mode->name) |
| strncpy(kmode->name, mode->name, DRM_DISPLAY_MODE_LEN); |
| kmode->name[DRM_DISPLAY_MODE_LEN-1] = 0; |
| } |
| |
| static void |
| drmmode_crtc_dpms(xf86CrtcPtr drmmode_crtc, int mode) |
| { |
| // FIXME - Implement this function |
| } |
| |
| static Bool |
| drmmode_set_crtc_off(xf86CrtcPtr crtc) |
| { |
| ScrnInfoPtr pScrn = crtc->scrn; |
| drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private; |
| uint32_t crtc_id = drmmode_crtc_id(crtc); |
| int rc; |
| |
| rc = drmModeSetCrtc(drmmode_crtc->drmmode->fd, crtc_id, 0, 0, 0, NULL, |
| 0, NULL); |
| if (rc) |
| ERROR_MSG("[CRTC:%u] disable failed: %s", crtc_id, |
| strerror(errno)); |
| |
| /* drmModeSetCrtc returns non-zero on error; convert to Bool */ |
| return (rc) ? FALSE : TRUE; |
| } |
| |
| static Bool |
| drmmode_set_crtc(ScrnInfoPtr pScrn, xf86CrtcPtr crtc, struct omap_bo *bo, int x, |
| int y) |
| { |
| xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn); |
| xf86OutputPtr output; |
| drmmode_crtc_private_ptr drmmode_crtc; |
| drmmode_output_private_ptr drmmode_output; |
| int rc, output_count, i; |
| uint32_t *output_ids = NULL; |
| uint32_t fb_id; |
| uint32_t crtc_id = drmmode_crtc_id(crtc); |
| drmModeModeInfo kmode; |
| Bool ret; |
| |
| output_ids = calloc(xf86_config->num_output, sizeof *output_ids); |
| assert(output_ids); |
| |
| output_count = 0; |
| for (i = 0; i < xf86_config->num_output; i++) { |
| output = xf86_config->output[i]; |
| drmmode_output = output->driver_private; |
| |
| if (output->crtc != crtc) |
| continue; |
| |
| output_ids[output_count] = drmmode_output->id; |
| output_count++; |
| } |
| if (!output_count) { |
| ERROR_MSG("[CRTC:%u] No outputs found", crtc_id); |
| ret = FALSE; |
| goto out; |
| } |
| |
| drmmode_ConvertToKMode(pScrn, &kmode, &crtc->mode); |
| |
| drmmode_crtc = crtc->driver_private; |
| fb_id = omap_bo_fb(bo); |
| /* drmModeSetCrtc returns non-zero on error; convert to Bool */ |
| rc = drmModeSetCrtc(drmmode_crtc->drmmode->fd, crtc_id, fb_id, x, y, |
| output_ids, output_count, &kmode); |
| if (rc) |
| ERROR_MSG("[CRTC:%u] failed to set mode with [FB:%u] @ (%d, %d): %s", |
| crtc_id, fb_id, x, y, strerror(errno)); |
| ret = rc ? FALSE : TRUE; |
| |
| out: |
| free(output_ids); |
| return ret; |
| } |
| |
| /* |
| * Copy region of @src starting at (@src_x, @src_y) to @dst at (@dst_x, dst_y). |
| * This function does no conversions, so it assumes same src and dst bpp. |
| * @src source buffer |
| * @src_x x coordinate from which to start copying |
| * @src_y y coordinate from which to start copying |
| * @src_width max number of pixels per src row to copy |
| * @src_height max number of src rows to copy |
| * @src_pitch total length of each src row, in bytes |
| * @src_cpp bytes (ie, chars) per pixel of source |
| * @dst destination buffer |
| * @dst_x x coordinate to which to start copying |
| * @dst_y y coordinate to which to start copying |
| * @dst_width max number of pixels per dst row to copy |
| * @dst_height max number of dst rows to copy |
| * @dst_pitch total length of each dst row, in bytes |
| * @dst_cpp bytes (ie, chars) per pixel of dst, must be same as src_cpp |
| */ |
| static void |
| drmmode_copy_from_to(const uint8_t *src, int src_x, int src_y, int src_width, |
| int src_height, int src_pitch, int src_cpp, |
| uint8_t *dst, int dst_x, int dst_y, int dst_width, |
| int dst_height, int dst_pitch, int dst_cpp) |
| { |
| int y; |
| int src_x_start = max(dst_x - src_x, 0); |
| int dst_x_start = max(src_x - dst_x, 0); |
| int src_y_start = max(dst_y - src_y, 0); |
| int dst_y_start = max(src_y - dst_y, 0); |
| int width = min(src_width - src_x_start, dst_width - dst_x_start); |
| int height = min(src_height - src_y_start, dst_height - dst_y_start); |
| |
| |
| assert(src_cpp == dst_cpp); |
| |
| if (width <= 0 || height <= 0) |
| return; |
| |
| src += src_y_start * src_pitch + src_x_start * src_cpp; |
| dst += dst_y_start * dst_pitch + dst_x_start * src_cpp; |
| |
| for (y = 0; y < height; y++, src += src_pitch, dst += dst_pitch) |
| memcpy(dst, src, width * dst_cpp); |
| } |
| |
| /* |
| * Copy region of src buffer located at (src_x, src_y) that overlaps the dst |
| * buffer at dst_x, dst_y. |
| * This function does no conversions, so it assumes same bpp and depth. |
| * It also assumes the two regions are non-overlapping memory areas, even though |
| * they may overlap in pixel space. |
| */ |
| static Bool |
| drmmode_copy_bo(ScrnInfoPtr pScrn, struct omap_bo *src_bo, int src_x, int src_y, |
| struct omap_bo *dst_bo, int dst_x, int dst_y) |
| { |
| void *dst; |
| const void *src; |
| |
| if (!src_bo || !dst_bo) { |
| ERROR_MSG("copy_bo received invalid arguments"); |
| return FALSE; |
| } |
| |
| assert(omap_bo_bpp(src_bo) == omap_bo_bpp(dst_bo)); |
| |
| src = omap_bo_map(src_bo); |
| if (!src) { |
| ERROR_MSG("Couldn't map src bo"); |
| return FALSE; |
| } |
| dst = omap_bo_map(dst_bo); |
| if (!dst) { |
| ERROR_MSG("Couldn't map dst bo"); |
| return FALSE; |
| } |
| |
| // acquire for write first, so if (probably impossible) src==dst acquire |
| // for read can succeed |
| omap_bo_cpu_prep(dst_bo, OMAP_GEM_WRITE); |
| omap_bo_cpu_prep(src_bo, OMAP_GEM_READ); |
| |
| drmmode_copy_from_to(src, src_x, src_y, |
| omap_bo_width(src_bo), omap_bo_height(src_bo), |
| omap_bo_pitch(src_bo), omap_bo_Bpp(src_bo), |
| dst, dst_x, dst_y, |
| omap_bo_width(dst_bo), omap_bo_height(dst_bo), |
| omap_bo_pitch(dst_bo), omap_bo_Bpp(dst_bo)); |
| |
| omap_bo_cpu_fini(src_bo, 0); |
| omap_bo_cpu_fini(dst_bo, 0); |
| |
| return TRUE; |
| } |
| |
| static Bool drmmode_set_blit_crtc(ScrnInfoPtr pScrn, xf86CrtcPtr crtc) |
| { |
| OMAPPtr pOMAP = OMAPPTR(pScrn); |
| Bool ret; |
| |
| if (!crtc->enabled) |
| return TRUE; |
| |
| ret = drmmode_set_crtc(pScrn, crtc, pOMAP->scanout, crtc->x, crtc->y); |
| if (!ret) { |
| ERROR_MSG("[CRTC:%u] set root scanout failed", |
| drmmode_crtc_id(crtc)); |
| drmmode_set_crtc_off(crtc); |
| } |
| |
| return ret; |
| } |
| |
| static Bool drmmode_set_flip_crtc(ScrnInfoPtr pScrn, xf86CrtcPtr crtc) |
| { |
| OMAPPtr pOMAP = OMAPPTR(pScrn); |
| OMAPScanoutPtr scanout; |
| Bool ret; |
| |
| if (!crtc->enabled) |
| return TRUE; |
| |
| scanout = drmmode_scanout_from_crtc(pOMAP->scanouts, crtc); |
| if (!scanout) |
| return TRUE; |
| |
| ret = drmmode_set_crtc(pScrn, crtc, scanout->bo, 0, 0); |
| if (!ret) { |
| ERROR_MSG("[CRTC:%u] set per-crtc scanout failed", |
| drmmode_crtc_id(crtc)); |
| drmmode_set_crtc_off(crtc); |
| } |
| |
| return ret; |
| } |
| |
| Bool drmmode_update_scanout_from_crtcs(ScrnInfoPtr pScrn) |
| { |
| OMAPPtr pOMAP = OMAPPTR(pScrn); |
| int i; |
| Bool res; |
| |
| if (pOMAP->flip_mode == OMAP_FLIP_DISABLED) |
| return TRUE; |
| |
| TRACE_ENTER(); |
| |
| /* Only copy if source is valid. */ |
| for (i = 0; i < MAX_SCANOUTS; i++) { |
| OMAPScanoutPtr scanout = &pOMAP->scanouts[i]; |
| |
| if (!scanout->bo) |
| continue; |
| if (!scanout->valid) |
| continue; |
| |
| res = drmmode_copy_bo(pScrn, scanout->bo, scanout->x, |
| scanout->y, pOMAP->scanout, 0, 0); |
| if (!res) { |
| ERROR_MSG("Copy crtc to scanout failed"); |
| goto out; |
| } |
| } |
| res = TRUE; |
| out: |
| TRACE_EXIT(); |
| return res; |
| } |
| |
| /* |
| * Enter blit mode. |
| * |
| * First, wait for all pending flips to complete. |
| * Next, copy all valid per-crtc bo contents to the root bo, and mark their |
| * scanouts as invalid to ensure they get updated when switching back to flip |
| * mode. |
| * Lastly, set all enabled crtcs to scan out from the root bo. |
| */ |
| Bool drmmode_set_blit_mode(ScrnInfoPtr pScrn) |
| { |
| OMAPPtr pOMAP = OMAPPTR(pScrn); |
| xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn); |
| int i; |
| Bool ret; |
| |
| if (pOMAP->flip_mode == OMAP_FLIP_DISABLED) |
| return TRUE; |
| |
| // wait for all flips to finish so we will read from the current buffer |
| while (pOMAP->pending_flips > 0) |
| drmmode_wait_for_event(pScrn); |
| |
| /* Only copy if source is valid. */ |
| for (i = 0; i < MAX_SCANOUTS; i++) { |
| OMAPScanoutPtr scanout = &pOMAP->scanouts[i]; |
| |
| if (!scanout->bo) |
| continue; |
| if (!scanout->valid) |
| continue; |
| |
| ret = drmmode_copy_bo(pScrn, scanout->bo, scanout->x, |
| scanout->y, pOMAP->scanout, 0, 0); |
| if (!ret) { |
| ERROR_MSG("Copy crtc to scanout failed"); |
| return FALSE; |
| } |
| scanout->valid = FALSE; |
| } |
| for (i = 0; i < xf86_config->num_crtc; i++) { |
| xf86CrtcPtr crtc = xf86_config->crtc[i]; |
| if (!drmmode_set_blit_crtc(pScrn, crtc)) { |
| ERROR_MSG("[CRTC:%u] could not set blit mode", |
| drmmode_crtc_id(crtc)); |
| goto unwind; |
| } |
| } |
| pOMAP->flip_mode = OMAP_FLIP_DISABLED; |
| return TRUE; |
| |
| unwind: |
| /* try restoring already transitioned CRTCs back to flip mode */ |
| while (--i >= 0) { |
| xf86CrtcPtr crtc = xf86_config->crtc[i]; |
| if (!drmmode_set_flip_crtc(pScrn, crtc)) |
| ERROR_MSG("[CRTC:%u] could not restore flip mode", |
| drmmode_crtc_id(crtc)); |
| } |
| return FALSE; |
| } |
| |
| /* |
| * Enter flip mode. |
| * |
| * First, copy contents from the root bo to each invalid per-crtc bo, and mark |
| * its scanout as valid. |
| * Lastly, set all enabled crtcs to scan out from their per-crtc bos. |
| */ |
| Bool drmmode_set_flip_mode(ScrnInfoPtr pScrn) |
| { |
| OMAPPtr pOMAP = OMAPPTR(pScrn); |
| xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn); |
| int i; |
| Bool ret; |
| |
| if (pOMAP->flip_mode == OMAP_FLIP_ENABLED) |
| return TRUE; |
| |
| /* Only copy if destination is invalid. */ |
| for (i = 0; i < MAX_SCANOUTS; i++) { |
| OMAPScanoutPtr scanout = &pOMAP->scanouts[i]; |
| |
| if (!scanout->bo) |
| continue; |
| if (scanout->valid) |
| continue; |
| |
| ret = drmmode_copy_bo(pScrn, pOMAP->scanout, 0, 0, |
| scanout->bo, scanout->x, |
| scanout->y); |
| if (!ret) { |
| ERROR_MSG("Copy scanout to crtc failed"); |
| return FALSE; |
| } |
| scanout->valid = TRUE; |
| } |
| |
| for (i = 0; i < xf86_config->num_crtc; i++) { |
| xf86CrtcPtr crtc = xf86_config->crtc[i]; |
| if (!drmmode_set_flip_crtc(pScrn, crtc)) { |
| ERROR_MSG("[CRTC:%u] could not set flip mode", |
| drmmode_crtc_id(crtc)); |
| goto unwind; |
| } |
| } |
| pOMAP->flip_mode = OMAP_FLIP_ENABLED; |
| return TRUE; |
| |
| unwind: |
| /* try restoring already transitioned CRTCs back to blit mode */ |
| while (--i >= 0) { |
| xf86CrtcPtr crtc = xf86_config->crtc[i]; |
| if (!drmmode_set_blit_crtc(pScrn, crtc)) |
| ERROR_MSG("[CRTC:%u] could not restore blit mode", |
| drmmode_crtc_id(crtc)); |
| } |
| return FALSE; |
| } |
| |
| static Bool drmmode_update_scanouts(ScrnInfoPtr pScrn) |
| { |
| OMAPPtr pOMAP = OMAPPTR(pScrn); |
| OMAPScanoutPtr scanout; |
| int i; |
| xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn); |
| xf86CrtcPtr crtc; |
| struct omap_bo *bo; |
| Bool valid; |
| |
| OMAPScanout old_scanouts[MAX_SCANOUTS]; |
| memcpy(old_scanouts, pOMAP->scanouts, sizeof(old_scanouts)); |
| memset(pOMAP->scanouts, 0, sizeof(pOMAP->scanouts)); |
| |
| for (i = 0; i < xf86_config->num_crtc; i++) { |
| crtc = xf86_config->crtc[i]; |
| if (!crtc->enabled || !crtc->mode.HDisplay || |
| !crtc->mode.VDisplay) |
| continue; |
| |
| scanout = drmmode_scanout_from_crtc(old_scanouts, crtc); |
| if (scanout) { |
| /* Use existing BO */ |
| bo = scanout->bo; |
| valid = scanout->valid; |
| memset(scanout, 0, sizeof(*scanout)); |
| } else { |
| /* Allocate a new BO */ |
| bo = omap_bo_new_with_depth(pOMAP->dev, |
| crtc->mode.HDisplay, |
| crtc->mode.VDisplay, pScrn->depth, |
| pScrn->bitsPerPixel); |
| if (!bo) { |
| ERROR_MSG("Scanout buffer allocation failed"); |
| return FALSE; |
| } |
| valid = FALSE; |
| } |
| scanout = drmmode_scanout_add(pOMAP->scanouts, crtc, bo); |
| if (!scanout) { |
| ERROR_MSG("Add scanout failed"); |
| omap_bo_unreference(bo); |
| return FALSE; |
| } |
| scanout->valid = valid; |
| |
| /* |
| * drmmode_scanout_add() adds a reference, but we either: |
| * * already have a reference, from a recycled BO |
| * * was given a reference when a new BO was allocated |
| */ |
| omap_bo_unreference(bo); |
| } |
| |
| /* Drop the remaining unused BOs. */ |
| for (i = 0; i < MAX_SCANOUTS; i++) |
| if (old_scanouts[i].bo != NULL) { |
| /* |
| * Set has_resized when discarding active scanouts. This |
| * ensures we trigger the blit/flip logic which will |
| * setcrtc to a valid fb if needed |
| */ |
| pOMAP->has_resized = TRUE; |
| omap_bo_unreference(old_scanouts[i].bo); |
| } |
| |
| return TRUE; |
| } |
| |
| static Bool |
| drmmode_set_mode_major(xf86CrtcPtr crtc, DisplayModePtr mode, |
| Rotation rotation, int x, int y) |
| { |
| ScrnInfoPtr pScrn = crtc->scrn; |
| OMAPPtr pOMAP = OMAPPTR(pScrn); |
| xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(crtc->scrn); |
| Bool ret; |
| int i; |
| |
| TRACE_ENTER(); |
| |
| ret = xf86CrtcRotate(crtc); |
| if (!ret) |
| goto done; |
| |
| // On a modeset, we should switch to blit mode to get a single scanout buffer |
| // and we will switch back to flip mode on the next flip request |
| if (pOMAP->flip_mode == OMAP_FLIP_DISABLED) |
| ret = drmmode_set_crtc(pScrn, crtc, pOMAP->scanout, crtc->x, crtc->y); |
| else |
| ret = drmmode_set_blit_mode(pScrn); |
| if (!ret) |
| goto done; |
| |
| // Fixme - Intel puts this function here, and Nouveau puts it at the end |
| // of this function -> determine what's best for TI'S OMAP4: |
| if (crtc->funcs->gamma_set) |
| crtc->funcs->gamma_set(crtc, crtc->gamma_red, crtc->gamma_green, |
| crtc->gamma_blue, crtc->gamma_size); |
| |
| ret = drmmode_update_scanouts(pScrn); |
| if (!ret) { |
| ERROR_MSG("Update scanouts failed"); |
| goto done; |
| } |
| |
| // FIXME - DO WE NEED TO CALL TO THE PVR EXA/DRI2 CODE TO UPDATE THEM??? |
| |
| /* Turn on any outputs on this crtc that may have been disabled: */ |
| for (i = 0; i < xf86_config->num_output; i++) { |
| xf86OutputPtr output = xf86_config->output[i]; |
| |
| if (output->crtc != crtc) |
| continue; |
| |
| drmmode_output_dpms(output, DPMSModeOn); |
| } |
| |
| /* |
| * The screen has reconfigured, so reload hw cursor images as needed, |
| * and adjust cursor positions. |
| */ |
| xf86_reload_cursors(pScrn->pScreen); |
| |
| done: |
| TRACE_EXIT(); |
| return ret; |
| } |
| |
| #define CURSORW 64 |
| #define CURSORH 64 |
| |
| static void |
| drmmode_set_cursor_position(xf86CrtcPtr crtc, int x, int y) |
| { |
| drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private; |
| drmmode_ptr drmmode = drmmode_crtc->drmmode; |
| |
| drmModeMoveCursor(drmmode->fd, drmmode_crtc_id(crtc), x, y); |
| } |
| |
| static void |
| drmmode_hide_cursor(xf86CrtcPtr crtc) |
| { |
| drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private; |
| drmmode_ptr drmmode = drmmode_crtc->drmmode; |
| |
| drmModeSetCursor(drmmode->fd, drmmode_crtc_id(crtc), 0, CURSORW, CURSORH); |
| } |
| |
| static void |
| drmmode_show_cursor(xf86CrtcPtr crtc) |
| { |
| drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private; |
| drmmode_ptr drmmode = drmmode_crtc->drmmode; |
| struct omap_bo* cursor_bo = drmmode_crtc->cursor_bo; |
| uint32_t handle = cursor_bo ? omap_bo_handle(cursor_bo) : 0; |
| drmModeSetCursor(drmmode->fd, drmmode_crtc_id(crtc), handle, CURSORW, CURSORH); |
| } |
| |
| static void |
| drmmode_load_cursor_argb(xf86CrtcPtr crtc, CARD32 *image) |
| { |
| drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private; |
| struct omap_bo* cursor_bo = drmmode_crtc->cursor_bo; |
| int row; |
| void* dst; |
| const char* src_row; |
| char* dst_row; |
| |
| if (!cursor_bo) |
| return; |
| |
| dst = omap_bo_map(cursor_bo); |
| omap_bo_cpu_prep(cursor_bo, OMAP_GEM_WRITE); |
| for (row = 0; row < CURSORH; row += 1) { |
| // we're operating with ARGB data (32bpp) |
| src_row = (const char*)image + row * 4 * CURSORW; |
| dst_row = (char*)dst + row * 4 * CURSORW; |
| memcpy(dst_row, src_row, 4 * CURSORW); |
| } |
| omap_bo_cpu_fini(cursor_bo, 0); |
| } |
| |
| #ifdef OMAP_SUPPORT_GAMMA |
| static void |
| drmmode_gamma_set(xf86CrtcPtr crtc, CARD16 *red, CARD16 *green, CARD16 *blue, |
| int size) |
| { |
| drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private; |
| drmmode_ptr drmmode = drmmode_crtc->drmmode; |
| int ret; |
| |
| ret = drmModeCrtcSetGamma(drmmode->fd, drmmode_crtc_id(crtc), |
| size, red, green, blue); |
| if (ret != 0) { |
| xf86DrvMsg(crtc->scrn->scrnIndex, X_ERROR, |
| "failed to set gamma: %s\n", strerror(-ret)); |
| } |
| } |
| #endif |
| |
| static void |
| drmmode_crtc_destroy(xf86CrtcPtr crtc) |
| { |
| drmmode_crtc_private_ptr drmmode_crtc = crtc->driver_private; |
| |
| omap_bo_unreference(drmmode_crtc->cursor_bo); |
| free(drmmode_crtc); |
| crtc->driver_private = NULL; |
| } |
| |
| static const xf86CrtcFuncsRec drmmode_crtc_funcs = { |
| .destroy = drmmode_crtc_destroy, |
| .dpms = drmmode_crtc_dpms, |
| .set_mode_major = drmmode_set_mode_major, |
| .set_cursor_position = drmmode_set_cursor_position, |
| .show_cursor = drmmode_show_cursor, |
| .hide_cursor = drmmode_hide_cursor, |
| .load_cursor_argb = drmmode_load_cursor_argb, |
| #ifdef OMAP_SUPPORT_GAMMA |
| .gamma_set = drmmode_gamma_set, |
| #endif |
| }; |
| |
| |
| static Bool |
| drmmode_crtc_pre_init(ScrnInfoPtr pScrn, drmmode_ptr drmmode, |
| const drmModeResPtr mode_res, |
| const drmModePlaneResPtr plane_res, int num) |
| { |
| xf86CrtcPtr crtc; |
| drmmode_crtc_private_ptr drmmode_crtc; |
| Bool ret; |
| uint32_t crtc_id = mode_res->crtcs[num]; |
| OMAPPtr pOMAP = OMAPPTR(pScrn); |
| |
| TRACE_ENTER(); |
| |
| drmmode_crtc = calloc(1, sizeof *drmmode_crtc); |
| if (!drmmode_crtc) { |
| ERROR_MSG("CRTC[%u]: Failed to allocate drmmode_crtc", |
| crtc_id); |
| ret = FALSE; |
| goto out; |
| } |
| drmmode_crtc->id = crtc_id; |
| drmmode_crtc->drmmode = drmmode; |
| drmmode_crtc->cursor_bo = omap_bo_new_with_format(pOMAP->dev, CURSORW, CURSORH, |
| DRM_FORMAT_ARGB8888, 32); |
| if (!drmmode_crtc->cursor_bo) { |
| ERROR_MSG("error allocating hw cursor buffer"); |
| ret = FALSE; |
| goto err_free_drmmode_crtc; |
| } |
| |
| crtc = xf86CrtcCreate(pScrn, &drmmode_crtc_funcs); |
| if (crtc == NULL) { |
| ERROR_MSG("CRTC[%u]: Failed to create xf86Crtc", crtc_id); |
| ret = FALSE; |
| goto err_destroy_cursor; |
| } |
| |
| INFO_MSG("[CRTC:%u] HW Cursor using [BO:%u]", |
| drmmode_crtc->id, |
| omap_bo_handle(drmmode_crtc->cursor_bo)); |
| |
| crtc->driver_private = drmmode_crtc; |
| |
| ret = TRUE; |
| goto out; |
| |
| err_destroy_cursor: |
| omap_bo_unreference(drmmode_crtc->cursor_bo); |
| err_free_drmmode_crtc: |
| free(drmmode_crtc); |
| out: |
| TRACE_EXIT(); |
| return ret; |
| } |
| |
| static xf86OutputStatus |
| drmmode_output_detect(xf86OutputPtr output) |
| { |
| /* go to the hw and retrieve a new output struct */ |
| drmmode_output_private_ptr drmmode_output = output->driver_private; |
| drmmode_ptr drmmode = drmmode_output->drmmode; |
| xf86OutputStatus status; |
| drmModeFreeConnector(drmmode_output->mode_output); |
| |
| drmmode_output->mode_output = |
| drmModeGetConnector(drmmode->fd, drmmode_output->id); |
| |
| switch (drmmode_output->mode_output->connection) { |
| case DRM_MODE_CONNECTED: |
| status = XF86OutputStatusConnected; |
| break; |
| case DRM_MODE_DISCONNECTED: |
| status = XF86OutputStatusDisconnected; |
| break; |
| default: |
| case DRM_MODE_UNKNOWNCONNECTION: |
| status = XF86OutputStatusUnknown; |
| break; |
| } |
| return status; |
| } |
| |
| static Bool |
| drmmode_output_mode_valid(xf86OutputPtr output, DisplayModePtr mode) |
| { |
| if (mode->type & M_T_DEFAULT) |
| /* Default modes are harmful here. */ |
| return MODE_BAD; |
| |
| return MODE_OK; |
| } |
| |
| static DisplayModePtr |
| drmmode_output_get_modes(xf86OutputPtr output) |
| { |
| ScrnInfoPtr pScrn = output->scrn; |
| drmmode_output_private_ptr drmmode_output = output->driver_private; |
| drmModeConnectorPtr koutput = drmmode_output->mode_output; |
| drmmode_ptr drmmode = drmmode_output->drmmode; |
| DisplayModePtr Modes = NULL, Mode; |
| drmModePropertyPtr prop; |
| xf86MonPtr ddc_mon = NULL; |
| int i; |
| |
| /* look for an EDID property */ |
| for (i = 0; i < koutput->count_props; i++) { |
| prop = drmModeGetProperty(drmmode->fd, koutput->props[i]); |
| if (!prop) |
| continue; |
| |
| if ((prop->flags & DRM_MODE_PROP_BLOB) && |
| !strcmp(prop->name, "EDID")) { |
| if (drmmode_output->edid_blob) |
| drmModeFreePropertyBlob(drmmode_output->edid_blob); |
| drmmode_output->edid_blob = |
| drmModeGetPropertyBlob(drmmode->fd, |
| koutput->prop_values[i]); |
| } |
| drmModeFreeProperty(prop); |
| } |
| |
| if (drmmode_output->edid_blob) |
| ddc_mon = xf86InterpretEDID(pScrn->scrnIndex, |
| drmmode_output->edid_blob->data); |
| |
| if (ddc_mon) { |
| xf86OutputSetEDID(output, ddc_mon); |
| xf86SetDDCproperties(pScrn, ddc_mon); |
| } |
| |
| DEBUG_MSG("count_modes: %d", koutput->count_modes); |
| |
| /* modes should already be available */ |
| for (i = 0; i < koutput->count_modes; i++) { |
| Mode = xnfalloc(sizeof(DisplayModeRec)); |
| |
| drmmode_ConvertFromKMode(pScrn, &koutput->modes[i], |
| Mode); |
| Modes = xf86ModesAdd(Modes, Mode); |
| |
| } |
| return Modes; |
| } |
| |
| static void |
| drmmode_output_destroy(xf86OutputPtr output) |
| { |
| drmmode_output_private_ptr drmmode_output = output->driver_private; |
| int i; |
| |
| if (drmmode_output->edid_blob) |
| drmModeFreePropertyBlob(drmmode_output->edid_blob); |
| for (i = 0; i < drmmode_output->num_props; i++) { |
| drmModeFreeProperty(drmmode_output->props[i].mode_prop); |
| free(drmmode_output->props[i].atoms); |
| } |
| free(drmmode_output->props); |
| drmModeFreeConnector(drmmode_output->mode_output); |
| free(drmmode_output); |
| output->driver_private = NULL; |
| } |
| |
| static void |
| drmmode_output_dpms(xf86OutputPtr output, int mode) |
| { |
| ScrnInfoPtr pScrn = output->scrn; |
| drmmode_output_private_ptr drmmode_output = output->driver_private; |
| drmmode_ptr drmmode = drmmode_output->drmmode; |
| int ret; |
| |
| if (!drmmode_output->dpms_id) |
| return; |
| |
| ret = drmModeConnectorSetProperty(drmmode->fd, drmmode_output->id, |
| drmmode_output->dpms_id, mode); |
| if (ret) |
| ERROR_MSG("[CONNECTOR:%u] Failed to set [DPMS:%u]", |
| drmmode_output->id, mode); |
| } |
| |
| static Bool |
| drmmode_property_ignore(drmModePropertyPtr prop) |
| { |
| if (!prop) |
| return TRUE; |
| /* ignore blob prop */ |
| if (prop->flags & DRM_MODE_PROP_BLOB) |
| return TRUE; |
| /* ignore standard property */ |
| if (!strcmp(prop->name, "EDID") || |
| !strcmp(prop->name, "DPMS")) |
| return TRUE; |
| |
| return FALSE; |
| } |
| |
| static void |
| drmmode_output_create_resources(xf86OutputPtr output) |
| { |
| drmmode_output_private_ptr drmmode_output = output->driver_private; |
| drmModeConnectorPtr mode_output = drmmode_output->mode_output; |
| drmmode_ptr drmmode = drmmode_output->drmmode; |
| drmModePropertyPtr drmmode_prop; |
| uint32_t value; |
| int i, j, err; |
| |
| drmmode_output->props = calloc(mode_output->count_props, |
| sizeof *drmmode_output->props); |
| if (!drmmode_output->props) |
| return; |
| |
| drmmode_output->num_props = 0; |
| for (i = 0, j = 0; i < mode_output->count_props; i++) { |
| drmmode_prop = drmModeGetProperty(drmmode->fd, mode_output->props[i]); |
| if (drmmode_property_ignore(drmmode_prop)) { |
| drmModeFreeProperty(drmmode_prop); |
| continue; |
| } |
| drmmode_output->props[j].mode_prop = drmmode_prop; |
| drmmode_output->props[j].index = i; |
| drmmode_output->num_props++; |
| j++; |
| } |
| |
| for (i = 0; i < drmmode_output->num_props; i++) { |
| drmmode_prop_ptr p = &drmmode_output->props[i]; |
| drmmode_prop = p->mode_prop; |
| |
| value = drmmode_output->mode_output->prop_values[p->index]; |
| |
| if (drmmode_prop->flags & DRM_MODE_PROP_RANGE) { |
| INT32 range[2]; |
| |
| p->num_atoms = 1; |
| p->atoms = calloc(p->num_atoms, sizeof *p->atoms); |
| if (!p->atoms) |
| continue; |
| p->atoms[0] = MakeAtom(drmmode_prop->name, strlen(drmmode_prop->name), TRUE); |
| range[0] = drmmode_prop->values[0]; |
| range[1] = drmmode_prop->values[1]; |
| err = RRConfigureOutputProperty(output->randr_output, p->atoms[0], |
| FALSE, TRUE, |
| drmmode_prop->flags & DRM_MODE_PROP_IMMUTABLE ? TRUE : FALSE, |
| 2, range); |
| if (err != 0) { |
| xf86DrvMsg(output->scrn->scrnIndex, X_ERROR, |
| "RRConfigureOutputProperty error, %d\n", err); |
| } |
| err = RRChangeOutputProperty(output->randr_output, p->atoms[0], |
| XA_INTEGER, 32, PropModeReplace, 1, |
| &value, FALSE, FALSE); |
| if (err != 0) { |
| xf86DrvMsg(output->scrn->scrnIndex, X_ERROR, |
| "RRChangeOutputProperty error, %d\n", err); |
| } |
| } else if (drmmode_prop->flags & DRM_MODE_PROP_ENUM) { |
| p->num_atoms = drmmode_prop->count_enums + 1; |
| p->atoms = calloc(p->num_atoms, sizeof *p->atoms); |
| if (!p->atoms) |
| continue; |
| p->atoms[0] = MakeAtom(drmmode_prop->name, strlen(drmmode_prop->name), TRUE); |
| for (j = 1; j <= drmmode_prop->count_enums; j++) { |
| struct drm_mode_property_enum *e = &drmmode_prop->enums[j-1]; |
| p->atoms[j] = MakeAtom(e->name, strlen(e->name), TRUE); |
| } |
| err = RRConfigureOutputProperty(output->randr_output, p->atoms[0], |
| FALSE, FALSE, |
| drmmode_prop->flags & DRM_MODE_PROP_IMMUTABLE ? TRUE : FALSE, |
| p->num_atoms - 1, (INT32 *)&p->atoms[1]); |
| if (err != 0) { |
| xf86DrvMsg(output->scrn->scrnIndex, X_ERROR, |
| "RRConfigureOutputProperty error, %d\n", err); |
| } |
| for (j = 0; j < drmmode_prop->count_enums; j++) |
| if (drmmode_prop->enums[j].value == value) |
| break; |
| /* there's always a matching value */ |
| err = RRChangeOutputProperty(output->randr_output, p->atoms[0], |
| XA_ATOM, 32, PropModeReplace, 1, &p->atoms[j+1], FALSE, FALSE); |
| if (err != 0) { |
| xf86DrvMsg(output->scrn->scrnIndex, X_ERROR, |
| "RRChangeOutputProperty error, %d\n", err); |
| } |
| } |
| } |
| } |
| |
| static Bool |
| drmmode_output_set_property(xf86OutputPtr output, Atom property, |
| RRPropertyValuePtr value) |
| { |
| drmmode_output_private_ptr drmmode_output = output->driver_private; |
| drmmode_ptr drmmode = drmmode_output->drmmode; |
| int i, ret; |
| |
| for (i = 0; i < drmmode_output->num_props; i++) { |
| drmmode_prop_ptr p = &drmmode_output->props[i]; |
| |
| if (p->atoms[0] != property) |
| continue; |
| |
| if (p->mode_prop->flags & DRM_MODE_PROP_RANGE) { |
| uint32_t val; |
| |
| if (value->type != XA_INTEGER || value->format != 32 || |
| value->size != 1) |
| return FALSE; |
| val = *(uint32_t *)value->data; |
| |
| ret = drmModeConnectorSetProperty(drmmode->fd, |
| drmmode_output->id, |
| p->mode_prop->prop_id, (uint64_t)val); |
| |
| if (ret) |
| return FALSE; |
| |
| return TRUE; |
| |
| } else if (p->mode_prop->flags & DRM_MODE_PROP_ENUM) { |
| Atom atom; |
| const char *name; |
| int j; |
| |
| if (value->type != XA_ATOM || value->format != 32 || value->size != 1) |
| return FALSE; |
| memcpy(&atom, value->data, 4); |
| name = NameForAtom(atom); |
| if (name == NULL) |
| return FALSE; |
| |
| /* search for matching name string, then set its value down */ |
| for (j = 0; j < p->mode_prop->count_enums; j++) { |
| if (!strcmp(p->mode_prop->enums[j].name, name)) { |
| ret = drmModeConnectorSetProperty(drmmode->fd, |
| drmmode_output->id, |
| p->mode_prop->prop_id, |
| p->mode_prop->enums[j].value); |
| |
| if (ret) |
| return FALSE; |
| |
| return TRUE; |
| } |
| } |
| |
| return FALSE; |
| } |
| } |
| |
| return TRUE; |
| } |
| |
| /* These are borrowed from libdrm/xf86drmMode.c */ |
| #define U642VOID(x) ((void *)(unsigned long)(x)) |
| #define VOID2U64(x) ((uint64_t)(unsigned long)(x)) |
| |
| static Bool |
| drmmode_output_get_property_from_connector(xf86OutputPtr output, int prop_idx, |
| uint64_t *val) |
| { |
| drmmode_output_private_ptr drmmode_output = output->driver_private; |
| drmmode_ptr drmmode = drmmode_output->drmmode; |
| struct drm_mode_get_connector conn, counts; |
| struct drm_mode_modeinfo mode; |
| uint64_t *prop_values; |
| Bool r = TRUE; |
| |
| retry: |
| memset(&conn, 0, sizeof(struct drm_mode_get_connector)); |
| conn.connector_id = drmmode_output->id; |
| |
| /* |
| * This is a hack to prevent the kernel from calling get_modes() |
| * on this connector when all we really want is a property |
| * value. In certain cases, fetching the display modes can take |
| * on the order of seconds, and we don't want to spend that |
| * long here. |
| * |
| * By requesting one mode, the kernel will just fill up modes_ptr with |
| * the first mode (if it exists), and it'll be a noop if there are |
| * no modes. It's important that we don't use this mode for anything |
| * since it could be out-of-date. |
| */ |
| conn.count_modes = 1; |
| conn.modes_ptr = VOID2U64(&mode); |
| if (drmIoctl(drmmode->fd, DRM_IOCTL_MODE_GETCONNECTOR, &conn)) |
| return FALSE; |
| |
| counts = conn; |
| |
| if (!conn.count_props) |
| return FALSE; |
| |
| conn.props_ptr = VOID2U64( |
| drmMalloc(conn.count_props * sizeof(uint32_t))); |
| if (!conn.props_ptr) { |
| r = FALSE; |
| goto err_allocs; |
| } |
| |
| conn.prop_values_ptr = VOID2U64( |
| drmMalloc(conn.count_props * sizeof(uint64_t))); |
| if (!conn.prop_values_ptr) { |
| r = FALSE; |
| goto err_allocs; |
| } |
| |
| /* Reset the encoder/mode counts so we don't fetch them */ |
| conn.count_encoders = 0; |
| conn.count_modes = 1; |
| if (drmIoctl(drmmode->fd, DRM_IOCTL_MODE_GETCONNECTOR, &conn)) { |
| r = FALSE; |
| goto err_allocs; |
| } |
| |
| /* |
| * The number of props may have changed with a hotplug event in between |
| * the ioctls, in which case the field is silently ignored by the |
| * kernel. |
| */ |
| if (counts.count_props < conn.count_props) { |
| drmFree(U642VOID(conn.props_ptr)); |
| drmFree(U642VOID(conn.prop_values_ptr)); |
| goto retry; |
| } |
| |
| if (conn.count_props <= prop_idx) { |
| r = FALSE; |
| goto err_allocs; |
| } |
| |
| prop_values = U642VOID(conn.prop_values_ptr); |
| *val = prop_values[prop_idx]; |
| |
| err_allocs: |
| drmFree(U642VOID(conn.prop_values_ptr)); |
| drmFree(U642VOID(conn.props_ptr)); |
| |
| return r; |
| } |
| |
| static Bool |
| drmmode_output_get_property(xf86OutputPtr output, Atom property) |
| { |
| drmmode_output_private_ptr drmmode_output = output->driver_private; |
| drmmode_prop_ptr p = NULL; |
| uint64_t value; |
| int err, i; |
| |
| for (i = 0; i < drmmode_output->num_props; i++) { |
| p = &drmmode_output->props[i]; |
| if (p->atoms[0] == property) |
| break; |
| } |
| if (i == drmmode_output->num_props) |
| return FALSE; |
| |
| if (output->scrn->vtSema) { |
| if (!drmmode_output_get_property_from_connector(output, |
| p->index, &value)) |
| return FALSE; |
| } else { |
| value = drmmode_output->mode_output->prop_values[p->index]; |
| } |
| |
| if (p->mode_prop->flags & DRM_MODE_PROP_RANGE) { |
| err = RRChangeOutputProperty(output->randr_output, |
| property, XA_INTEGER, 32, |
| PropModeReplace, 1, &value, |
| FALSE, FALSE); |
| |
| return !err; |
| } else if (p->mode_prop->flags & DRM_MODE_PROP_ENUM) { |
| int j; |
| |
| /* search for matching name string, then set its value down */ |
| for (j = 0; j < p->mode_prop->count_enums; j++) { |
| if (p->mode_prop->enums[j].value == value) |
| break; |
| } |
| |
| err = RRChangeOutputProperty(output->randr_output, property, |
| XA_ATOM, 32, PropModeReplace, 1, |
| &p->atoms[j+1], FALSE, FALSE); |
| |
| return !err; |
| } |
| |
| return FALSE; |
| } |
| |
| static const xf86OutputFuncsRec drmmode_output_funcs = { |
| .create_resources = drmmode_output_create_resources, |
| .dpms = drmmode_output_dpms, |
| .detect = drmmode_output_detect, |
| .mode_valid = drmmode_output_mode_valid, |
| .get_modes = drmmode_output_get_modes, |
| .set_property = drmmode_output_set_property, |
| .get_property = drmmode_output_get_property, |
| .destroy = drmmode_output_destroy |
| }; |
| |
| // FIXME - Eliminate the following values that aren't accurate for OMAP4: |
| const char *output_names[] = { "None", |
| "VGA", |
| "DVI-I", |
| "DVI-D", |
| "DVI-A", |
| "Composite", |
| "SVIDEO", |
| "LVDS", |
| "CTV", |
| "DIN", |
| "DP", |
| "HDMI", |
| "HDMI", |
| "TV", |
| "eDP", |
| }; |
| #define NUM_OUTPUT_NAMES (sizeof(output_names) / sizeof(output_names[0])) |
| |
| static Bool |
| drmmode_output_pre_init(ScrnInfoPtr pScrn, drmmode_ptr drmmode, |
| const drmModeResPtr mode_res, int num) |
| { |
| xf86OutputPtr output; |
| drmModeConnectorPtr koutput; |
| drmModeEncoderPtr kencoder; |
| drmmode_output_private_ptr drmmode_output; |
| char name[32]; |
| CARD32 possible_crtcs, possible_clones; |
| uint32_t connector_id = mode_res->connectors[num]; |
| |
| Bool ret; |
| |
| TRACE_ENTER(); |
| |
| koutput = drmModeGetConnector(drmmode->fd, connector_id); |
| if (!koutput) { |
| ERROR_MSG("[CONNECTOR:%u] Failed drmModeGetConnector", |
| connector_id); |
| ret = FALSE; |
| goto out; |
| } |
| |
| /* |
| * Fetch possible clones and crtcs from this connector's encoder. |
| * We assume here that there is only one possible encoder for this |
| * connector. |
| */ |
| kencoder = drmModeGetEncoder(drmmode->fd, koutput->encoders[0]); |
| if (!kencoder) { |
| ERROR_MSG("[CONNECTOR:%u] Failed drmModeGetEncoder", |
| connector_id); |
| ret = FALSE; |
| goto err_free_drm_mode_connector; |
| } |
| |
| possible_crtcs = kencoder->possible_crtcs; |
| possible_clones = kencoder->possible_clones; |
| drmModeFreeEncoder(kencoder); |
| |
| if (koutput->connector_type >= NUM_OUTPUT_NAMES) |
| snprintf(name, 32, "Unknown%d-%d", koutput->connector_type, |
| koutput->connector_type_id); |
| else |
| snprintf(name, 32, "%s-%d", |
| output_names[koutput->connector_type], |
| koutput->connector_type_id); |
| |
| drmmode_output = calloc(1, sizeof *drmmode_output); |
| if (!drmmode_output) { |
| ERROR_MSG("[CONNECTOR:%u] Failed to allocate drmmode_output", |
| connector_id); |
| ret = FALSE; |
| goto err_free_drm_mode_connector; |
| } |
| |
| drmmode_output->id = connector_id; |
| drmmode_output->mode_output = koutput; |
| drmmode_output->drmmode = drmmode; |
| drmmode_output->dpms_id = drmmode_get_prop_id(drmmode->fd, |
| koutput->count_props, koutput->props, |
| "DPMS", DRM_MODE_PROP_ENUM); |
| |
| output = xf86OutputCreate(pScrn, &drmmode_output_funcs, name); |
| if (!output) { |
| ERROR_MSG("[CONNECTOR:%u] Failed xf86OutputCreate", |
| connector_id); |
| ret = FALSE; |
| goto err_free_drmmode_output; |
| } |
| |
| output->mm_width = koutput->mmWidth; |
| output->mm_height = koutput->mmHeight; |
| output->driver_private = drmmode_output; |
| |
| output->possible_crtcs = possible_crtcs; |
| output->possible_clones = possible_clones; |
| output->interlaceAllowed = TRUE; |
| |
| ret = TRUE; |
| goto out; |
| |
| err_free_drmmode_output: |
| free(drmmode_output); |
| err_free_drm_mode_connector: |
| drmModeFreeConnector(koutput); |
| out: |
| TRACE_EXIT(); |
| return ret; |
| } |
| |
| static Bool |
| drmmode_xf86crtc_resize(ScrnInfoPtr pScrn, int width, int height) |
| { |
| OMAPPtr pOMAP = OMAPPTR(pScrn); |
| ScreenPtr pScreen = pScrn->pScreen; |
| struct omap_bo *new_scanout; |
| uint32_t pitch; |
| |
| TRACE_ENTER(); |
| |
| /* if fb required size has changed, realloc! */ |
| |
| DEBUG_MSG("Resize! %dx%d", width, height); |
| |
| if ( (width != omap_bo_width(pOMAP->scanout)) |
| || (height != omap_bo_height(pOMAP->scanout)) |
| || (pScrn->bitsPerPixel != omap_bo_bpp(pOMAP->scanout)) ) { |
| |
| DEBUG_MSG("allocating new scanout buffer: %dx%d", |
| width, height); |
| |
| /* allocate new scanout buffer */ |
| new_scanout = omap_bo_new_with_depth(pOMAP->dev, width, |
| height, pScrn->depth, |
| pScrn->bitsPerPixel); |
| if (!new_scanout) { |
| ERROR_MSG("Error reallocating scanout buffer"); |
| return FALSE; |
| } |
| |
| pOMAP->has_resized = TRUE; |
| omap_bo_unreference(pOMAP->scanout); |
| pOMAP->scanout = new_scanout; |
| } |
| |
| pScrn->virtualX = width; |
| pScrn->virtualY = height; |
| pitch = omap_bo_pitch(pOMAP->scanout); |
| pScrn->displayWidth = pitch / ((pScrn->bitsPerPixel + 7) / 8); |
| |
| if (pScreen && pScreen->ModifyPixmapHeader) { |
| PixmapPtr rootPixmap = pScreen->GetScreenPixmap(pScreen); |
| pScreen->ModifyPixmapHeader(rootPixmap, |
| pScrn->virtualX, pScrn->virtualY, |
| pScrn->depth, pScrn->bitsPerPixel, pitch, |
| omap_bo_map(pOMAP->scanout)); |
| } |
| |
| TRACE_EXIT(); |
| return TRUE; |
| } |
| |
| static const xf86CrtcConfigFuncsRec drmmode_xf86crtc_config_funcs = { |
| .resize = drmmode_xf86crtc_resize |
| }; |
| |
| static void drmmode_crtcs_destroy(ScrnInfoPtr pScrn) |
| { |
| xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn); |
| |
| /* |
| * xf86CrtcDestroy() removes crtc from list and memmoves the other |
| * entries, and decrements num_crtc. |
| * Hence, as an optimization, we work backwards num_crtc. |
| */ |
| while (xf86_config->num_crtc) { |
| int c = xf86_config->num_crtc - 1; |
| xf86CrtcPtr crtc = xf86_config->crtc[c]; |
| xf86CrtcDestroy(crtc); |
| } |
| } |
| |
| static void drmmode_outputs_destroy(ScrnInfoPtr pScrn) |
| { |
| xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn); |
| |
| /* |
| * xf86OutputDestroy() removes output from list and memmoves the other |
| * entries, and decrements num_output. |
| * Hence, as an optimization, we work backwards num_output. |
| */ |
| while (xf86_config->num_output) { |
| int o = xf86_config->num_output - 1; |
| xf86OutputPtr output = xf86_config->output[o]; |
| xf86OutputDestroy(output); |
| } |
| } |
| |
| Bool drmmode_pre_init(ScrnInfoPtr pScrn, int fd) |
| { |
| drmmode_ptr drmmode; |
| drmModeResPtr mode_res; |
| drmModePlaneResPtr plane_res; |
| int i; |
| Bool ret; |
| |
| TRACE_ENTER(); |
| |
| pScrn->canDoBGNoneRoot = TRUE; |
| |
| xf86CrtcConfigInit(pScrn, &drmmode_xf86crtc_config_funcs); |
| |
| mode_res = drmModeGetResources(fd); |
| if (!mode_res) { |
| ret = FALSE; |
| goto out; |
| } |
| DEBUG_MSG("Got KMS resources"); |
| DEBUG_MSG(" %d connectors, %d encoders", |
| mode_res->count_connectors, |
| mode_res->count_encoders); |
| DEBUG_MSG(" %d crtcs, %d fbs", |
| mode_res->count_crtcs, mode_res->count_fbs); |
| DEBUG_MSG(" %dx%d minimum resolution", |
| mode_res->min_width, mode_res->min_height); |
| DEBUG_MSG(" %dx%d maximum resolution", |
| mode_res->max_width, mode_res->max_height); |
| |
| xf86CrtcSetSizeRange(pScrn, 320, 200, mode_res->max_width, |
| mode_res->max_height); |
| |
| plane_res = drmModeGetPlaneResources(fd); |
| if (!plane_res) { |
| ERROR_MSG("drmModeGetPlaneResources failed: %s", |
| strerror(errno)); |
| ret = FALSE; |
| goto err_free_drm_resources; |
| } |
| DEBUG_MSG(" %d planes", plane_res->count_planes); |
| |
| drmmode = calloc(1, sizeof *drmmode); |
| if (!drmmode) { |
| ERROR_MSG("Failed to allocate drmmode"); |
| ret = FALSE; |
| goto err_free_drm_plane_resources; |
| } |
| drmmode->fd = fd; |
| |
| ret = TRUE; |
| for (i = 0; i < mode_res->count_crtcs && ret; i++) |
| ret = drmmode_crtc_pre_init(pScrn, drmmode, mode_res, |
| plane_res, i); |
| if (!ret) |
| goto err_crtcs_destroy; |
| |
| for (i = 0; i < mode_res->count_connectors && ret; i++) |
| ret = drmmode_output_pre_init(pScrn, drmmode, mode_res, i); |
| if (!ret) |
| goto err_outputs_destroy; |
| |
| ret = xf86InitialConfiguration(pScrn, TRUE); |
| if (!ret) { |
| ERROR_MSG("xf86 Initial Configuration failed"); |
| goto err_outputs_destroy; |
| } |
| |
| drmModeFreePlaneResources(plane_res); |
| drmModeFreeResources(mode_res); |
| goto out; |
| |
| err_outputs_destroy: |
| drmmode_outputs_destroy(pScrn); |
| err_crtcs_destroy: |
| drmmode_crtcs_destroy(pScrn); |
| free(drmmode); |
| err_free_drm_plane_resources: |
| drmModeFreePlaneResources(plane_res); |
| err_free_drm_resources: |
| drmModeFreeResources(mode_res); |
| out: |
| TRACE_EXIT(); |
| return ret; |
| } |
| |
| void |
| drmmode_adjust_frame(ScrnInfoPtr pScrn, int x, int y) |
| { |
| xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn); |
| xf86OutputPtr output = config->output[config->compat_output]; |
| xf86CrtcPtr crtc = output->crtc; |
| int saved_x, saved_y; |
| Bool ret; |
| |
| if (!crtc || !crtc->enabled) |
| return; |
| |
| saved_x = crtc->x; |
| saved_y = crtc->y; |
| ret = drmmode_set_mode_major(crtc, &crtc->mode, crtc->rotation, x, y); |
| if (!ret) { |
| crtc->x = saved_x; |
| crtc->y = saved_y; |
| } |
| } |
| |
| /* |
| * Page Flipping |
| */ |
| |
| static void |
| page_flip_handler(int fd, unsigned int sequence, unsigned int tv_sec, |
| unsigned int tv_usec, void *user_data) |
| { |
| OMAPDRI2SwapComplete(user_data); |
| } |
| |
| static drmEventContext event_context = { |
| .version = DRM_EVENT_CONTEXT_VERSION, |
| .page_flip_handler = page_flip_handler, |
| }; |
| |
| int |
| drmmode_page_flip(DrawablePtr draw, uint32_t fb_id, void *priv, |
| int* num_flipped) |
| { |
| ScreenPtr pScreen = draw->pScreen; |
| ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen); |
| OMAPPtr pOMAP = OMAPPTR(pScrn); |
| xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn); |
| int ret, i; |
| unsigned int flags = 0; |
| |
| #if OMAP_USE_PAGE_FLIP_EVENTS |
| flags |= DRM_MODE_PAGE_FLIP_EVENT; |
| #endif |
| |
| /* Flip all crtc's that match this drawable's position and size */ |
| *num_flipped = 0; |
| for (i = 0; i < xf86_config->num_crtc; i++) { |
| xf86CrtcPtr crtc = xf86_config->crtc[i]; |
| uint32_t crtc_id = drmmode_crtc_id(crtc); |
| Bool connected = FALSE; |
| int j; |
| |
| if (!crtc->enabled) |
| continue; |
| /* crtc can be enabled but all the outputs disabled, which |
| will cause flip to fail with EBUSY, so don't even try. |
| eventually the mode on this CRTC will be disabled */ |
| for (j = 0; j < xf86_config->num_output; j++) { |
| xf86OutputPtr output = xf86_config->output[j]; |
| connected = connected || (output->crtc == crtc |
| && output->status |
| == XF86OutputStatusConnected); |
| } |
| if (!connected) |
| continue; |
| |
| if (crtc->x != draw->x || crtc->y != draw->y || |
| crtc->mode.HDisplay != draw->width || |
| crtc->mode.VDisplay != draw->height) |
| continue; |
| |
| DEBUG_MSG("[CRTC:%u] [FB:%u]", crtc_id, fb_id); |
| ret = drmModePageFlip(pOMAP->drmFD, crtc_id, fb_id, flags, |
| priv); |
| if (ret) { |
| ERROR_MSG("[CRTC:%u] [FB:%u] page flip failed: %s", |
| crtc_id, fb_id, strerror(errno)); |
| return ret; |
| } |
| (*num_flipped)++; |
| } |
| return 0; |
| } |
| |
| /* |
| * Hot Plug Event handling: |
| */ |
| |
| static void |
| drmmode_handle_uevents(int fd, void *closure) |
| { |
| ScrnInfoPtr pScrn = closure; |
| OMAPPtr pOMAP = OMAPPTR(pScrn); |
| drmmode_ptr drmmode = drmmode_from_scrn(pScrn); |
| struct udev_device *dev; |
| const char *hotplug; |
| struct stat s; |
| dev_t udev_devnum; |
| |
| dev = udev_monitor_receive_device(drmmode->uevent_monitor); |
| if (!dev) |
| return; |
| |
| // FIXME - Do we need to keep this code, which Rob originally wrote |
| // (i.e. up thru the "if" statement)?: |
| |
| /* |
| * Check to make sure this event is directed at our |
| * device (by comparing dev_t values), then make |
| * sure it's a hotplug event (HOTPLUG=1) |
| */ |
| udev_devnum = udev_device_get_devnum(dev); |
| if (fstat(pOMAP->drmFD, &s)) { |
| ERROR_MSG("fstat failed: %s", strerror(errno)); |
| udev_device_unref(dev); |
| return; |
| } |
| |
| hotplug = udev_device_get_property_value(dev, "HOTPLUG"); |
| |
| xf86DrvMsg(pScrn->scrnIndex, X_INFO, "hotplug=%s, match=%d\n", hotplug, |
| !memcmp(&s.st_rdev, &udev_devnum, sizeof (dev_t))); |
| |
| if (memcmp(&s.st_rdev, &udev_devnum, sizeof (dev_t)) == 0 && |
| hotplug && atoi(hotplug) == 1) { |
| RRGetInfo(xf86ScrnToScreen(pScrn), TRUE); |
| } |
| udev_device_unref(dev); |
| } |
| |
| static Bool |
| drmmode_uevent_init(ScrnInfoPtr pScrn) |
| { |
| drmmode_ptr drmmode = drmmode_from_scrn(pScrn); |
| struct udev *u; |
| struct udev_monitor *mon; |
| Bool ret; |
| |
| TRACE_ENTER(); |
| |
| u = udev_new(); |
| if (!u) { |
| ret = FALSE; |
| goto out; |
| } |
| mon = udev_monitor_new_from_netlink(u, "udev"); |
| if (!mon) { |
| ret = FALSE; |
| goto err_udev_unref; |
| } |
| |
| if (udev_monitor_filter_add_match_subsystem_devtype(mon, |
| "drm", |
| "drm_minor") < 0 || |
| udev_monitor_enable_receiving(mon) < 0) { |
| ret = FALSE; |
| goto err_udev_monitor_unref; |
| } |
| |
| drmmode->uevent_handler = |
| xf86AddGeneralHandler(udev_monitor_get_fd(mon), |
| drmmode_handle_uevents, pScrn); |
| if (!drmmode->uevent_handler) { |
| ret = FALSE; |
| goto err_udev_monitor_unref; |
| } |
| |
| drmmode->uevent_monitor = mon; |
| |
| ret = TRUE; |
| goto out; |
| |
| err_udev_monitor_unref: |
| udev_monitor_unref(mon); |
| err_udev_unref: |
| udev_unref(u); |
| out: |
| TRACE_EXIT(); |
| return ret; |
| } |
| |
| static void |
| drmmode_uevent_fini(ScrnInfoPtr pScrn) |
| { |
| drmmode_ptr drmmode; |
| struct udev *u; |
| |
| TRACE_ENTER(); |
| |
| drmmode = drmmode_from_scrn(pScrn); |
| u = udev_monitor_get_udev(drmmode->uevent_monitor); |
| xf86RemoveGeneralHandler(drmmode->uevent_handler); |
| drmmode->uevent_handler = NULL; |
| udev_monitor_unref(drmmode->uevent_monitor); |
| drmmode->uevent_monitor = NULL; |
| udev_unref(u); |
| |
| TRACE_EXIT(); |
| } |
| |
| static void |
| drmmode_wakeup_handler(pointer data, int err, pointer p) |
| { |
| ScrnInfoPtr pScrn = data; |
| drmmode_ptr drmmode = drmmode_from_scrn(pScrn); |
| fd_set *read_mask = p; |
| |
| if (pScrn == NULL || err < 0) |
| return; |
| |
| if (FD_ISSET(drmmode->fd, read_mask)) |
| drmHandleEvent(drmmode->fd, &event_context); |
| } |
| |
| void |
| drmmode_wait_for_event(ScrnInfoPtr pScrn) |
| { |
| drmmode_ptr drmmode = drmmode_from_scrn(pScrn); |
| drmHandleEvent(drmmode->fd, &event_context); |
| } |
| |
| Bool |
| drmmode_screen_init(ScrnInfoPtr pScrn) |
| { |
| drmmode_ptr drmmode = drmmode_from_scrn(pScrn); |
| ScreenPtr pScreen = xf86ScrnToScreen(pScrn); |
| Bool ret; |
| |
| /* Per ScreenInit cursor initialization */ |
| ret = xf86_cursors_init(pScreen, CURSORW, CURSORH, HARDWARE_CURSOR_ARGB); |
| if (!ret) { |
| ERROR_MSG("xf86_cursors_init() failed"); |
| goto out; |
| } |
| |
| ret = drmmode_uevent_init(pScrn); |
| if (!ret) |
| goto err_fini_cursors; |
| |
| AddGeneralSocket(drmmode->fd); |
| |
| /* Register a wakeup handler to get informed on DRM events */ |
| ret = RegisterBlockAndWakeupHandlers((BlockHandlerProcPtr)NoopDDA, |
| drmmode_wakeup_handler, pScrn); |
| if (!ret) { |
| ERROR_MSG("RegisterBlockAndWakeupHandlers() failed"); |
| goto err_drmmode_uevent_fini; |
| } |
| |
| ret = TRUE; |
| goto out; |
| |
| err_drmmode_uevent_fini: |
| RemoveGeneralSocket(drmmode->fd); |
| drmmode_uevent_fini(pScrn); |
| err_fini_cursors: |
| xf86_cursors_fini(pScreen); |
| out: |
| return ret; |
| } |
| |
| void |
| drmmode_close_screen(ScrnInfoPtr pScrn) |
| { |
| drmmode_ptr drmmode = drmmode_from_scrn(pScrn); |
| ScreenPtr pScreen = xf86ScrnToScreen(pScrn); |
| |
| RemoveBlockAndWakeupHandlers((BlockHandlerProcPtr)NoopDDA, |
| drmmode_wakeup_handler, pScrn); |
| RemoveGeneralSocket(drmmode->fd); |
| drmmode_uevent_fini(pScrn); |
| xf86_cursors_fini(pScreen); |
| } |
| |
| void drmmode_copy_fb(ScrnInfoPtr pScrn) |
| { |
| OMAPPtr pOMAP = OMAPPTR(pScrn); |
| int dst_cpp = (pScrn->bitsPerPixel + 7) / 8; |
| uint32_t dst_pitch = pScrn->displayWidth * dst_cpp; |
| int src_cpp; |
| uint32_t src_pitch; |
| unsigned int src_size; |
| unsigned char *dst, *src; |
| struct fb_var_screeninfo vinfo; |
| int fd; |
| int ret; |
| |
| if (!(dst = omap_bo_map(pOMAP->scanout))) { |
| xf86DrvMsg(pScrn->scrnIndex, X_ERROR, |
| "Couldn't map scanout bo\n"); |
| return; |
| } |
| |
| fd = open("/dev/fb0", O_RDONLY | O_SYNC); |
| if (fd == -1) { |
| xf86DrvMsg(pScrn->scrnIndex, X_ERROR, |
| "Couldn't open /dev/fb0: %s\n", |
| strerror(errno)); |
| return; |
| } |
| |
| if (ioctl(fd, FBIOGET_VSCREENINFO, &vinfo) < 0) { |
| xf86DrvMsg(pScrn->scrnIndex, X_ERROR, |
| "Vscreeninfo ioctl failed: %s\n", |
| strerror(errno)); |
| goto close_fd; |
| } |
| |
| if (vinfo.bits_per_pixel != 32) |
| { |
| xf86DrvMsg(pScrn->scrnIndex, X_ERROR, |
| "FB found but not 32 bpp\n"); |
| goto close_fd; |
| } |
| |
| src_cpp = (vinfo.bits_per_pixel + 7) / 8; |
| src_pitch = vinfo.xres_virtual * src_cpp; |
| src_size = vinfo.yres_virtual * src_pitch; |
| |
| src = mmap(NULL, src_size, PROT_READ, MAP_SHARED, fd, 0); |
| if (src == MAP_FAILED) { |
| xf86DrvMsg(pScrn->scrnIndex, X_ERROR, |
| "Couldn't mmap /dev/fb0: %s\n", |
| strerror(errno)); |
| goto close_fd; |
| } |
| |
| ret = omap_bo_cpu_prep(pOMAP->scanout, OMAP_GEM_WRITE); |
| if (ret) |
| goto munmap_src; |
| |
| drmmode_copy_from_to(src, 0, 0, vinfo.xres_virtual, vinfo.yres_virtual, |
| src_pitch, src_cpp, |
| dst, 0, 0, pScrn->virtualX, pScrn->virtualY, |
| dst_pitch, dst_cpp); |
| |
| omap_bo_cpu_fini(pOMAP->scanout, 0); |
| |
| munmap_src: |
| ret = munmap(src, src_size); |
| if (ret == -1) |
| xf86DrvMsg(pScrn->scrnIndex, X_ERROR, |
| "Couldn't munmap /dev/fb0: %s\n", |
| strerror(errno)); |
| |
| close_fd: |
| close(fd); |
| } |