OMAPEXAPtr
InitNullEXA(ScreenPtr pScreen, ScrnInfoPtr pScrn, int fd)
{
	OMAPNullEXAPtr null_exa = calloc(sizeof (*null_exa), 1);
	OMAPEXAPtr omap_exa = (OMAPEXAPtr)null_exa;
	ExaDriverPtr exa;

	INFO_MSG("Soft EXA mode");

	exa = exaDriverAlloc();
	if (!exa) {
		goto fail;
	}

	null_exa->exa = exa;

	exa->exa_major = EXA_VERSION_MAJOR;
	exa->exa_minor = EXA_VERSION_MINOR;

	exa->pixmapOffsetAlign = 0;
	exa->pixmapPitchAlign = 32 * 4; // see OMAPCalculateStride()
	exa->flags = EXA_OFFSCREEN_PIXMAPS |
			EXA_HANDLES_PIXMAPS | EXA_SUPPORTS_PREPARE_AUX;
	exa->maxX = 4096;
	exa->maxY = 4096;

	/* Required EXA functions: */
	exa->WaitMarker = OMAPWaitMarker;
	exa->CreatePixmap2 = OMAPCreatePixmap;
	exa->DestroyPixmap = OMAPDestroyPixmap;
	exa->ModifyPixmapHeader = OMAPModifyPixmapHeader;

	exa->PrepareAccess = OMAPPrepareAccess;
	exa->FinishAccess = OMAPFinishAccess;
	exa->PixmapIsOffscreen = OMAPPixmapIsOffscreen;

	// Always fallback for software operations
	exa->PrepareCopy = PrepareCopyFail;
	exa->PrepareSolid = PrepareSolidFail;
	exa->CheckComposite = CheckCompositeFail;
	exa->PrepareComposite = PrepareCompositeFail;

	if (! exaDriverInit(pScreen, exa)) {
		ERROR_MSG("exaDriverInit failed");
		goto fail;
	}

	omap_exa->CloseScreen = CloseScreen;
	omap_exa->FreeScreen = FreeScreen;

	return omap_exa;

fail:
	if (null_exa) {
		free(null_exa);
	}
	return NULL;
}
Bool G80ExaInit(ScreenPtr pScreen, ScrnInfoPtr pScrn)
{
    G80Ptr pNv = G80PTR(pScrn);
    ExaDriverPtr exa;
    const int pitch = pScrn->displayWidth * (pScrn->bitsPerPixel / 8);

    exa = pNv->exa = exaDriverAlloc();
    if(!exa) return FALSE;

    exa->exa_major         = EXA_VERSION_MAJOR;
    exa->exa_minor         = EXA_VERSION_MINOR;
    exa->memoryBase        = pNv->mem;
    exa->offScreenBase     = 0;
    exa->memorySize        = pitch * pNv->offscreenHeight;
    exa->pixmapOffsetAlign = 256;
    exa->pixmapPitchAlign  = 256;
    exa->flags             = EXA_OFFSCREEN_PIXMAPS;
    exa->maxX              = 8192;
    exa->maxY              = 8192;

    /**** Rendering ops ****/
    exa->PrepareSolid     = prepareSolid;
    exa->Solid            = solid;
    exa->DoneSolid        = doneSolid;
    exa->PrepareCopy      = prepareCopy;
    exa->Copy             = copy;
    exa->DoneCopy         = doneCopy;
    exa->CheckComposite   = checkComposite;
    //exa->PrepareComposite = prepareComposite;
    //exa->Composite        = composite;
    //exa->DoneComposite    = doneComposite;
    exa->UploadToScreen   = upload;

    exa->WaitMarker       = waitMarker;

    return exaDriverInit(pScreen, exa);
}
Esempio n. 3
0
Bool
nouveau_exa_init(ScreenPtr pScreen) 
{
	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
	NVPtr pNv = NVPTR(pScrn);
	ExaDriverPtr exa;

	exa = exaDriverAlloc();
	if (!exa) {
		pNv->NoAccel = TRUE;
		return FALSE;
	}

	exa->exa_major = EXA_VERSION_MAJOR;
	exa->exa_minor = EXA_VERSION_MINOR;
	exa->flags = EXA_OFFSCREEN_PIXMAPS;

#ifdef EXA_SUPPORTS_PREPARE_AUX
	exa->flags |= EXA_SUPPORTS_PREPARE_AUX;
#endif

	exa->PixmapIsOffscreen = nouveau_exa_pixmap_is_offscreen;
	exa->PrepareAccess = nouveau_exa_prepare_access;
	exa->FinishAccess = nouveau_exa_finish_access;

	exa->flags |= (EXA_HANDLES_PIXMAPS | EXA_MIXED_PIXMAPS);
	exa->pixmapOffsetAlign = 256;
	exa->pixmapPitchAlign = 64;

	exa->CreatePixmap2 = nouveau_exa_create_pixmap;
	exa->DestroyPixmap = nouveau_exa_destroy_pixmap;

	if (pNv->Architecture >= NV_ARCH_50) {
		exa->maxX = 8192;
		exa->maxY = 8192;
	} else
	if (pNv->Architecture >= NV_ARCH_10) {
		exa->maxX = 4096;
		exa->maxY = 4096;
	} else {
		exa->maxX = 2048;
		exa->maxY = 2048;
	}

	exa->MarkSync = nouveau_exa_mark_sync;
	exa->WaitMarker = nouveau_exa_wait_marker;

	exa->DownloadFromScreen = nouveau_exa_download_from_screen;
	exa->UploadToScreen = nouveau_exa_upload_to_screen;

	if (pNv->Architecture < NV_ARCH_50) {
		exa->PrepareCopy = NV04EXAPrepareCopy;
		exa->Copy = NV04EXACopy;
		exa->DoneCopy = NV04EXADoneCopy;

		exa->PrepareSolid = NV04EXAPrepareSolid;
		exa->Solid = NV04EXASolid;
		exa->DoneSolid = NV04EXADoneSolid;
	} else
	if (pNv->Architecture < NV_ARCH_C0) {
		exa->PrepareCopy = NV50EXAPrepareCopy;
		exa->Copy = NV50EXACopy;
		exa->DoneCopy = NV50EXADoneCopy;

		exa->PrepareSolid = NV50EXAPrepareSolid;
		exa->Solid = NV50EXASolid;
		exa->DoneSolid = NV50EXADoneSolid;
	} else {
		exa->PrepareCopy = NVC0EXAPrepareCopy;
		exa->Copy        = NVC0EXACopy;
		exa->DoneCopy    = NVC0EXADoneCopy;

		exa->PrepareSolid = NVC0EXAPrepareSolid;
		exa->Solid        = NVC0EXASolid;
		exa->DoneSolid    = NVC0EXADoneSolid;
	}

	switch (pNv->Architecture) {	
	case NV_ARCH_10:
	case NV_ARCH_20:
 		exa->CheckComposite   = NV10EXACheckComposite;
 		exa->PrepareComposite = NV10EXAPrepareComposite;
 		exa->Composite        = NV10EXAComposite;
 		exa->DoneComposite    = NV10EXADoneComposite;
		break;
	case NV_ARCH_30:
		exa->CheckComposite   = NV30EXACheckComposite;
		exa->PrepareComposite = NV30EXAPrepareComposite;
		exa->Composite        = NV30EXAComposite;
		exa->DoneComposite    = NV30EXADoneComposite;
		break;
	case NV_ARCH_40:
		exa->CheckComposite   = NV40EXACheckComposite;
		exa->PrepareComposite = NV40EXAPrepareComposite;
		exa->Composite        = NV40EXAComposite;
		exa->DoneComposite    = NV40EXADoneComposite;
		break;
	case NV_ARCH_50:
		exa->CheckComposite   = NV50EXACheckComposite;
		exa->PrepareComposite = NV50EXAPrepareComposite;
		exa->Composite        = NV50EXAComposite;
		exa->DoneComposite    = NV50EXADoneComposite;
		break;
	case NV_ARCH_C0:
		exa->CheckComposite   = NVC0EXACheckComposite;
		exa->PrepareComposite = NVC0EXAPrepareComposite;
		exa->Composite        = NVC0EXAComposite;
		exa->DoneComposite    = NVC0EXADoneComposite;
		break;
	default:
		break;
	}

	if (!exaDriverInit(pScreen, exa))
		return FALSE;

	pNv->EXADriverPtr = exa;
	return TRUE;
}
Esempio n. 4
0
/**
 * This function initializes EXA to use the fake acceleration implementation
 * which just falls through to software.  The purpose is to have a reliable,
 * correct driver with which to test changes to the EXA core.
 */
