| /xsrc/external/mit/xf86-video-nv/dist/src/ |
| g80_dma.c | 31 void G80DmaKickoff(G80Ptr pNv)
33 if(pNv->dmaCurrent != pNv->dmaPut) {
34 pNv->dmaPut = pNv->dmaCurrent;
35 pNv->reg[0x00c02040/4] = pNv->dmaPut << 2;
39 void G80DmaWait(G80Ptr pNv, int size)
45 while(pNv->dmaFree < size) {
46 dmaGet = pNv->reg[0x00c02044/4] >> 2
[all...] |
| g80_dma.h | 3 #define G80DmaNext(pNv, data) \
4 (pNv)->dmaBase[(pNv)->dmaCurrent++] = (data)
6 #define G80DmaStart(pNv, tag, size) { \
7 if((pNv)->dmaFree <= (size)) \
8 G80DmaWait(pNv, size); \
9 G80DmaNext(pNv, ((size) << 18) | (tag)); \
10 (pNv)->dmaFree -= ((size) + 1); \
13 void G80DmaKickoff(G80Ptr pNv);
14 void G80DmaWait(G80Ptr pNv, int size)
[all...] |
| nv_xaa.c | 98 NVDmaKickoff(NVPtr pNv)
100 if(pNv->dmaCurrent != pNv->dmaPut) {
101 pNv->dmaPut = pNv->dmaCurrent;
102 WRITE_PUT(pNv, pNv->dmaPut);
115 NVPtr pNv,
122 while(pNv->dmaFree < size) {
123 dmaGet = READ_GET(pNv);
[all...] |
| g80_exa.c | 41 setSrc(G80Ptr pNv, PixmapPtr pSrc)
54 G80DmaStart(pNv, 0x230, 2);
55 G80DmaNext (pNv, depth);
56 G80DmaNext (pNv, 0x00000001);
57 G80DmaStart(pNv, 0x244, 5);
58 G80DmaNext (pNv, exaGetPixmapPitch(pSrc));
59 G80DmaNext (pNv, pSrc->drawable.width);
60 G80DmaNext (pNv, pSrc->drawable.height);
61 G80DmaNext (pNv, 0x00000000);
62 G80DmaNext (pNv, exaGetPixmapOffset(pSrc))
[all...] |
| g80_xaa.c | 37 G80Ptr pNv = G80PTR(pScrn);
38 volatile CARD16 *pSync = (volatile CARD16*)&pNv->reg[0x00711008/4] + 1;
40 G80DmaStart(pNv, 0x104, 1);
41 G80DmaNext (pNv, 0);
42 G80DmaStart(pNv, 0x100, 1);
43 G80DmaNext (pNv, 0);
46 G80DmaKickoff(pNv);
53 G80Ptr pNv = G80PTR(pScrn);
55 G80DmaKickoff(pNv);
56 pNv->DMAKickoffCallback = NULL
[all...] |
| g80_driver.c | 98 G80Ptr pNv = G80PTR(pScrn);
111 !pNv->xaa ||
113 pNv->exa) {
129 if(pNv->exa) {
130 if(pNv->exaScreenArea)
131 exaOffscreenFree(pScreen, pNv->exaScreenArea);
132 pNv->exaScreenArea = exaOffscreenAlloc(pScreen, pitch * pScrn->virtualY,
134 if(!pNv->exaScreenArea || pNv->exaScreenArea->offset != 0) {
152 G80Ptr pNv;
[all...] |
| nv_hw.c | 34 NVPtr pNv,
40 VGA_WR08(pNv->PCIO, 0x3D4, 0x1F);
41 VGA_WR08(pNv->PCIO, 0x3D5, Lock ? 0x99 : 0x57);
43 VGA_WR08(pNv->PCIO, 0x3D4, 0x11);
44 cr11 = VGA_RD08(pNv->PCIO, 0x3D5);
47 VGA_WR08(pNv->PCIO, 0x3D5, cr11);
51 NVPtr pNv,
55 int current = pNv->CurrentState->cursor1;
57 pNv->CurrentState->cursor1 = (pNv->CurrentState->cursor1 & 0xFE)
[all...] |
| nv_setup.c | 43 NVPtr pNv = (NVPtr)pVga->MMIOBase;
44 VGA_WR08(pNv->PCIO, pVga->IOBase + VGA_CRTC_INDEX_OFFSET, index);
45 VGA_WR08(pNv->PCIO, pVga->IOBase + VGA_CRTC_DATA_OFFSET, value);
49 NVPtr pNv = (NVPtr)pVga->MMIOBase;
50 VGA_WR08(pNv->PCIO, pVga->IOBase + VGA_CRTC_INDEX_OFFSET, index);
51 return (VGA_RD08(pNv->PCIO, pVga->IOBase + VGA_CRTC_DATA_OFFSET));
55 NVPtr pNv = (NVPtr)pVga->MMIOBase;
56 VGA_WR08(pNv->PVIO, VGA_GRAPH_INDEX, index);
57 VGA_WR08(pNv->PVIO, VGA_GRAPH_DATA, value);
61 NVPtr pNv = (NVPtr)pVga->MMIOBase
[all...] |
| nv_local.h | 65 #define NVDmaNext(pNv, data) { \
66 (pNv)->dmaBase[(pNv)->dmaCurrent++] = (data); \
69 #define NVDmaStart(pNv, tag, size) { \
70 if((pNv)->dmaFree <= (size)) \
71 NVDmaWait(pNv, size); \
72 NVDmaNext(pNv, ((size) << 18) | (tag)); \
73 (pNv)->dmaFree -= ((size) + 1); \
76 #define WRITE_PUT(pNv, data) { \
79 scratch = (pNv)->FbStart[0];
[all...] |
| g80_cursor.c | 36 #define CURSOR_PTR ((CARD32*)pNv->mem + pNv->videoRam * 256 - 0x1000)
40 G80Ptr pNv = G80PTR(crtc->scrn);
45 pNv->reg[(0x00647084 + headOff)/4] = y << 16 | x;
46 pNv->reg[(0x00647080 + headOff)/4] = 0;
51 G80Ptr pNv = G80PTR(crtc->scrn);
60 G80Ptr pNv = G80PTR(pScrn);
64 if(!pNv->HWCursor) return TRUE;
70 pNv->reg[(0x00610270+headOff)/4] = 0x2000;
71 while(pNv->reg[(0x00610270+headOff)/4] & 0x30000)
[all...] |
| nv_exa.c | 67 NVPtr pNv = NVPTR(pScrn);
73 planemask |= ~0 << pNv->CurrentLayout.depth;
82 NVDmaStart(pNv, SURFACE_FORMAT, 4);
83 NVDmaNext (pNv, pNv->surfaceFormat);
84 NVDmaNext (pNv, srcpitch | (dstpitch << 16));
85 NVDmaNext (pNv, srcoff);
86 NVDmaNext (pNv, dstoff);
88 pNv->DMAKickoffCallback = NVDMAKickoffCallback;
107 NVPtr pNv = NVPTR(pScrn)
[all...] |
| nv_cursor.c | 52 ConvertCursor1555(NVPtr pNv, CARD32 *src, CARD16 *dst)
63 *dst = ( b & 0x80000000) ? pNv->curFg : pNv->curBg;
70 *dst = ( b & 1) ? pNv->curFg : pNv->curBg;
83 ConvertCursor8888(NVPtr pNv, CARD32 *src, CARD32 *dst)
94 *dst = ( b & 0x80000000) ? pNv->curFg : pNv->curBg;
101 *dst = ( b & 1) ? pNv->curFg : pNv->curBg
[all...] |
| nv_dac.c | 31 NVDACPanelTweaks(NVPtr pNv, NVRegPtr state)
35 if(pNv->usePanelTweak) {
36 tweak = pNv->PanelTweak;
44 if(((pNv->Chipset & 0xffff) == 0x0328) && (state->bpp == 32)) {
46 if (((pNv->PciInfo->subvendor_id & 0xffff) == 0x1179) &&
47 ((pNv->PciInfo->subdevice_id & 0xffff) == 0x0020))
49 if (((pNv->PciInfo->subsysVendor & 0xffff) == 0x1179) &&
50 ((pNv->PciInfo->subsysCard & 0xffff) == 0x0020))
62 if((pNv->Chipset & 0xfff0) == 0x0310) {
88 NVPtr pNv = NVPTR(pScrn)
[all...] |
| nv_driver.c | 1080 NVPtr pNv = NVPTR(pScrn);
1081 const Bool disableAccess = pNv->accessEnabled;
1107 NVPtr pNv = NVPTR(pScrn);
1108 NVFBLayout *pLayout = &pNv->CurrentLayout;
1111 NVSetStartAddress(pNv, startAddr);
1127 NVPtr pNv = NVPTR(pScrn);
1133 if(pNv->overlayAdaptor)
1169 NVPtr pNv = NVPTR(pScrn);
1173 NVLockUnlock(pNv, 1);
1190 NVPtr pNv = NVPTR(pScrnInfo)
[all...] |
| nv_shadow.c | 31 NVPtr pNv = NVPTR(pScrn);
41 src = pNv->ShadowPtr + (pbox->y1 * pNv->ShadowPitch) +
43 dst = pNv->FbStart + (pbox->y1 * FBPitch) + (pbox->x1 * Bpp);
48 src += pNv->ShadowPitch;
59 NVPtr pNv = NVPTR(pScrn);
62 if(pNv->Rotate == 1) {
70 (*pNv->PointerMoved)(arg, newX, newY);
76 NVPtr pNv = NVPTR(pScrn);
81 if(!pNv->Rotate)
[all...] |
| g80_xaa.h | 3 void G80SetPattern(G80Ptr pNv, int bg, int fg, int pat0, int pat1);
4 void G80SetRopSolid(G80Ptr pNv, CARD32 rop, CARD32 planemask);
5 void G80SetClip(G80Ptr pNv, int x, int y, int w, int h);
|
| nv_dga.c | 61 NVPtr pNv = NVPTR(pScrn);
75 (size <= pNv->ScratchBufferStart)) {
92 if(!pNv->NoAccel)
112 mode->address = pNv->FbStart;
115 mode->imageHeight = pNv->ScratchBufferStart /
142 NVPtr pNv = NVPTR(pScrn);
170 pNv->numDGAModes = num;
171 pNv->DGAModes = modes;
197 NVPtr pNv = NVPTR(pScrn);
200 if(pNv->DGAactive
[all...] |
| g80_output.c | 70 static Bool G80ReadPortMapping(int scrnIndex, G80Ptr pNv)
80 pNv->i2cMap[i].dac = pNv->i2cMap[i].sor = -1;
83 switch(*(CARD16*)pNv->table1) {
92 a = *(CARD16*)(pNv->table1 + 0x36);
93 table2 = (unsigned char*)pNv->table1 + a;
100 table3 = (unsigned char*)pNv->table1 + *(CARD16*)(table2 + 4);
147 if(pNv->i2cMap[port].dac != (ORNum)-1) {
150 "port %i\n", or, pNv->i2cMap[port].dac, port);
152 pNv->i2cMap[port].dac = or
[all...] |
| /xsrc/external/mit/xf86-video-nouveau/dist/src/ |
| nv04_xv_ovl.c | 47 NVPtr pNv = NVPTR(pScrn);
48 NVPortPrivPtr pPriv = GET_OVERLAY_PRIVATE(pNv);
71 nvWriteVIDEO(pNv, NV_PVIDEO_OE_STATE, 0);
72 nvWriteVIDEO(pNv, NV_PVIDEO_SU_STATE, 0);
73 nvWriteVIDEO(pNv, NV_PVIDEO_RM_STATE, 0);
75 nvWriteVIDEO(pNv, NV_PVIDEO_BUFF0_START_ADDRESS,
77 nvWriteVIDEO(pNv, NV_PVIDEO_BUFF0_START_ADDRESS + 4,
79 nvWriteVIDEO(pNv, NV_PVIDEO_BUFF0_PITCH_LENGTH, dstPitch);
80 nvWriteVIDEO(pNv, NV_PVIDEO_BUFF0_PITCH_LENGTH + 4, dstPitch);
81 nvWriteVIDEO(pNv, NV_PVIDEO_BUFF0_OFFSET, 0)
[all...] |
| nouveau_copy.c | 31 NVPtr pNv = NVPTR(pScrn);
32 nouveau_object_del(&pNv->NvCopy);
33 nouveau_pushbuf_del(&pNv->ce_pushbuf);
34 nouveau_object_del(&pNv->ce_channel);
55 NVPtr pNv = NVPTR(pScrn);
58 if (pNv->AccelMethod == NONE) {
64 switch (pNv->Architecture) {
66 if (pNv->dev->chipset < 0xa3 ||
67 pNv->dev->chipset == 0xaa ||
68 pNv->dev->chipset == 0xac
[all...] |
| nv_accel_common.c | 35 NVPtr pNv = NVPTR(scrn);
51 if (scanout && pNv->tiled_scanout)
54 if (pNv->Architecture >= NV_TESLA) {
64 if (pNv->Architecture >= NV_FERMI) {
78 } else if (pNv->Architecture >= NV_TESLA) {
96 pNv->dev->chipset >= 0x40 ? 1024 : 256,
104 if (pNv->Architecture < NV_TESLA) {
116 ret = nouveau_bo_new(pNv->dev, flags, 0, *pitch * height, &cfg, bo);
129 NVPtr pNv = NVPTR(pScrn);
130 struct nouveau_pushbuf *push = pNv->pushbuf
[all...] |
| nvc0_accel.c | 66 #define NVC0PushProgram(pNv,addr,code) do { \
68 PUSH_DATAu((pNv)->pushbuf, (pNv)->scratch, (addr), size); \
69 PUSH_DATAp((pNv)->pushbuf, (code), size); \
76 NVPtr pNv = NVPTR(pScrn);
77 struct nouveau_pushbuf *push = pNv->pushbuf;
81 if (!pNv->NvSW || !nouveau_exa_pixmap_is_onscreen(ppix))
96 PUSH_DATA (push, pNv->NvSW->handle);
98 PUSH_DATA (push, (pNv->scratch->offset + SEMA_OFFSET) >> 32);
99 PUSH_DATA (push, (pNv->scratch->offset + SEMA_OFFSET))
[all...] |
| nv_driver.c | 478 NVPtr pNv = NVPTR(pScrn);
491 ret = drmSetMaster(pNv->dev->fd);
499 if (pNv->overlayAdaptor && pNv->Architecture != NV_ARCH_04)
515 NVPtr pNv = NVPTR(pScrn);
529 ret = drmDropMaster(pNv->dev->fd);
538 NVPtr pNv = NVPTR(pScrn);
539 if (pScrn->vtSema && pNv->Flush)
540 pNv->Flush(pScrn);
582 NVPtr pNv = NVPTR(pScrn)
[all...] |
| nv10_xv_ovl.c | 70 NVPtr pNv = NVPTR(pScrn);
71 NVPortPrivPtr pPriv = GET_OVERLAY_PRIVATE(pNv);
97 nvWriteVIDEO(pNv, NV_PVIDEO_BASE(buffer) , 0);
98 nvWriteVIDEO(pNv, NV_PVIDEO_OFFSET_BUFF(buffer),
100 nvWriteVIDEO(pNv, NV_PVIDEO_SIZE_IN(buffer) , (height << 16) | width);
101 nvWriteVIDEO(pNv, NV_PVIDEO_POINT_IN(buffer) ,
103 nvWriteVIDEO(pNv, NV_PVIDEO_DS_DX(buffer) , (src_w << 20) / drw_w);
104 nvWriteVIDEO(pNv, NV_PVIDEO_DT_DY(buffer) , (src_h << 20) / drw_h);
105 nvWriteVIDEO(pNv, NV_PVIDEO_POINT_OUT(buffer),
107 nvWriteVIDEO(pNv, NV_PVIDEO_SIZE_OUT(buffer)
[all...] |
| nv_shadow.c | 34 NVPtr pNv = NVPTR(pScrn);
41 nouveau_bo_map(pNv->scanout, NOUVEAU_BO_WR, pNv->client);
51 src = pNv->ShadowPtr + (y1 * pNv->ShadowPitch) + (x1 * cpp);
52 dst = pNv->scanout->map + (y1 * FBPitch) + (x1 * cpp);
57 src += pNv->ShadowPitch;
|
