static Bool
RADEONPrepareSolid(PixmapPtr pPix, int alu, Pixel pm, Pixel fg)
{
RINFO_FROM_SCREEN(pPix->drawable.pScreen);
uint32_t datatype, dst_pitch_offset;
struct radeon_exa_pixmap_priv *driver_priv;
int ret;
TRACE;
if (pPix->drawable.bitsPerPixel == 24)
RADEON_FALLBACK(("24bpp unsupported\n"));
if (!RADEONGetDatatypeBpp(pPix->drawable.bitsPerPixel, &datatype))
RADEON_FALLBACK(("RADEONGetDatatypeBpp failed\n"));
if (!RADEONGetPixmapOffsetPitch(pPix, &dst_pitch_offset))
RADEON_FALLBACK(("RADEONGetPixmapOffsetPitch failed\n"));
RADEON_SWITCH_TO_2D();
radeon_cs_space_reset_bos(info->cs);
driver_priv = exaGetPixmapDriverPrivate(pPix);
radeon_cs_space_add_persistent_bo(info->cs, driver_priv->bo, 0, RADEON_GEM_DOMAIN_VRAM);
ret = radeon_cs_space_check(info->cs);
if (ret)
RADEON_FALLBACK(("Not enough RAM to hw accel solid operation\n"));
driver_priv = exaGetPixmapDriverPrivate(pPix);
if (driver_priv) {
info->state_2d.dst_bo = driver_priv->bo;
info->state_2d.dst_domain = driver_priv->shared ? RADEON_GEM_DOMAIN_GTT : RADEON_GEM_DOMAIN_VRAM;
}
info->state_2d.default_sc_bottom_right = (RADEON_DEFAULT_SC_RIGHT_MAX |
RADEON_DEFAULT_SC_BOTTOM_MAX);
info->state_2d.dp_brush_bkgd_clr = 0x00000000;
info->state_2d.dp_src_frgd_clr = 0xffffffff;
info->state_2d.dp_src_bkgd_clr = 0x00000000;
info->state_2d.dp_gui_master_cntl = (RADEON_GMC_DST_PITCH_OFFSET_CNTL |
RADEON_GMC_BRUSH_SOLID_COLOR |
(datatype << 8) |
RADEON_GMC_SRC_DATATYPE_COLOR |
RADEON_ROP[alu].pattern |
RADEON_GMC_CLR_CMP_CNTL_DIS);
info->state_2d.dp_brush_frgd_clr = fg;
info->state_2d.dp_cntl = (RADEON_DST_X_LEFT_TO_RIGHT | RADEON_DST_Y_TOP_TO_BOTTOM);
info->state_2d.dp_write_mask = pm;
info->state_2d.dst_pitch_offset = dst_pitch_offset;
info->state_2d.src_pitch_offset = 0;
info->state_2d.src_bo = NULL;
info->accel_state->dst_pix = pPix;
Emit2DState(pScrn, RADEON_2D_EXA_SOLID);
return TRUE;
}
static void
ExaCopy(PixmapPtr pDstPixmap, int srcX, int srcY, int dstX, int dstY,
int width, int height)
{
ScrnInfoPtr pScrn = xf86ScreenToScrn(pDstPixmap->drawable.pScreen);
modesettingPtr ms = modesettingPTR(pScrn);
struct exa_context *exa = ms->exa;
struct pipe_box src_box;
exa_debug_printf("\tExaCopy(srcx=%d, srcy=%d, dstX=%d, dstY=%d, w=%d, h=%d)\n",
srcX, srcY, dstX, dstY, width, height);
debug_assert(exaGetPixmapDriverPrivate(pDstPixmap) == exa->copy.dst);
u_box_2d(srcX, srcY, width, height, &src_box);
/* If source and destination overlap, we have to copy to/from a scratch
* pixmap.
*/
if (exa->copy.dst == exa->copy.src &&
!((dstX + width) < srcX || dstX > (srcX + width) ||
(dstY + height) < srcY || dstY > (srcY + height))) {
struct exa_pixmap_priv *tmp_priv;
if (!exa->copy.tmp_pix) {
exa->copy.tmp_pix = pScrn->pScreen->CreatePixmap(pScrn->pScreen,
pDstPixmap->drawable.width,
pDstPixmap->drawable.height,
pDstPixmap->drawable.depth,
pDstPixmap->drawable.width);
exaMoveInPixmap(exa->copy.tmp_pix);
}
tmp_priv = exaGetPixmapDriverPrivate(exa->copy.tmp_pix);
exa->pipe->resource_copy_region( exa->pipe,
tmp_priv->tex,
0,
srcX, srcY, 0,
exa->copy.src->tex,
0, &src_box);
exa->pipe->resource_copy_region( exa->pipe,
exa->copy.dst->tex,
0,
dstX, dstY, 0,
tmp_priv->tex,
0, &src_box);
} else
exa->pipe->resource_copy_region( exa->pipe,
exa->copy.dst->tex,
0,
dstX, dstY, 0,
exa->copy.src->tex,
0, &src_box);
}
static Bool maliPrepareCopy(PixmapPtr pSrcPixmap, PixmapPtr pDstPixmap, int xdir, int ydir, int alu, Pixel planemask)
{
PrivPixmap *srcPrivPixmap = (PrivPixmap *)exaGetPixmapDriverPrivate(pSrcPixmap);
PrivPixmap *dstPrivPixmap = (PrivPixmap *)exaGetPixmapDriverPrivate(pDstPixmap);
IGNORE(pSrcPixmap);
IGNORE(pDstPixmap);
IGNORE(xdir);
IGNORE(ydir);
IGNORE(alu);
IGNORE(planemask);
if (srcPrivPixmap->isFrameBuffer &&
dstPrivPixmap->isFrameBuffer)
{
//if (srcPrivPixmap->frameBufferNumber != 0 ||
// srcPrivPixmap->frameBufferNumber != 0)
//{
// ERROR_STR("%s: pSrcPixmap=%p (buffer# %d) pDstPixmap=%p (buffer# %d) xdir=%d ydir=%d alu=%x\n",
// __FUNCTION__, pSrcPixmap, srcPrivPixmap->frameBufferNumber, pDstPixmap, dstPrivPixmap->frameBufferNumber, xdir, ydir, alu);
//}
SrcPixmap = pSrcPixmap;
if (ge2d_fd < 0)
{
init_ge2d();
}
return TRUE;
}
//if (srcPrivPixmap->mem_info &&
// dstPrivPixmap->mem_info)
//{
// //if (srcPrivPixmap->mem_info->handle != UMP_INVALID_SECURE_ID &&
// // dstPrivPixmap->mem_info->handle != UMP_INVALID_SECURE_ID)
// {
// SrcPixmap = pSrcPixmap;
// if (ge2d_fd < 0)
// {
// init_ge2d();
// }
// return TRUE;
// }
//}
return FALSE;
}
static void
ExaCopy(PixmapPtr pDstPixmap, int srcX, int srcY, int dstX, int dstY,
int width, int height)
{
ScrnInfoPtr pScrn = xf86Screens[pDstPixmap->drawable.pScreen->myNum];
modesettingPtr ms = modesettingPTR(pScrn);
struct exa_context *exa = ms->exa;
struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pDstPixmap);
exa_debug_printf("\tExaCopy(srcx=%d, srcy=%d, dstX=%d, dstY=%d, w=%d, h=%d)\n",
srcX, srcY, dstX, dstY, width, height);
debug_assert(priv == exa->copy.dst);
(void) priv;
if (exa->copy.use_surface_copy) {
struct pipe_box src_box;
u_box_2d(srcX, srcY, width, height, &src_box);
exa->pipe->resource_copy_region( exa->pipe,
exa->copy.dst->tex,
0,
dstX, dstY, 0,
exa->copy.src->tex,
0, &src_box);
}
else {
renderer_copy_pixmap(exa->renderer,
dstX, dstY,
srcX, srcY,
width, height,
exa->copy.src_texture->width0,
exa->copy.src_texture->height0);
}
}
static Bool
ExaDownloadFromScreen(PixmapPtr pPix, int x, int y, int w, int h, char *dst,
int dst_pitch)
{
ScreenPtr pScreen = pPix->drawable.pScreen;
ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
modesettingPtr ms = modesettingPTR(pScrn);
struct exa_context *exa = ms->exa;
struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPix);
struct pipe_transfer *transfer;
if (!priv || !priv->tex)
return FALSE;
transfer = pipe_get_transfer(exa->pipe, priv->tex, 0, 0,
PIPE_TRANSFER_READ, x, y, w, h);
if (!transfer)
return FALSE;
exa_debug_printf("------ ExaDownloadFromScreen(%d, %d, %d, %d, %d)\n",
x, y, w, h, dst_pitch);
util_copy_rect((unsigned char*)dst, priv->tex->format, dst_pitch, 0, 0,
w, h, exa->pipe->transfer_map(exa->pipe, transfer),
transfer->stride, 0, 0);
exa->pipe->transfer_unmap(exa->pipe, transfer);
exa->pipe->transfer_destroy(exa->pipe, transfer);
return TRUE;
}
static Bool
ExaUploadToScreen(PixmapPtr pPix, int x, int y, int w, int h, char *src,
int src_pitch)
{
ScreenPtr pScreen = pPix->drawable.pScreen;
ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
modesettingPtr ms = modesettingPTR(pScrn);
struct exa_context *exa = ms->exa;
struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPix);
struct pipe_transfer *transfer;
void *map;
if (!priv || !priv->tex)
return FALSE;
map = pipe_transfer_map(exa->pipe, priv->tex, 0, 0,
PIPE_TRANSFER_WRITE, x, y, w, h, &transfer);
if (!map)
return FALSE;
exa_debug_printf("++++++ ExaUploadToScreen(%d, %d, %d, %d, %d)\n",
x, y, w, h, src_pitch);
util_copy_rect(map,
priv->tex->format, transfer->stride, 0, 0, w, h,
(unsigned char*)src, src_pitch, 0, 0);
exa->pipe->transfer_unmap(exa->pipe, transfer);
return TRUE;
}
static void
ExaFinishAccess(PixmapPtr pPix, int index)
{
ScreenPtr pScreen = pPix->drawable.pScreen;
ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
modesettingPtr ms = modesettingPTR(pScrn);
struct exa_context *exa = ms->exa;
struct exa_pixmap_priv *priv;
priv = exaGetPixmapDriverPrivate(pPix);
if (!priv)
return;
if (!priv->map_transfer || pPix->devPrivate.ptr == NULL)
return;
exa_debug_printf("ExaFinishAccess %d\n", index);
if (--priv->map_count == 0) {
assert(priv->map_transfer);
exa->pipe->transfer_unmap(exa->pipe, priv->map_transfer);
priv->map_transfer = NULL;
pPix->devPrivate.ptr = NULL;
}
exa_debug_printf("ExaFinishAccess %d finished\n", index);
}
static Bool
ExaPrepareSolid(PixmapPtr pPixmap, int alu, Pixel planeMask, Pixel fg)
{
ScrnInfoPtr pScrn = xf86ScreenToScrn(pPixmap->drawable.pScreen);
modesettingPtr ms = modesettingPTR(pScrn);
struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap);
struct exa_context *exa = ms->exa;
exa_debug_printf("ExaPrepareSolid(0x%x)\n", fg);
if (!exa->accel)
return FALSE;
if (!exa->pipe)
XORG_FALLBACK("accel not enabled");
if (!priv || !priv->tex)
XORG_FALLBACK("%s", !priv ? "!priv" : "!priv->tex");
if (!EXA_PM_IS_SOLID(&pPixmap->drawable, planeMask))
XORG_FALLBACK("planeMask is not solid");
if (alu != GXcopy)
XORG_FALLBACK("not GXcopy");
if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format,
priv->tex->target, 0,
PIPE_BIND_RENDER_TARGET)) {
XORG_FALLBACK("format %s", util_format_name(priv->tex->format));
}
return xorg_solid_bind_state(exa, priv, fg);
}
static Bool
XAPixmapIsOffscreen(PixmapPtr pPixmap)
{
ScreenPtr pScreen = pPixmap->drawable.pScreen;
struct xa_surface *surf = msm_get_pixmap_surf(pPixmap);
if ((pScreen->GetScreenPixmap(pScreen) == pPixmap)) {
return TRUE;
}
if (!surf) {
/* because we are pretending to handle unaccel (1bpp, etc)
* pixmaps too..
* this is pretty lame, revisit using EXA_MIXED_PIXMAPS
*/
struct msm_pixmap_priv *priv =
exaGetPixmapDriverPrivate(pPixmap);
if (priv && priv->ptr) {
return TRUE;
}
}
if (surf)
return TRUE;
return FALSE;
}
static Bool
RADEONPrepareCopy(PixmapPtr pSrc, PixmapPtr pDst,
int xdir, int ydir,
int rop,
Pixel planemask)
{
RINFO_FROM_SCREEN(pDst->drawable.pScreen);
uint32_t datatype, src_pitch_offset, dst_pitch_offset;
struct radeon_exa_pixmap_priv *driver_priv;
int ret;
TRACE;
if (pDst->drawable.bitsPerPixel == 24)
RADEON_FALLBACK(("24bpp unsupported"));
if (!RADEONGetDatatypeBpp(pDst->drawable.bitsPerPixel, &datatype))
RADEON_FALLBACK(("RADEONGetDatatypeBpp failed\n"));
if (!RADEONGetPixmapOffsetPitch(pSrc, &src_pitch_offset))
RADEON_FALLBACK(("RADEONGetPixmapOffsetPitch source failed\n"));
if (!RADEONGetPixmapOffsetPitch(pDst, &dst_pitch_offset))
RADEON_FALLBACK(("RADEONGetPixmapOffsetPitch dest failed\n"));
RADEON_SWITCH_TO_2D();
radeon_cs_space_reset_bos(info->cs);
driver_priv = exaGetPixmapDriverPrivate(pSrc);
radeon_cs_space_add_persistent_bo(info->cs, driver_priv->bo, RADEON_GEM_DOMAIN_GTT | RADEON_GEM_DOMAIN_VRAM, 0);
info->state_2d.src_bo = driver_priv->bo;
driver_priv = exaGetPixmapDriverPrivate(pDst);
info->state_2d.dst_bo = driver_priv->bo;
info->state_2d.dst_domain = driver_priv->shared ? RADEON_GEM_DOMAIN_GTT : RADEON_GEM_DOMAIN_VRAM;
radeon_cs_space_add_persistent_bo(info->cs, driver_priv->bo, 0, info->state_2d.dst_domain);
ret = radeon_cs_space_check(info->cs);
if (ret)
RADEON_FALLBACK(("Not enough RAM to hw accel copy operation\n"));
info->accel_state->xdir = xdir;
info->accel_state->ydir = ydir;
info->accel_state->dst_pix = pDst;
RADEONDoPrepareCopy(pScrn, src_pitch_offset, dst_pitch_offset,
datatype, rop, planemask);
return TRUE;
}
static Bool
ExaPrepareCopy(PixmapPtr pSrcPixmap, PixmapPtr pDstPixmap, int xdir,
int ydir, int alu, Pixel planeMask)
{
ScrnInfoPtr pScrn = xf86ScreenToScrn(pDstPixmap->drawable.pScreen);
modesettingPtr ms = modesettingPTR(pScrn);
struct exa_context *exa = ms->exa;
struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pDstPixmap);
struct exa_pixmap_priv *src_priv = exaGetPixmapDriverPrivate(pSrcPixmap);
exa_debug_printf("ExaPrepareCopy\n");
if (!exa->accel)
return FALSE;
if (!exa->pipe)
XORG_FALLBACK("accel not enabled");
if (!priv || !priv->tex)
XORG_FALLBACK("pDst %s", !priv ? "!priv" : "!priv->tex");
if (!src_priv || !src_priv->tex)
XORG_FALLBACK("pSrc %s", !src_priv ? "!priv" : "!priv->tex");
if (!EXA_PM_IS_SOLID(&pSrcPixmap->drawable, planeMask))
XORG_FALLBACK("planeMask is not solid");
if (alu != GXcopy)
XORG_FALLBACK("alu not GXcopy");
if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format,
priv->tex->target, 0,
PIPE_BIND_RENDER_TARGET))
XORG_FALLBACK("pDst format %s", util_format_name(priv->tex->format));
if (!exa->scrn->is_format_supported(exa->scrn, src_priv->tex->format,
src_priv->tex->target, 0,
PIPE_BIND_SAMPLER_VIEW))
XORG_FALLBACK("pSrc format %s", util_format_name(src_priv->tex->format));
exa->copy.src = src_priv;
exa->copy.dst = priv;
return TRUE;
}
static Bool
ExaModifyPixmapHeader(PixmapPtr pPixmap, int width, int height,
int depth, int bitsPerPixel, int devKind,
pointer pPixData)
{
ScreenPtr pScreen = pPixmap->drawable.pScreen;
ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap);
modesettingPtr ms = modesettingPTR(pScrn);
struct exa_context *exa = ms->exa;
if (!priv || pPixData)
return FALSE;
if (0) {
debug_printf("%s pixmap %p sz %dx%dx%d devKind %d\n",
__FUNCTION__, pPixmap, width, height, bitsPerPixel, devKind);
if (priv->tex)
debug_printf(" ==> old texture %dx%d\n",
priv->tex->width0,
priv->tex->height0);
}
if (depth <= 0)
depth = pPixmap->drawable.depth;
if (bitsPerPixel <= 0)
bitsPerPixel = pPixmap->drawable.bitsPerPixel;
if (width <= 0)
width = pPixmap->drawable.width;
if (height <= 0)
height = pPixmap->drawable.height;
if (width <= 0 || height <= 0 || depth <= 0)
return FALSE;
miModifyPixmapHeader(pPixmap, width, height, depth,
bitsPerPixel, devKind, NULL);
priv->width = width;
priv->height = height;
/* Deal with screen resize */
if ((exa->accel || priv->flags) &&
(!priv->tex ||
!size_match(width, priv->tex->width0) ||
!size_match(height, priv->tex->height0) ||
priv->tex_flags != priv->flags)) {
struct pipe_resource *texture = NULL;
struct pipe_resource template;
memset(&template, 0, sizeof(template));
static void maliFinishAccess(PixmapPtr pPix, int index)
{
PrivPixmap *privPixmap = (PrivPixmap *)exaGetPixmapDriverPrivate(pPix);
mali_mem_info *mem_info;
ScreenPtr pScreen = pPix->drawable.pScreen;
ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
MaliPtr fPtr = MALIPTR(pScrn);
IGNORE(index);
if (!privPixmap)
{
return;
}
if (!pPix)
{
return;
}
mem_info = privPixmap->mem_info;
if (!privPixmap->isFrameBuffer)
{
int secure_id = 0;
_lock_item_s item;
secure_id = ump_secure_id_get(mem_info->handle);
if (secure_id)
{
item.secure_id = secure_id;
item.usage = _LOCK_ACCESS_CPU_WRITE;
if (fPtr->fd_umplock > 0)
{
ioctl(fPtr->fd_umplock, LOCK_IOCTL_RELEASE, &item);
}
}
if (privPixmap->refs == 1)
{
if (NULL != mem_info)
{
ump_mapped_pointer_release(mem_info->handle);
}
}
}
pPix->devPrivate.ptr = NULL;
privPixmap->refs--;
}
static void
ExaDoneSolid(PixmapPtr pPixmap)
{
ScrnInfoPtr pScrn = xf86Screens[pPixmap->drawable.pScreen->myNum];
modesettingPtr ms = modesettingPTR(pScrn);
struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap);
struct exa_context *exa = ms->exa;
if (!priv)
return;
xorg_composite_done(exa);
}
/* used by DRI2 code to play buffer switcharoo */
void
ARMSOCPixmapExchange(PixmapPtr a, PixmapPtr b)
{
struct ARMSOCPixmapPrivRec *apriv = exaGetPixmapDriverPrivate(a);
struct ARMSOCPixmapPrivRec *bpriv = exaGetPixmapDriverPrivate(b);
exchange(apriv->priv, bpriv->priv);
exchange(apriv->bo, bpriv->bo);
/* Ensure neither pixmap has a dmabuf fd attached to the bo if the
* ext_access_cnt refcount is 0, as it will never be cleared. */
if (armsoc_bo_has_dmabuf(apriv->bo) && !apriv->ext_access_cnt) {
armsoc_bo_clear_dmabuf(apriv->bo);
/* Should only have to clear one dmabuf fd, otherwise the
* refcount is wrong */
assert(!armsoc_bo_has_dmabuf(bpriv->bo));
} else if (armsoc_bo_has_dmabuf(bpriv->bo) && !bpriv->ext_access_cnt) {
armsoc_bo_clear_dmabuf(bpriv->bo);
assert(!armsoc_bo_has_dmabuf(apriv->bo));
}
}
static Bool
ExaPrepareAccess(PixmapPtr pPix, int index)
{
ScreenPtr pScreen = pPix->drawable.pScreen;
ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
modesettingPtr ms = modesettingPTR(pScrn);
struct exa_context *exa = ms->exa;
struct exa_pixmap_priv *priv;
priv = exaGetPixmapDriverPrivate(pPix);
if (!priv)
return FALSE;
if (!priv->tex)
return FALSE;
exa_debug_printf("ExaPrepareAccess %d\n", index);
if (priv->map_count == 0)
{
assert(pPix->drawable.width <= priv->tex->width0);
assert(pPix->drawable.height <= priv->tex->height0);
priv->map_transfer =
pipe_get_transfer(exa->pipe, priv->tex, 0, 0,
#ifdef EXA_MIXED_PIXMAPS
PIPE_TRANSFER_MAP_DIRECTLY |
#endif
PIPE_TRANSFER_READ_WRITE,
0, 0,
pPix->drawable.width,
pPix->drawable.height );
if (!priv->map_transfer)
#ifdef EXA_MIXED_PIXMAPS
return FALSE;
#else
FatalError("failed to create transfer\n");
#endif
pPix->devPrivate.ptr =
exa->pipe->transfer_map(exa->pipe, priv->map_transfer);
pPix->devKind = priv->map_transfer->stride;
}
priv->map_count++;
exa_debug_printf("ExaPrepareAccess %d prepared\n", index);
return TRUE;
}
static void
ExaDoneSolid(PixmapPtr pPixmap)
{
ScrnInfoPtr pScrn = xf86ScreenToScrn(pPixmap->drawable.pScreen);
modesettingPtr ms = modesettingPTR(pScrn);
struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap);
struct exa_context *exa = ms->exa;
if (!priv)
return;
exa_debug_printf("ExaDoneSolid\n");
xorg_composite_done(exa);
exa_debug_printf("ExaDoneSolid done\n");
}
int
xorg_exa_set_shared_usage(PixmapPtr pPixmap)
{
struct exa_pixmap_priv *priv;
priv = exaGetPixmapDriverPrivate(pPixmap);
if (!priv) {
FatalError("NO PIXMAP PRIVATE\n");
return 0;
}
priv->flags |= PIPE_BIND_SHARED;
return 0;
}
int
xorg_exa_set_shared_usage(PixmapPtr pPixmap)
{
struct exa_pixmap_priv *priv;
priv = exaGetPixmapDriverPrivate(pPixmap);
if (!priv) {
FatalError("NO PIXMAP PRIVATE\n");
return 0;
}
priv->flags |= PIPE_TEXTURE_USAGE_DISPLAY_TARGET;
return 0;
}
static Bool
ExaPixmapIsOffscreen(PixmapPtr pPixmap)
{
struct exa_pixmap_priv *priv;
priv = exaGetPixmapDriverPrivate(pPixmap);
if (!priv)
return FALSE;
if (priv->tex)
return TRUE;
return FALSE;
}
static void
ExaComposite(PixmapPtr pDst, int srcX, int srcY, int maskX, int maskY,
int dstX, int dstY, int width, int height)
{
ScrnInfoPtr pScrn = xf86ScreenToScrn(pDst->drawable.pScreen);
modesettingPtr ms = modesettingPTR(pScrn);
struct exa_context *exa = ms->exa;
struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pDst);
exa_debug_printf("\tExaComposite(src[%d,%d], mask=[%d, %d], dst=[%d, %d], dim=[%d, %d])\n",
srcX, srcY, maskX, maskY, dstX, dstY, width, height);
exa_debug_printf("\t Num bound samplers = %d\n",
exa->num_bound_samplers);
xorg_composite(exa, priv, srcX, srcY, maskX, maskY,
dstX, dstY, width, height);
}
static Bool maliPixmapIsOffscreen(PixmapPtr pPix)
{
ScreenPtr pScreen = pPix->drawable.pScreen;
PrivPixmap *privPixmap = (PrivPixmap *)exaGetPixmapDriverPrivate(pPix);
if (pScreen->GetScreenPixmap(pScreen) == pPix)
{
return TRUE;
}
if (privPixmap)
{
return pPix->devPrivate.ptr ? FALSE : TRUE;
}
return FALSE;
}
static void
ExaDoneCopy(PixmapPtr pPixmap)
{
ScrnInfoPtr pScrn = xf86Screens[pPixmap->drawable.pScreen->myNum];
modesettingPtr ms = modesettingPTR(pScrn);
struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap);
struct exa_context *exa = ms->exa;
if (!priv)
return;
renderer_draw_flush(exa->renderer);
exa->copy.src = NULL;
exa->copy.dst = NULL;
pipe_surface_reference(&exa->copy.src_surface, NULL);
pipe_surface_reference(&exa->copy.dst_surface, NULL);
pipe_texture_reference(&exa->copy.src_texture, NULL);
}
static void
ExaSolid(PixmapPtr pPixmap, int x0, int y0, int x1, int y1)
{
ScrnInfoPtr pScrn = xf86Screens[pPixmap->drawable.pScreen->myNum];
modesettingPtr ms = modesettingPTR(pScrn);
struct exa_context *exa = ms->exa;
struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap);
#if DEBUG_PRINT
debug_printf("\tExaSolid(%d, %d, %d, %d)\n", x0, y0, x1, y1);
#endif
if (x0 == 0 && y0 == 0 &&
x1 == pPixmap->drawable.width && y1 == pPixmap->drawable.height) {
exa->pipe->clear(exa->pipe, PIPE_CLEAR_COLOR, exa->solid_color, 0.0, 0);
return;
}
xorg_solid(exa, priv, x0, y0, x1, y1) ;
}
Bool sgx_exa_update_pixmap(PixmapPtr pPixmap,
int width, int height,
int depth, int bitsPerPixel,
int pitch, PVR2DMEMINFO *mem_info)
{
ScreenPtr pScreen = pPixmap->drawable.pScreen;
struct PVR2DPixmap *priv = exaGetPixmapDriverPrivate(pPixmap);
Bool ret;
ret = (*pScreen->ModifyPixmapHeader)(pPixmap,
width, height,
depth, bitsPerPixel,
pitch, NULL);
if (ret) {
priv->pvr2dmem = mem_info;
priv->shmaddr = mem_info->pBase;
}
return ret;
}
static void
ExaDoneCopy(PixmapPtr pPixmap)
{
ScrnInfoPtr pScrn = xf86ScreenToScrn(pPixmap->drawable.pScreen);
modesettingPtr ms = modesettingPTR(pScrn);
struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap);
struct exa_context *exa = ms->exa;
if (!priv)
return;
exa_debug_printf("ExaDoneCopy\n");
if (exa->copy.tmp_pix) {
pScrn->pScreen->DestroyPixmap(exa->copy.tmp_pix);
exa->copy.tmp_pix = NULL;
}
exa->copy.src = NULL;
exa->copy.dst = NULL;
exa_debug_printf("ExaDoneCopy done\n");
}
static Bool
ExaUploadToScreen(PixmapPtr pPix, int x, int y, int w, int h, char *src,
int src_pitch)
{
ScreenPtr pScreen = pPix->drawable.pScreen;
ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
modesettingPtr ms = modesettingPTR(pScrn);
struct exa_context *exa = ms->exa;
struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPix);
struct pipe_transfer *transfer;
if (!priv || !priv->tex)
return FALSE;
/* make sure that any pending operations are flushed to hardware */
if (exa->pipe->is_texture_referenced(exa->pipe, priv->tex, 0, 0) &
(PIPE_REFERENCED_FOR_READ | PIPE_REFERENCED_FOR_WRITE))
xorg_exa_flush(exa, 0, NULL);
transfer = exa->scrn->get_tex_transfer(exa->scrn, priv->tex, 0, 0, 0,
PIPE_TRANSFER_WRITE, x, y, w, h);
if (!transfer)
return FALSE;
#if DEBUG_PRINT
debug_printf("++++++ ExaUploadToScreen(%d, %d, %d, %d, %d)\n",
x, y, w, h, src_pitch);
#endif
util_copy_rect(exa->scrn->transfer_map(exa->scrn, transfer),
priv->tex->format, transfer->stride, 0, 0, w, h,
(unsigned char*)src, src_pitch, 0, 0);
exa->scrn->transfer_unmap(exa->scrn, transfer);
exa->scrn->tex_transfer_destroy(transfer);
return TRUE;
}
Bool getDrawableInfo(DrawablePtr pDraw, PVR2DMEMINFO ** ppMemInfo, long *pXoff,
long *pYoff)
{
PixmapPtr pPixmap =
pDraw->type ==
DRAWABLE_WINDOW ? pDraw->pScreen->
GetWindowPixmap((WindowPtr) pDraw) : (PixmapPtr) pDraw;
struct PVR2DPixmap *ppix = exaGetPixmapDriverPrivate(pPixmap);
if (!ppix || !PVR2DValidate(pPixmap, ppix, TRUE))
return FALSE;
*ppMemInfo = ppix->pvr2dmem;
#ifdef COMPOSITE
*pXoff = -pPixmap->screen_x + pPixmap->drawable.x;
*pYoff = -pPixmap->screen_y + pPixmap->drawable.y;
#else
*pXoff = 0;
*pYoff = 0;
#endif
return TRUE;
}
static void
ExaSolid(PixmapPtr pPixmap, int x0, int y0, int x1, int y1)
{
ScrnInfoPtr pScrn = xf86ScreenToScrn(pPixmap->drawable.pScreen);
modesettingPtr ms = modesettingPTR(pScrn);
struct exa_context *exa = ms->exa;
struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap);
exa_debug_printf("\tExaSolid(%d, %d, %d, %d)\n", x0, y0, x1, y1);
if (x0 == 0 && y0 == 0 &&
x1 == pPixmap->drawable.width && y1 == pPixmap->drawable.height) {
union pipe_color_union solid_color;
solid_color.f[0] = exa->solid_color[0];
solid_color.f[1] = exa->solid_color[1];
solid_color.f[2] = exa->solid_color[2];
solid_color.f[3] = exa->solid_color[3];
exa->pipe->clear(exa->pipe, PIPE_CLEAR_COLOR, &solid_color, 0.0, 0);
return;
}
xorg_solid(exa, priv, x0, y0, x1, y1) ;
}
static void
ExaCopy(PixmapPtr pDstPixmap, int srcX, int srcY, int dstX, int dstY,
int width, int height)
{
ScrnInfoPtr pScrn = xf86Screens[pDstPixmap->drawable.pScreen->myNum];
modesettingPtr ms = modesettingPTR(pScrn);
struct exa_context *exa = ms->exa;
struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pDstPixmap);
#if DEBUG_PRINT
debug_printf("\tExaCopy(srcx=%d, srcy=%d, dstX=%d, dstY=%d, w=%d, h=%d)\n",
srcX, srcY, dstX, dstY, width, height);
#endif
debug_assert(priv == exa->copy.dst);
(void) priv;
if (exa->copy.use_surface_copy) {
/* XXX: consider exposing >1 box in surface_copy interface.
*/
exa->pipe->surface_copy( exa->pipe,
exa->copy.dst_surface,
dstX, dstY,
exa->copy.src_surface,
srcX, srcY,
width, height );
}
else {
renderer_copy_pixmap(exa->renderer,
dstX, dstY,
srcX, srcY,
width, height,
exa->copy.src_texture->width0,
exa->copy.src_texture->height0);
}
}