Bool
ephyrDrawInit(ScreenPtr pScreen)
{
    KdScreenPriv(pScreen);
    KdScreenInfo *screen = pScreenPriv->screen;
    EphyrScrPriv *scrpriv = screen->driver;
    EphyrFakexaPriv *fakexa;
    Bool success;

    fakexa = xcalloc(1, sizeof(*fakexa));
    if (fakexa == NULL)
	return FALSE;

    fakexa->exa = exaDriverAlloc();
    if (fakexa->exa == NULL) {
	xfree(fakexa);
	return FALSE;
    }

    fakexa->exa->memoryBase = screen->memory_base;
    fakexa->exa->memorySize = screen->memory_size;
    fakexa->exa->offScreenBase = screen->off_screen_base;

    /* Since we statically link against EXA, we shouldn't have to be smart about
     * versioning.
     */
    fakexa->exa->exa_major = 2;
    fakexa->exa->exa_minor = 0;

    fakexa->exa->PrepareSolid = ephyrPrepareSolid;
    fakexa->exa->Solid = ephyrSolid;
    fakexa->exa->DoneSolid = ephyrDoneSolid;

    fakexa->exa->PrepareCopy = ephyrPrepareCopy;
    fakexa->exa->Copy = ephyrCopy;
    fakexa->exa->DoneCopy = ephyrDoneCopy;

    fakexa->exa->CheckComposite = ephyrCheckComposite;
    fakexa->exa->PrepareComposite = ephyrPrepareComposite;
    fakexa->exa->Composite = ephyrComposite;
    fakexa->exa->DoneComposite = ephyrDoneComposite;

    fakexa->exa->DownloadFromScreen = ephyrDownloadFromScreen;
    fakexa->exa->UploadToScreen = ephyrUploadToScreen;

    fakexa->exa->MarkSync = ephyrMarkSync;
    fakexa->exa->WaitMarker = ephyrWaitMarker;

    fakexa->exa->PrepareAccess = ephyrPrepareAccess;

    fakexa->exa->pixmapOffsetAlign = EPHYR_OFFSET_ALIGN;
    fakexa->exa->pixmapPitchAlign = EPHYR_PITCH_ALIGN;

    fakexa->exa->maxX = 1023;
    fakexa->exa->maxY = 1023;

    fakexa->exa->flags = EXA_OFFSCREEN_PIXMAPS;

    success = exaDriverInit(pScreen, fakexa->exa);
    if (success) {
	ErrorF("Initialized fake EXA acceleration\n");
	scrpriv->fakexa = fakexa;
    } else {
	ErrorF("Failed to initialize EXA\n");
	xfree(fakexa->exa);
	xfree(fakexa);
    }

    return success;
}
struct ARMSOCEXARec *
InitNullEXA(ScreenPtr pScreen, ScrnInfoPtr pScrn, int fd)
{
	struct ARMSOCNullEXARec *null_exa = calloc(sizeof(*null_exa), 1);
	struct ARMSOCEXARec *armsoc_exa;
	ExaDriverPtr exa;

	INFO_MSG("Soft EXA mode");

	if (!null_exa)
		return NULL;

	armsoc_exa = (struct ARMSOCEXARec *)null_exa;

	exa = exaDriverAlloc();
	if (!exa)
		goto fail;

	null_exa->exa = exa;

	exa->exa_major = EXA_VERSION_MAJOR;
	exa->exa_minor = EXA_VERSION_MINOR;

	exa->pixmapOffsetAlign = 0;
	exa->pixmapPitchAlign = 32;
	exa->flags = EXA_OFFSCREEN_PIXMAPS |
			EXA_HANDLES_PIXMAPS | EXA_SUPPORTS_PREPARE_AUX;
	exa->maxX = 4096;
	exa->maxY = 4096;

	/* Required EXA functions: */
	exa->WaitMarker = ARMSOCWaitMarker;
	exa->CreatePixmap2 = ARMSOCCreatePixmap2;
	exa->DestroyPixmap = ARMSOCDestroyPixmap;
	exa->ModifyPixmapHeader = ARMSOCModifyPixmapHeader;

	exa->PrepareAccess = ARMSOCPrepareAccess;
	exa->FinishAccess = ARMSOCFinishAccess;
	exa->PixmapIsOffscreen = ARMSOCPixmapIsOffscreen;

	/* Always fallback for software operations */
	exa->PrepareCopy = PrepareCopyFail;
	exa->PrepareSolid = PrepareSolidFail;
	exa->CheckComposite = CheckCompositeFail;
	exa->PrepareComposite = PrepareCompositeFail;

	/* This needs to happen before EXA is initialized */
	InstallAlphaHack(pScreen);

	if (!exaDriverInit(pScreen, exa)) {
		ERROR_MSG("exaDriverInit failed");
		goto fail;
	}

	armsoc_exa->CloseScreen = CloseScreen;
	armsoc_exa->FreeScreen = FreeScreen;

	return armsoc_exa;

fail:
	if (exa)
		free(exa);

	if (null_exa)
		free(null_exa);

	return NULL;
}
Esempio n. 6
0
Bool
GLAMODrawExaInit(ScreenPtr pScreen, ScrnInfoPtr pScrn)
{
	GlamoPtr pGlamo = GlamoPTR(pScrn);

	Bool success = FALSE;
	ExaDriverPtr exa;

	xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
			"EXA hardware acceleration initialising\n");

	exa = pGlamo->exa = exaDriverAlloc();
    if(!exa) return FALSE;

	exa->memoryBase = pGlamo->fbstart;
	exa->memorySize = 1024 * 1024 * 4;
	/*exa->offScreenBase = pGlamo->fboff;*/
	exa->offScreenBase = pScrn->virtualX * pScrn->virtualY * 2;

	exa->exa_major = 2;
	exa->exa_minor = 0;

	exa->PrepareSolid = GLAMOExaPrepareSolid;
	exa->Solid = GLAMOExaSolid;
	exa->DoneSolid = GLAMOExaDoneSolid;

	exa->PrepareCopy = GLAMOExaPrepareCopy;
	exa->Copy = GLAMOExaCopy;
	exa->DoneCopy = GLAMOExaDoneCopy;

	exa->CheckComposite = GLAMOExaCheckComposite;
	exa->PrepareComposite = GLAMOExaPrepareComposite;
	exa->Composite = GLAMOExaComposite;
	exa->DoneComposite = GLAMOExaDoneComposite;


	exa->DownloadFromScreen = GLAMOExaDownloadFromScreen;
	exa->UploadToScreen = GLAMOExaUploadToScreen;

	/*glamos->exa.MarkSync = GLAMOExaMarkSync;*/
	exa->WaitMarker = GLAMOExaWaitMarker;

	exa->pixmapOffsetAlign = 2;
	exa->pixmapPitchAlign = 2;

	exa->maxX = 640;
	exa->maxY = 640;

	exa->flags = EXA_OFFSCREEN_PIXMAPS;

	RegisterBlockAndWakeupHandlers(GLAMOBlockHandler,
				       GLAMOWakeupHandler,
				       pScreen);

	success = exaDriverInit(pScreen, exa);
	if (success) {
		ErrorF("Initialized EXA acceleration\n");
	} else {
		ErrorF("Failed to initialize EXA acceleration\n");
	}

	return success;
}