static CARD32 perfCountersCallback(OsTimerPtr timer, CARD32 time, pointer arg)
{
	ScrnInfoPtr pScrn = arg;
	FBDevPtr fbdev = FBDEVPTR(pScrn);
	int i, t;

	xf86DrvMsg(pScrn->scrnIndex, X_INFO,
	           "Memory allocation statistics:\n"
	           "malloc:     %.4f megabytes/%4ld segments\n"
	           "shm:        %.4f megabytes/%4ld segments\n"
	           "total:      %.4f megabytes/%4ld segments (%.4f avg)\n",
	           (float) perf_counters.malloc_bytes / (1024 * 1024),
	           perf_counters.malloc_segments,
	           (float) perf_counters.shm_bytes / (1024 * 1024),
	           perf_counters.shm_segments,
	           (float) (perf_counters.malloc_bytes +
	                    perf_counters.shm_bytes) / (1024 * 1024),
	           perf_counters.malloc_segments + perf_counters.shm_segments,
	           (float) ((perf_counters.malloc_bytes +
	                    perf_counters.shm_bytes) /
	                    (perf_counters.malloc_segments +
	                    perf_counters.shm_segments)) / (1024 * 1024));

	xf86DrvMsg(pScrn->scrnIndex, X_INFO,
		   "Solid:        %8ld HW        %8ld SW        %8ld ALL\n",
		   perf_counters.hw_solid, perf_counters.sw_solid,
		   perf_counters.hw_solid + perf_counters.sw_solid);
	for (i = GXclear; i <= GXset; i++)
		if (perf_counters.solid_alu[i])
			xf86DrvMsg(pScrn->scrnIndex, X_INFO,
				   "        %s: %8ld\n", alu[i],
				   perf_counters.solid_alu[i]);

	xf86DrvMsg(pScrn->scrnIndex, X_INFO,
		   "Copy:         %8ld HW        %8ld SW        %8ld ALL\n",
		   perf_counters.hw_copy, perf_counters.sw_copy,
		   perf_counters.hw_copy + perf_counters.sw_copy);
	for (i = GXclear; i <= GXset; i++)
		if (perf_counters.copy_alu[i])
			xf86DrvMsg(pScrn->scrnIndex, X_INFO,
				   "        %s: %8ld\n", alu[i],
				   perf_counters.copy_alu[i]);

	xf86DrvMsg(pScrn->scrnIndex, X_INFO,
		   "Cache:        %8ld FLUSH     %8ld INVAL\n",
		   perf_counters.cache_flush, perf_counters.cache_inval);

	xf86DrvMsg(pScrn->scrnIndex, X_INFO,
		   "Fallback: %8ld GXcopy %8ld bitsPerPixel %8ld isSolid\n",
		   perf_counters.fallback_GXcopy,
		   perf_counters.fallback_bitsPerPixel,
		   perf_counters.fallback_isSolid);

	xf86DrvMsg(pScrn->scrnIndex, X_INFO,
		   "Fallback: Solid: %8ld validateDst %8ld getFormatDst\n",
		   perf_counters.fallback_solid_validateDst,
		   perf_counters.fallback_solid_getFormatDst);

	xf86DrvMsg(pScrn->scrnIndex, X_INFO,
		   "Fallback: Copy: %8ld validateSrc %8ld validateDst %8ld getFormatSrc %8ld getFormatDst\n\n",
		   perf_counters.fallback_copy_validateSrc,
		   perf_counters.fallback_copy_validateDst,
		   perf_counters.fallback_copy_getFormatSrc,
		   perf_counters.fallback_copy_getFormatDst);

	if (xf86IsOptionSet(fbdev->Options, OPTION_PERF_RESET))
		memset(&perf_counters, 0, sizeof(struct sgx_perf_counters));

	xf86GetOptValInteger(fbdev->Options, OPTION_PERF_TIME, &t);
	return t;
}
示例#2
0
/* Data from here is valid to all server generations */
static Bool NestedPreInit(ScrnInfoPtr pScrn, int flags) {
    NestedPrivatePtr pNested;
    char *originString = NULL;

    xf86DrvMsg(pScrn->scrnIndex, X_INFO, "NestedPreInit\n");

    if (flags & PROBE_DETECT)
        return FALSE;

    if (!NestedAllocatePrivate(pScrn)) {
        xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Failed to allocate private\n");
        return FALSE;
    }

    pNested = PNESTED(pScrn);

    if (!xf86SetDepthBpp(pScrn, 0, 0, 0, Support24bppFb | Support32bppFb))
        return FALSE;
 
    xf86PrintDepthBpp(pScrn);

    if (pScrn->depth > 8) {
        rgb zeros = {0, 0, 0};
        if (!xf86SetWeight(pScrn, zeros, zeros)) {
            return FALSE;
        }
    }

    if (!xf86SetDefaultVisual(pScrn, -1))
        return FALSE;

    pScrn->monitor = pScrn->confScreen->monitor; /* XXX */

    xf86CollectOptions(pScrn, NULL);
    xf86ProcessOptions(pScrn->scrnIndex, pScrn->options, NestedOptions);

    if (xf86IsOptionSet(NestedOptions, OPTION_DISPLAY)) {
        pNested->displayName = xf86GetOptValString(NestedOptions,
                                                   OPTION_DISPLAY);
        xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Using display \"%s\"\n",
                   pNested->displayName);
    } else {
        pNested->displayName = NULL;
    }

    if (xf86IsOptionSet(NestedOptions, OPTION_ORIGIN)) {
        originString = xf86GetOptValString(NestedOptions, OPTION_ORIGIN);
        if (sscanf(originString, "%d %d", &pNested->originX,
            &pNested->originY) != 2) {
            xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
                       "Invalid value for option \"Origin\"\n");
            return FALSE;
        }
        xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Using origin x:%d y:%d\n",
                   pNested->originX, pNested->originY);
    } else {
        pNested->originX = 0;
        pNested->originY = 0;
    }

    xf86ShowUnusedOptions(pScrn->scrnIndex, pScrn->options);

    if (!NestedClientCheckDisplay(pNested->displayName)) {
        xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Can't open display: %s\n",
                   pNested->displayName);
        return FALSE;
    }

    if (!NestedClientValidDepth(pScrn->depth)) {
        xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Invalid depth: %d\n",
                   pScrn->depth);
        return FALSE;
    }

    /*if (pScrn->depth > 1) {
        Gamma zeros = {0.0, 0.0, 0.0};
        if (!xf86SetGamma(pScrn, zeros))
            return FALSE;
    }*/

    if (NestedValidateModes(pScrn) < 1) {
        xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No valid modes\n");
        return FALSE;
    }


    if (!pScrn->modes) {
        xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "No valid modes found\n");
        return FALSE;
    }
    xf86SetCrtcForModes(pScrn, 0);

    pScrn->currentMode = pScrn->modes;

    xf86SetDpi(pScrn, 0, 0);

    if (!xf86LoadSubModule(pScrn, "shadow"))
        return FALSE;
    if (!xf86LoadSubModule(pScrn, "fb"))
        return FALSE;
    if (!xf86LoadSubModule(pScrn, "ramdac"))
        return FALSE;

    pScrn->memPhysBase = 0;
    pScrn->fbOffset = 0;
    
    return TRUE;
}