Aurelien
/
xf86-video-intel
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'crestline-origin' into crestline

This commit is contained in:
Eric Anholt 2006-11-17 14:57:41 -08:00
parent 15ff17c756 2fe6107ac6
commit ee502dd92a
12 changed files with 1241 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/i830.h
View File

@ -359,6 +359,7 @@ typedef struct _I830Rec {
XF86ModReqInfo shadowReq; /* to test for later libshadow */
I830MemRange RotatedMem;
I830MemRange RotatedMem2;
I830MemRange RotateStateMem; /* for G965 state buffer */
Rotation rotation;
int InitialRotation;
int displayWidth;

13
src/i830_driver.c
View File

@ -2940,6 +2940,10 @@ I830ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
/* Rotated2 Buffer */
memset(&(pI830->RotatedMem2), 0, sizeof(pI830->RotatedMem2));
pI830->RotatedMem2.Key = -1;
if (IS_I965G(pI830)) {
memset(&(pI830->RotateStateMem), 0, sizeof(pI830->RotateStateMem));
pI830->RotateStateMem.Key = -1;
}
}
#ifdef HAS_MTRR_SUPPORT
@ -3299,11 +3303,7 @@ I830ScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv)
xf86DisableRandR(); /* Disable built-in RandR extension */
shadowSetup(pScreen);
/* support all rotations */
if (IS_I965G(pI830)) {
I830RandRInit(pScreen, RR_Rotate_0); /* only 0 degrees for I965G */
} else {
I830RandRInit(pScreen, RR_Rotate_0 | RR_Rotate_90 | RR_Rotate_180 | RR_Rotate_270);
}
I830RandRInit(pScreen, RR_Rotate_0 | RR_Rotate_90 | RR_Rotate_180 | RR_Rotate_270);
pI830->PointerMoved = pScrn->PointerMoved;
pScrn->PointerMoved = I830PointerMoved;
pI830->CreateScreenResources = pScreen->CreateScreenResources;
@ -3666,8 +3666,7 @@ I830SwitchMode(int scrnIndex, DisplayModePtr mode, int flags)
* The extra WindowTable check detects a rotation at startup.
*/
if ( (!WindowTable[pScrn->scrnIndex] || pspix->devPrivate.ptr == NULL) &&
!pI830->DGAactive && (pScrn->PointerMoved == I830PointerMoved) &&
!IS_I965G(pI830)) {
!pI830->DGAactive && (pScrn->PointerMoved == I830PointerMoved)) {
if (!I830Rotate(pScrn, mode))
ret = FALSE;
}

36
src/i830_memory.c
View File

@ -518,6 +518,28 @@ I830AllocateRotatedBuffer(ScrnInfoPtr pScrn, int flags)
xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, verbosity,
"%sAllocated %ld kB for the rotated buffer at 0x%lx.\n", s,
alloced / 1024, pI830->RotatedMem.Start);
#define BRW_LINEAR_EXTRA (32*1024)
if (IS_I965G(pI830)) {
memset(&(pI830->RotateStateMem), 0, sizeof(I830MemRange));
pI830->RotateStateMem.Key = -1;
size = ROUND_TO_PAGE(BRW_LINEAR_EXTRA);
align = GTT_PAGE_SIZE;
alloced = I830AllocVidMem(pScrn, &(pI830->RotateStateMem),
&(pI830->StolenPool), size, align,
flags | FROM_ANYWHERE | ALLOCATE_AT_TOP);
if (alloced < size) {
if (!dryrun) {
xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
"G965: Failed to allocate rotate state buffer space.\n");
}
return FALSE;
}
xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, verbosity,
"%sAllocated %ld kB for the G965 rotate state buffer at 0x%lx - 0x%lx.\n", s,
alloced / 1024, pI830->RotateStateMem.Start, pI830->RotateStateMem.End);
}
return TRUE;
}
@ -1738,8 +1760,13 @@ I830SetupMemoryTiling(ScrnInfoPtr pScrn)
int i;
/* Clear out */
for (i = 0; i < 8; i++)
pI830->ModeReg.Fence[i] = 0;
if (IS_I965G(pI830)) {
for (i = 0; i < FENCE_NEW_NR*2; i++)
pI830->ModeReg.Fence[i] = 0;
} else {
for (i = 0; i < 8; i++)
pI830->ModeReg.Fence[i] = 0;
}
nextTile = 0;
tileGeneration = -1;
@ -1809,6 +1836,9 @@ I830SetupMemoryTiling(ScrnInfoPtr pScrn)
}
}
/* XXX tiled rotate mem not ready on G965*/
if(!IS_I965G(pI830)) {
if (pI830->RotatedMem.Alignment >= KB(512)) {
if (MakeTiles(pScrn, &(pI830->RotatedMem), FENCE_XMAJOR)) {
xf86DrvMsg(pScrn->scrnIndex, X_INFO,
@ -1819,7 +1849,7 @@ I830SetupMemoryTiling(ScrnInfoPtr pScrn)
"MakeTiles failed for the rotated buffer.\n");
}
}
}
#if 0
if (pI830->RotatedMem2.Alignment >= KB(512)) {
if (MakeTiles(pScrn, &(pI830->RotatedMem2), FENCE_XMAJOR)) {

753
src/i830_rotate.c
View File

@ -60,6 +60,8 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include "i830.h"
#include "i915_reg.h"
#include "i915_3d.h"
#include "brw_defines.h"
#include "brw_structs.h"
#ifdef XF86DRI
#include "dri.h"
@ -194,6 +196,718 @@ static void draw_poly(CARD32 *vb,
}
}
/* Our PS kernel uses less than 32 GRF registers (about 20) */
#define PS_KERNEL_NUM_GRF 32
#define PS_MAX_THREADS 32
#define BRW_GRF_BLOCKS(nreg) ((nreg + 15) / 16 - 1)
static const CARD32 ps_kernel_static0[][4] = {
#include "rotation_wm_prog0.h"
};
static const CARD32 ps_kernel_static90[][4] = {
#include "rotation_wm_prog90.h"
};
#define ALIGN(i,m) (((i) + (m) - 1) & ~((m) - 1))
#define MIN(a,b) ((a) < (b) ? (a) : (b))
#define BRW_LINEAR_EXTRA (32*1024)
#define WM_BINDING_TABLE_ENTRIES 2
static const CARD32 sip_kernel_static[][4] = {
/* wait (1) a0<1>UW a145<0,1,0>UW { align1 + } */
{ 0x00000030, 0x20000108, 0x00001220, 0x00000000 },
/* nop (4) g0<1>UD { align1 + } */
{ 0x0040007e, 0x20000c21, 0x00690000, 0x00000000 },
/* nop (4) g0<1>UD { align1 + } */
{ 0x0040007e, 0x20000c21, 0x00690000, 0x00000000 },
/* nop (4) g0<1>UD { align1 + } */
{ 0x0040007e, 0x20000c21, 0x00690000, 0x00000000 },
/* nop (4) g0<1>UD { align1 + } */
{ 0x0040007e, 0x20000c21, 0x00690000, 0x00000000 },
/* nop (4) g0<1>UD { align1 + } */
{ 0x0040007e, 0x20000c21, 0x00690000, 0x00000000 },
/* nop (4) g0<1>UD { align1 + } */
{ 0x0040007e, 0x20000c21, 0x00690000, 0x00000000 },
/* nop (4) g0<1>UD { align1 + } */
{ 0x0040007e, 0x20000c21, 0x00690000, 0x00000000 },
/* nop (4) g0<1>UD { align1 + } */
{ 0x0040007e, 0x20000c21, 0x00690000, 0x00000000 },
/* nop (4) g0<1>UD { align1 + } */
{ 0x0040007e, 0x20000c21, 0x00690000, 0x00000000 },
};
#define SF_KERNEL_NUM_GRF 16
#define SF_MAX_THREADS 1
static const CARD32 sf_kernel_static0[][4] = {
#include "rotation_sf_prog0.h"
};
static const CARD32 sf_kernel_static90[][4] = {
#include "rotation_sf_prog90.h"
};
static void
I965UpdateRotate (ScreenPtr pScreen,
shadowBufPtr pBuf)
{
ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
I830Ptr pI830 = I830PTR(pScrn);
ScrnInfoPtr pScrn1 = pScrn;
I830Ptr pI8301 = NULL;
RegionPtr damage = shadowDamage(pBuf);
int nbox = REGION_NUM_RECTS (damage);
BoxPtr pbox = REGION_RECTS (damage);
int box_x1, box_x2, box_y1, box_y2;
float verts[4][2];
struct matrix23 rotMatrix;
Bool updateInvarient = FALSE;
#ifdef XF86DRI
drmI830Sarea *sarea = NULL;
drm_context_t myContext = 0;
#endif
Bool didLock = FALSE;
/* Gen4 states */
int urb_vs_start, urb_vs_size;
int urb_gs_start, urb_gs_size;
int urb_clip_start, urb_clip_size;
int urb_sf_start, urb_sf_size;
int urb_cs_start, urb_cs_size;
struct brw_surface_state *dest_surf_state;
struct brw_surface_state *src_surf_state;
struct brw_sampler_state *src_sampler_state;
struct brw_vs_unit_state *vs_state;
struct brw_sf_unit_state *sf_state;
struct brw_wm_unit_state *wm_state;
struct brw_cc_unit_state *cc_state;
struct brw_cc_viewport *cc_viewport;
struct brw_instruction *sf_kernel;
struct brw_instruction *ps_kernel;
struct brw_instruction *sip_kernel;
float *vb;
BOOL first_output = TRUE;
CARD32 *binding_table;
int dest_surf_offset, src_surf_offset, src_sampler_offset, vs_offset;
int sf_offset, wm_offset, cc_offset, vb_offset, cc_viewport_offset;
int wm_scratch_offset;
int sf_kernel_offset, ps_kernel_offset, sip_kernel_offset;
int binding_table_offset;
int next_offset, total_state_size;
int vb_size = (4 * 4) * 4; /* 4 DWORDS per vertex */
char *state_base;
int state_base_offset;
DPRINTF(PFX, "I965UpdateRotate: from (%d x %d) -> (%d x %d)\n",
pScrn->virtualX, pScrn->virtualY, pScreen->width, pScreen->height);
if (I830IsPrimary(pScrn)) {
pI8301 = pI830;
} else {
pI8301 = I830PTR(pI830->entityPrivate->pScrn_1);
pScrn1 = pI830->entityPrivate->pScrn_1;
}
switch (pI830->rotation) {
case RR_Rotate_90:
matrix23Rotate(&rotMatrix,
pScreen->width, pScreen->height,
90);
break;
case RR_Rotate_180:
matrix23Rotate(&rotMatrix,
pScreen->width, pScreen->height,
180);
break;
case RR_Rotate_270:
matrix23Rotate(&rotMatrix,
pScreen->width, pScreen->height,
270);
break;
default:
break;
}
#ifdef XF86DRI
if (pI8301->directRenderingEnabled) {
sarea = DRIGetSAREAPrivate(pScrn1->pScreen);
myContext = DRIGetContext(pScrn1->pScreen);
didLock = I830DRILock(pScrn1);
}
#endif
if (pScrn->scrnIndex != *pI830->used3D)
updateInvarient = TRUE;
#ifdef XF86DRI
if (sarea && sarea->ctxOwner != myContext)
updateInvarient = TRUE;
#endif
/*XXX we'll always update state */
*pI830->used3D = pScrn->scrnIndex;
#ifdef XF86DRI
if (sarea)
sarea->ctxOwner = myContext;
#endif
/* this starts initialize 3D engine for rotation mapping*/
next_offset = 0;
/* Set up our layout of state in framebuffer. First the general state: */
vs_offset = ALIGN(next_offset, 64);
next_offset = vs_offset + sizeof(*vs_state);
sf_offset = ALIGN(next_offset, 32);
next_offset = sf_offset + sizeof(*sf_state);
wm_offset = ALIGN(next_offset, 32);
next_offset = wm_offset + sizeof(*wm_state);
wm_scratch_offset = ALIGN(next_offset, 1024);
next_offset = wm_scratch_offset + 1024 * PS_MAX_THREADS;
cc_offset = ALIGN(next_offset, 32);
next_offset = cc_offset + sizeof(*cc_state);
sf_kernel_offset = ALIGN(next_offset, 64);
switch (pI830->rotation) {
case RR_Rotate_90:
case RR_Rotate_270:
next_offset = sf_kernel_offset + sizeof (sf_kernel_static90);
ps_kernel_offset = ALIGN(next_offset, 64);
next_offset = ps_kernel_offset + sizeof (ps_kernel_static90);
break;
case RR_Rotate_180:
default:
next_offset = sf_kernel_offset + sizeof (sf_kernel_static0);
ps_kernel_offset = ALIGN(next_offset, 64);
next_offset = ps_kernel_offset + sizeof (ps_kernel_static0);
break;
}
sip_kernel_offset = ALIGN(next_offset, 64);
next_offset = sip_kernel_offset + sizeof (sip_kernel_static);
cc_viewport_offset = ALIGN(next_offset, 32);
next_offset = cc_viewport_offset + sizeof(*cc_viewport);
src_sampler_offset = ALIGN(next_offset, 32);
next_offset = src_sampler_offset + sizeof(*src_sampler_state);
/* Align VB to native size of elements, for safety */
vb_offset = ALIGN(next_offset, 8);
next_offset = vb_offset + vb_size;
dest_surf_offset = ALIGN(next_offset, 32);
next_offset = dest_surf_offset + sizeof(*dest_surf_state);
src_surf_offset = ALIGN(next_offset, 32);
next_offset = src_surf_offset + sizeof(*src_surf_state);
binding_table_offset = ALIGN(next_offset, 32);
next_offset = binding_table_offset + (WM_BINDING_TABLE_ENTRIES * 4);
total_state_size = next_offset;
assert (total_state_size < BRW_LINEAR_EXTRA);
state_base_offset = pI830->RotateStateMem.Start;
state_base_offset = ALIGN(state_base_offset, 64);
state_base = (char *)(pI830->FbBase + state_base_offset);
DPRINTF(PFX, "rotate state buffer start 0x%x, addr 0x%x, base 0x%x\n",
pI830->RotateStateMem.Start, state_base, pI830->FbBase);
vs_state = (void *)(state_base + vs_offset);
sf_state = (void *)(state_base + sf_offset);
wm_state = (void *)(state_base + wm_offset);
cc_state = (void *)(state_base + cc_offset);
sf_kernel = (void *)(state_base + sf_kernel_offset);
ps_kernel = (void *)(state_base + ps_kernel_offset);
sip_kernel = (void *)(state_base + sip_kernel_offset);
cc_viewport = (void *)(state_base + cc_viewport_offset);
dest_surf_state = (void *)(state_base + dest_surf_offset);
src_surf_state = (void *)(state_base + src_surf_offset);
src_sampler_state = (void *)(state_base + src_sampler_offset);
binding_table = (void *)(state_base + binding_table_offset);
vb = (void *)(state_base + vb_offset);
/* For 3D, the VS must have 8, 12, 16, 24, or 32 VUEs allocated to it.
* A VUE consists of a 256-bit vertex header followed by the vertex data,
* which in our case is 4 floats (128 bits), thus a single 512-bit URB
* entry.
*/
#define URB_VS_ENTRIES 8
#define URB_VS_ENTRY_SIZE 1
#define URB_GS_ENTRIES 0
#define URB_GS_ENTRY_SIZE 0
#define URB_CLIP_ENTRIES 0
#define URB_CLIP_ENTRY_SIZE 0
/* The SF kernel we use outputs only 4 256-bit registers, leading to an
* entry size of 2 512-bit URBs. We don't need to have many entries to
* output as we're generally working on large rectangles and don't care
* about having WM threads running on different rectangles simultaneously.
*/
#define URB_SF_ENTRIES 1
#define URB_SF_ENTRY_SIZE 2
#define URB_CS_ENTRIES 0
#define URB_CS_ENTRY_SIZE 0
urb_vs_start = 0;
urb_vs_size = URB_VS_ENTRIES * URB_VS_ENTRY_SIZE;
urb_gs_start = urb_vs_start + urb_vs_size;
urb_gs_size = URB_GS_ENTRIES * URB_GS_ENTRY_SIZE;
urb_clip_start = urb_gs_start + urb_gs_size;
urb_clip_size = URB_CLIP_ENTRIES * URB_CLIP_ENTRY_SIZE;
urb_sf_start = urb_clip_start + urb_clip_size;
urb_sf_size = URB_SF_ENTRIES * URB_SF_ENTRY_SIZE;
urb_cs_start = urb_sf_start + urb_sf_size;
urb_cs_size = URB_CS_ENTRIES * URB_CS_ENTRY_SIZE;
memset (cc_viewport, 0, sizeof (*cc_viewport));
cc_viewport->min_depth = -1.e35;
cc_viewport->max_depth = 1.e35;
memset(cc_state, 0, sizeof(*cc_state));
cc_state->cc0.stencil_enable = 0; /* disable stencil */
cc_state->cc2.depth_test = 0; /* disable depth test */
cc_state->cc2.logicop_enable = 1; /* enable logic op */
cc_state->cc3.ia_blend_enable = 1; /* blend alpha just like colors */
cc_state->cc3.blend_enable = 0; /* disable color blend */
cc_state->cc3.alpha_test = 0; /* disable alpha test */
cc_state->cc4.cc_viewport_state_offset = (state_base_offset + cc_viewport_offset) >> 5;
cc_state->cc5.dither_enable = 0; /* disable dither */
cc_state->cc5.logicop_func = 0xc; /* COPY S*/
cc_state->cc5.statistics_enable = 1;
cc_state->cc5.ia_blend_function = BRW_BLENDFUNCTION_ADD;
cc_state->cc5.ia_src_blend_factor = BRW_BLENDFACTOR_ONE;
cc_state->cc5.ia_dest_blend_factor = BRW_BLENDFACTOR_ZERO;
/* Upload system kernel */
memcpy (sip_kernel, sip_kernel_static, sizeof (sip_kernel_static));
memset(dest_surf_state, 0, sizeof(*dest_surf_state));
dest_surf_state->ss0.surface_type = BRW_SURFACE_2D;
dest_surf_state->ss0.data_return_format = BRW_SURFACERETURNFORMAT_FLOAT32;
if (pI8301->cpp == 2)
dest_surf_state->ss0.surface_format = BRW_SURFACEFORMAT_B5G6R5_UNORM;
else
dest_surf_state->ss0.surface_format = BRW_SURFACEFORMAT_B8G8R8A8_UNORM;
dest_surf_state->ss0.writedisable_alpha = 0;
dest_surf_state->ss0.writedisable_red = 0;
dest_surf_state->ss0.writedisable_green = 0;
dest_surf_state->ss0.writedisable_blue = 0;
dest_surf_state->ss0.color_blend = 0;
dest_surf_state->ss0.vert_line_stride = 0;
dest_surf_state->ss0.vert_line_stride_ofs = 0;
dest_surf_state->ss0.mipmap_layout_mode = 0;
dest_surf_state->ss0.render_cache_read_mode = 0;
if (I830IsPrimary(pScrn))
dest_surf_state->ss1.base_addr = pI830->FrontBuffer.Start;
else
dest_surf_state->ss1.base_addr = pI8301->FrontBuffer2.Start;
dest_surf_state->ss2.width = pScrn->virtualX - 1;
dest_surf_state->ss2.height = pScrn->virtualY - 1;
dest_surf_state->ss2.mip_count = 0;
dest_surf_state->ss2.render_target_rotation = 0; /*XXX how to use? */
dest_surf_state->ss3.pitch = (pI830->displayWidth * pI830->cpp) - 1;
if (pI830->front_tiled) {
dest_surf_state->ss3.tiled_surface = 1;
dest_surf_state->ss3.tile_walk = 0; /* X major */
}
memset(src_surf_state, 0, sizeof(*src_surf_state));
src_surf_state->ss0.surface_type = BRW_SURFACE_2D;
/* src_surf_state->ss0.data_return_format = BRW_SURFACERETURNFORMAT_FLOAT32;*/
if (pI8301->cpp == 2)
src_surf_state->ss0.surface_format = BRW_SURFACEFORMAT_B5G6R5_UNORM;
else
src_surf_state->ss0.surface_format = BRW_SURFACEFORMAT_B8G8R8A8_UNORM;
src_surf_state->ss0.writedisable_alpha = 0;
src_surf_state->ss0.writedisable_red = 0;
src_surf_state->ss0.writedisable_green = 0;
src_surf_state->ss0.writedisable_blue = 0;
src_surf_state->ss0.color_blend = 0;
src_surf_state->ss0.vert_line_stride = 0;
src_surf_state->ss0.vert_line_stride_ofs = 0;
src_surf_state->ss0.mipmap_layout_mode = 0;
src_surf_state->ss0.render_cache_read_mode = 0;
if (I830IsPrimary(pScrn))
src_surf_state->ss1.base_addr = pI830->RotatedMem.Start;
else
src_surf_state->ss1.base_addr = pI8301->RotatedMem2.Start;
src_surf_state->ss2.width = pScreen->width - 1;
src_surf_state->ss2.height = pScreen->height - 1;
src_surf_state->ss2.mip_count = 0;
src_surf_state->ss2.render_target_rotation = 0;
src_surf_state->ss3.pitch = (pScrn->displayWidth * pI830->cpp) - 1;
if (pI830->rotated_tiled) {
src_surf_state->ss3.tiled_surface = 1;
src_surf_state->ss3.tile_walk = 0; /* X major */
}
binding_table[0] = state_base_offset + dest_surf_offset;
binding_table[1] = state_base_offset + src_surf_offset;
memset(src_sampler_state, 0, sizeof(*src_sampler_state));
src_sampler_state->ss0.min_filter = BRW_MAPFILTER_LINEAR;
src_sampler_state->ss0.mag_filter = BRW_MAPFILTER_LINEAR;
src_sampler_state->ss1.r_wrap_mode = BRW_TEXCOORDMODE_CLAMP;
src_sampler_state->ss1.s_wrap_mode = BRW_TEXCOORDMODE_CLAMP;
src_sampler_state->ss1.t_wrap_mode = BRW_TEXCOORDMODE_CLAMP;
/* Set up the vertex shader to be disabled (passthrough) */
memset(vs_state, 0, sizeof(*vs_state));
vs_state->thread4.nr_urb_entries = URB_VS_ENTRIES;
vs_state->thread4.urb_entry_allocation_size = URB_VS_ENTRY_SIZE - 1;
vs_state->vs6.vs_enable = 0;
vs_state->vs6.vert_cache_disable = 1;
/* Set up the SF kernel to do coord interp: for each attribute,
* calculate dA/dx and dA/dy. Hand these interpolation coefficients
* back to SF which then hands pixels off to WM.
*/
switch (pI830->rotation) {
case RR_Rotate_90:
case RR_Rotate_270:
memcpy (sf_kernel, sf_kernel_static90, sizeof (sf_kernel_static90));
memcpy (ps_kernel, ps_kernel_static90, sizeof (ps_kernel_static90));
break;
case RR_Rotate_180:
default:
memcpy (sf_kernel, sf_kernel_static0, sizeof (sf_kernel_static0));
memcpy (ps_kernel, ps_kernel_static0, sizeof (ps_kernel_static0));
break;
}
memset(sf_state, 0, sizeof(*sf_state));
sf_state->thread0.kernel_start_pointer =
(state_base_offset + sf_kernel_offset) >> 6;
sf_state->thread0.grf_reg_count = BRW_GRF_BLOCKS(SF_KERNEL_NUM_GRF);
sf_state->sf1.single_program_flow = 1; /* XXX */
sf_state->sf1.binding_table_entry_count = 0;
sf_state->sf1.thread_priority = 0;
sf_state->sf1.floating_point_mode = 0;
sf_state->sf1.illegal_op_exception_enable = 1;
sf_state->sf1.mask_stack_exception_enable = 1;
sf_state->sf1.sw_exception_enable = 1;
sf_state->thread2.per_thread_scratch_space = 0;
sf_state->thread2.scratch_space_base_pointer = 0; /* not used in our kernel */
sf_state->thread3.const_urb_entry_read_length = 0; /* no const URBs */
sf_state->thread3.const_urb_entry_read_offset = 0; /* no const URBs */
sf_state->thread3.urb_entry_read_length = 1; /* 1 URB per vertex */
sf_state->thread3.urb_entry_read_offset = 0;
sf_state->thread3.dispatch_grf_start_reg = 3;
sf_state->thread4.max_threads = SF_MAX_THREADS - 1;
sf_state->thread4.urb_entry_allocation_size = URB_SF_ENTRY_SIZE - 1;
sf_state->thread4.nr_urb_entries = URB_SF_ENTRIES;
sf_state->thread4.stats_enable = 1;
sf_state->sf5.viewport_transform = FALSE; /* skip viewport */
sf_state->sf6.cull_mode = BRW_CULLMODE_NONE;
sf_state->sf6.scissor = 0;
sf_state->sf7.trifan_pv = 2;
sf_state->sf6.dest_org_vbias = 0x8;
sf_state->sf6.dest_org_hbias = 0x8;
memset (wm_state, 0, sizeof (*wm_state));
wm_state->thread0.kernel_start_pointer =
(state_base_offset + ps_kernel_offset) >> 6;
wm_state->thread0.grf_reg_count = BRW_GRF_BLOCKS(PS_KERNEL_NUM_GRF);
wm_state->thread1.single_program_flow = 1; /* XXX */
wm_state->thread1.binding_table_entry_count = 2;
/* Though we never use the scratch space in our WM kernel, it has to be
* set, and the minimum allocation is 1024 bytes.
*/
wm_state->thread2.scratch_space_base_pointer = (state_base_offset +
wm_scratch_offset) >> 10;
wm_state->thread2.per_thread_scratch_space = 0; /* 1024 bytes */
wm_state->thread3.dispatch_grf_start_reg = 3;
wm_state->thread3.const_urb_entry_read_length = 0;
wm_state->thread3.const_urb_entry_read_offset = 0;
wm_state->thread3.urb_entry_read_length = 1;
wm_state->thread3.urb_entry_read_offset = 0;
wm_state->wm4.stats_enable = 1;
wm_state->wm4.sampler_state_pointer = (state_base_offset + src_sampler_offset) >> 5;
wm_state->wm4.sampler_count = 1; /* 1-4 samplers used */
wm_state->wm5.max_threads = PS_MAX_THREADS - 1;
wm_state->wm5.thread_dispatch_enable = 1;
wm_state->wm5.enable_16_pix = 1;
wm_state->wm5.enable_8_pix = 0;
wm_state->wm5.early_depth_test = 1;
{
BEGIN_LP_RING(2);
OUT_RING(MI_FLUSH |
MI_STATE_INSTRUCTION_CACHE_FLUSH |
BRW_MI_GLOBAL_SNAPSHOT_RESET);
OUT_RING(MI_NOOP);
ADVANCE_LP_RING();
}
{
BEGIN_LP_RING(12);
OUT_RING(BRW_PIPELINE_SELECT | PIPELINE_SELECT_3D);
/* Mesa does this. Who knows... */
OUT_RING(BRW_CS_URB_STATE | 0);
OUT_RING((0 << 4) | /* URB Entry Allocation Size */
(0 << 0)); /* Number of URB Entries */
/* Zero out the two base address registers so all offsets are absolute */
OUT_RING(BRW_STATE_BASE_ADDRESS | 4);
OUT_RING(0 | BASE_ADDRESS_MODIFY); /* Generate state base address */
OUT_RING(0 | BASE_ADDRESS_MODIFY); /* Surface state base address */
OUT_RING(0 | BASE_ADDRESS_MODIFY); /* media base addr, don't care */
OUT_RING(0x10000000 | BASE_ADDRESS_MODIFY); /* general state max addr, disabled */
OUT_RING(0x10000000 | BASE_ADDRESS_MODIFY); /* media object state max addr, disabled */
/* Set system instruction pointer */
OUT_RING(BRW_STATE_SIP | 0);
OUT_RING(state_base_offset + sip_kernel_offset); /* system instruction pointer */
OUT_RING(MI_NOOP);
ADVANCE_LP_RING();
}
{
BEGIN_LP_RING(36);
/* Enable VF statistics */
OUT_RING(BRW_3DSTATE_VF_STATISTICS | 1);
/* Pipe control */
OUT_RING(BRW_PIPE_CONTROL |
BRW_PIPE_CONTROL_NOWRITE |
BRW_PIPE_CONTROL_IS_FLUSH |
2);
OUT_RING(0); /* Destination address */
OUT_RING(0); /* Immediate data low DW */
OUT_RING(0); /* Immediate data high DW */
/* Binding table pointers */
OUT_RING(BRW_3DSTATE_BINDING_TABLE_POINTERS | 4);
OUT_RING(0); /* vs */
OUT_RING(0); /* gs */
OUT_RING(0); /* clip */
OUT_RING(0); /* sf */
/* Only the PS uses the binding table */
OUT_RING(state_base_offset + binding_table_offset); /* ps */
/* XXX: Blend constant color (magenta is fun) */
//OUT_RING(BRW_3DSTATE_CONSTANT_COLOR | 3);
//OUT_RING(float_to_uint (1.0));
//OUT_RING(float_to_uint (0.0));
//OUT_RING(float_to_uint (1.0));
//OUT_RING(float_to_uint (1.0));
/* The drawing rectangle clipping is always on. Set it to values that
* shouldn't do any clipping.
*/
OUT_RING(BRW_3DSTATE_DRAWING_RECTANGLE | 2); /* XXX 3 for BLC or CTG */
OUT_RING(0x00000000); /* ymin, xmin */
OUT_RING((pScrn->virtualX - 1) |
(pScrn->virtualY - 1) << 16); /* ymax, xmax */
OUT_RING(0x00000000); /* yorigin, xorigin */
/* skip the depth buffer */
/* skip the polygon stipple */
/* skip the polygon stipple offset */
/* skip the line stipple */
/* Set the pointers to the 3d pipeline state */
OUT_RING(BRW_3DSTATE_PIPELINED_POINTERS | 5);
OUT_RING(state_base_offset + vs_offset); /* 32 byte aligned */
OUT_RING(BRW_GS_DISABLE); /* disable GS, resulting in passthrough */
OUT_RING(BRW_CLIP_DISABLE); /* disable CLIP, resulting in passthrough */
OUT_RING(state_base_offset + sf_offset); /* 32 byte aligned */
OUT_RING(state_base_offset + wm_offset); /* 32 byte aligned */
OUT_RING(state_base_offset + cc_offset); /* 64 byte aligned */
/* URB fence */
OUT_RING(BRW_URB_FENCE |
UF0_CS_REALLOC |
UF0_SF_REALLOC |
UF0_CLIP_REALLOC |
UF0_GS_REALLOC |
UF0_VS_REALLOC |
1);
OUT_RING(((urb_clip_start + urb_clip_size) << UF1_CLIP_FENCE_SHIFT) |
((urb_gs_start + urb_gs_size) << UF1_GS_FENCE_SHIFT) |
((urb_vs_start + urb_vs_size) << UF1_VS_FENCE_SHIFT));
OUT_RING(((urb_cs_start + urb_cs_size) << UF2_CS_FENCE_SHIFT) |
((urb_sf_start + urb_sf_size) << UF2_SF_FENCE_SHIFT));
/* Constant buffer state */
OUT_RING(BRW_CS_URB_STATE | 0);
OUT_RING(((URB_CS_ENTRY_SIZE - 1) << 4) | /* URB Entry Allocation Size */
(URB_CS_ENTRIES << 0)); /* Number of URB Entries */
/* Set up the pointer to our vertex buffer */
OUT_RING(BRW_3DSTATE_VERTEX_BUFFERS | 2);
OUT_RING((0 << VB0_BUFFER_INDEX_SHIFT) |
VB0_VERTEXDATA |
((4 * 4) << VB0_BUFFER_PITCH_SHIFT)); /* four 32-bit floats per vertex */
OUT_RING(state_base_offset + vb_offset);
OUT_RING(3); /* four corners to our rectangle */
/* Set up our vertex elements, sourced from the single vertex buffer. */
OUT_RING(BRW_3DSTATE_VERTEX_ELEMENTS | 3);
/* offset 0: X,Y -> {X, Y, 1.0, 1.0} */
OUT_RING((0 << VE0_VERTEX_BUFFER_INDEX_SHIFT) |
VE0_VALID |
(BRW_SURFACEFORMAT_R32G32_FLOAT << VE0_FORMAT_SHIFT) |
(0 << VE0_OFFSET_SHIFT));
OUT_RING((BRW_VFCOMPONENT_STORE_SRC << VE1_VFCOMPONENT_0_SHIFT) |
(BRW_VFCOMPONENT_STORE_SRC << VE1_VFCOMPONENT_1_SHIFT) |
(BRW_VFCOMPONENT_STORE_1_FLT << VE1_VFCOMPONENT_2_SHIFT) |
(BRW_VFCOMPONENT_STORE_1_FLT << VE1_VFCOMPONENT_3_SHIFT) |
(0 << VE1_DESTINATION_ELEMENT_OFFSET_SHIFT));
/* offset 8: S0, T0 -> {S0, T0, 1.0, 1.0} */
OUT_RING((0 << VE0_VERTEX_BUFFER_INDEX_SHIFT) |
VE0_VALID |
(BRW_SURFACEFORMAT_R32G32_FLOAT << VE0_FORMAT_SHIFT) |
(8 << VE0_OFFSET_SHIFT));
OUT_RING((BRW_VFCOMPONENT_STORE_SRC << VE1_VFCOMPONENT_0_SHIFT) |
(BRW_VFCOMPONENT_STORE_SRC << VE1_VFCOMPONENT_1_SHIFT) |
(BRW_VFCOMPONENT_STORE_1_FLT << VE1_VFCOMPONENT_2_SHIFT) |
(BRW_VFCOMPONENT_STORE_1_FLT << VE1_VFCOMPONENT_3_SHIFT) |
(4 << VE1_DESTINATION_ELEMENT_OFFSET_SHIFT));
//OUT_RING(MI_NOOP); /* pad to quadword */
ADVANCE_LP_RING();
}
{
BEGIN_LP_RING(2);
OUT_RING(MI_FLUSH |
MI_STATE_INSTRUCTION_CACHE_FLUSH |
BRW_MI_GLOBAL_SNAPSHOT_RESET);
OUT_RING(MI_NOOP);
ADVANCE_LP_RING();
}
while (nbox--)
{
float src_scale_x, src_scale_y;
int i;
box_x1 = pbox->x1;
box_y1 = pbox->y1;
box_x2 = pbox->x2;
box_y2 = pbox->y2;
if (!first_output) {
/* Since we use the same little vertex buffer over and over, sync for
* subsequent rectangles.
*/
if (pI830->AccelInfoRec && pI830->AccelInfoRec->NeedToSync) {
(*pI830->AccelInfoRec->Sync)(pScrn);
pI830->AccelInfoRec->NeedToSync = FALSE;
}
}
pbox++;
verts[0][0] = box_x1; verts[0][1] = box_y1;
verts[1][0] = box_x2; verts[1][1] = box_y1;
verts[2][0] = box_x2; verts[2][1] = box_y2;
verts[3][0] = box_x1; verts[3][1] = box_y2;
/* transform coordinates to rotated versions, but leave texcoords unchanged */
for (i = 0; i < 4; i++)
matrix23TransformCoordf(&rotMatrix, &verts[i][0], &verts[i][1]);
src_scale_x = (float)1.0 / (float)pScreen->width;
src_scale_y = (float)1.0 / (float)pScreen->height;
i = 0;
DPRINTF(PFX, "box size (%d, %d) -> (%d, %d)\n",
box_x1, box_y1, box_x2, box_y2);
switch (pI830->rotation) {
case RR_Rotate_90:
vb[i++] = (float)box_x1 * src_scale_x;
vb[i++] = (float)box_y2 * src_scale_y;
vb[i++] = verts[3][0];
vb[i++] = verts[3][1];
vb[i++] = (float)box_x1 * src_scale_x;
vb[i++] = (float)box_y1 * src_scale_y;
vb[i++] = verts[0][0];
vb[i++] = verts[0][1];
vb[i++] = (float)box_x2 * src_scale_x;
vb[i++] = (float)box_y1 * src_scale_y;
vb[i++] = verts[1][0];
vb[i++] = verts[1][1];
break;
case RR_Rotate_270:
vb[i++] = (float)box_x2 * src_scale_x;
vb[i++] = (float)box_y1 * src_scale_y;
vb[i++] = verts[1][0];
vb[i++] = verts[1][1];
vb[i++] = (float)box_x2 * src_scale_x;
vb[i++] = (float)box_y2 * src_scale_y;
vb[i++] = verts[2][0];
vb[i++] = verts[2][1];
vb[i++] = (float)box_x1 * src_scale_x;
vb[i++] = (float)box_y2 * src_scale_y;
vb[i++] = verts[3][0];
vb[i++] = verts[3][1];
break;
case RR_Rotate_180:
default:
vb[i++] = (float)box_x1 * src_scale_x;
vb[i++] = (float)box_y1 * src_scale_y;
vb[i++] = verts[0][0];
vb[i++] = verts[0][1];
vb[i++] = (float)box_x2 * src_scale_x;
vb[i++] = (float)box_y1 * src_scale_y;
vb[i++] = verts[1][0];
vb[i++] = verts[1][1];
vb[i++] = (float)box_x2 * src_scale_x;
vb[i++] = (float)box_y2 * src_scale_y;
vb[i++] = verts[2][0];
vb[i++] = verts[2][1];
break;
}
BEGIN_LP_RING(6);
OUT_RING(BRW_3DPRIMITIVE |
BRW_3DPRIMITIVE_VERTEX_SEQUENTIAL |
(_3DPRIM_RECTLIST << BRW_3DPRIMITIVE_TOPOLOGY_SHIFT) |
(0 << 9) | /* CTG - indirect vertex count */
4);
OUT_RING(3); /* vertex count per instance */
OUT_RING(0); /* start vertex offset */
OUT_RING(1); /* single instance */
OUT_RING(0); /* start instance location */
OUT_RING(0); /* index buffer offset, ignored */
ADVANCE_LP_RING();
first_output = FALSE;
if (pI830->AccelInfoRec)
pI830->AccelInfoRec->NeedToSync = TRUE;
}
if (pI830->AccelInfoRec)
(*pI830->AccelInfoRec->Sync)(pScrn);
#ifdef XF86DRI
if (didLock)
I830DRIUnlock(pScrn1);
#endif
}
static void
I915UpdateRotate (ScreenPtr pScreen,
shadowBufPtr pBuf)
@ -737,11 +1451,15 @@ I830Rotate(ScrnInfoPtr pScrn, DisplayModePtr mode)
if (pI830->noAccel)
func = LoaderSymbol("shadowUpdateRotatePacked");
else
if (IS_I9XX(pI830))
func = I915UpdateRotate;
else
else {
if (IS_I9XX(pI830)) {
if (IS_I965G(pI830))
func = I965UpdateRotate;
else
func = I915UpdateRotate;
} else
func = I830UpdateRotate;
}
if (I830IsPrimary(pScrn)) {
pI8301 = pI830;
@ -818,6 +1536,15 @@ I830Rotate(ScrnInfoPtr pScrn, DisplayModePtr mode)
memset(&(pI8301->RotatedMem), 0, sizeof(pI8301->RotatedMem));
pI8301->RotatedMem.Key = -1;
if (IS_I965G(pI8301)) {
if (pI8301->RotateStateMem.Key != -1)
xf86UnbindGARTMemory(pScrn1->scrnIndex, pI8301->RotateStateMem.Key);
I830FreeVidMem(pScrn1, &(pI8301->RotateStateMem));
memset(&(pI8301->RotateStateMem), 0, sizeof(pI8301->RotateStateMem));
pI8301->RotateStateMem.Key = -1;
}
if (pI830->entityPrivate) {
if (pI8301->RotatedMem2.Key != -1)
xf86UnbindGARTMemory(pScrn1->scrnIndex, pI8301->RotatedMem2.Key);
@ -900,6 +1627,12 @@ I830Rotate(ScrnInfoPtr pScrn, DisplayModePtr mode)
I830FixOffset(pScrn1, &(pI8301->RotatedMem));
if (pI8301->RotatedMem.Key != -1)
xf86BindGARTMemory(pScrn1->scrnIndex, pI8301->RotatedMem.Key, pI8301->RotatedMem.Offset);
if (IS_I965G(pI8301)) {
I830FixOffset(pScrn1, &(pI8301->RotateStateMem));
if (pI8301->RotateStateMem.Key != -1)
xf86BindGARTMemory(pScrn1->scrnIndex, pI8301->RotateStateMem.Key,
pI8301->RotateStateMem.Offset);
}
}
}
@ -967,8 +1700,16 @@ I830Rotate(ScrnInfoPtr pScrn, DisplayModePtr mode)
}
I830SetupMemoryTiling(pScrn1);
/* update fence registers */
for (i = 0; i < 8; i++)
OUTREG(FENCE + i * 4, pI8301->ModeReg.Fence[i]);
if (IS_I965G(pI830)) {
for (i = 0; i < FENCE_NEW_NR; i++) {
OUTREG(FENCE_NEW + i * 8, pI830->ModeReg.Fence[i]);
OUTREG(FENCE_NEW + 4 + i * 8, pI830->ModeReg.Fence[i+FENCE_NEW_NR]);
}
} else {
for (i = 0; i < 8; i++)
OUTREG(FENCE + i * 4, pI8301->ModeReg.Fence[i]);
}
{
drmI830Sarea *sarea = DRIGetSAREAPrivate(pScrn1->pScreen);
I830UpdateDRIBuffers(pScrn1, sarea );

17
src/rotation_sf0.g4a Normal file
View File

@ -0,0 +1,17 @@
send (1) 0 g6<1>F g1.12<0,1,0>F math inv scalar mlen 1 rlen 1 { align1 };
send (1) 0 g6.4<1>F g1.20<0,1,0>F math inv scalar mlen 1 rlen 1 { align1 };
add (8) g7<1>F g4<8,8,1>F -g3<8,8,1>F { align1 };
mul (1) g7<1>F g7<0,1,0>F g6<0,1,0>F { align1 };
mul (1) g7.4<1>F g7.4<0,1,0>F g6.4<0,1,0>F { align1 };
mov (8) m1<1>F g7<0,1,0>F { align1 };
mov (8) m2<1>F g7.4<0,1,0>F { align1 };
mov (8) m3<1>F g3<8,8,1>F { align1 };
send (8) 0 null g0<8,8,1>F urb 0 transpose used complete mlen 4 rlen 0 { align1 EOT };
nop;
nop;
nop;
nop;
nop;
nop;
nop;
nop;

17
src/rotation_sf90.g4a Normal file
View File

@ -0,0 +1,17 @@
send (1) 0 g6<1>F g1.20<0,1,0>F math inv scalar mlen 1 rlen 1 { align1 };
send (1) 0 g6.4<1>F g1.12<0,1,0>F math inv scalar mlen 1 rlen 1 { align1 };
add (8) g7<1>F g4<8,8,1>F -g3<8,8,1>F { align1 };
mul (1) g7<1>F g7<0,1,0>F g6<0,1,0>F { align1 };
mul (1) g7.4<1>F g7.4<0,1,0>F g6.4<0,1,0>F { align1 };
mov (8) m1<1>F g7<0,1,0>F { align1 };
mov (8) m2<1>F g7.4<0,1,0>F { align1 };
mov (8) m3<1>F g3<8,8,1>F { align1 };
send (8) 0 null g0<8,8,1>F urb 0 transpose used complete mlen 4 rlen 0 { align1 EOT };
nop;
nop;
nop;
nop;
nop;
nop;
nop;
nop;

17
src/rotation_sf_prog0.h Normal file
View File

@ -0,0 +1,17 @@
{ 0x00000031, 0x20c01fbd, 0x0000002c, 0x01110081 },
{ 0x00000031, 0x20c41fbd, 0x00000034, 0x01110081 },
{ 0x00600040, 0x20e077bd, 0x008d0080, 0x008d4060 },
{ 0x00000041, 0x20e077bd, 0x000000e0, 0x000000c0 },
{ 0x00000041, 0x20e477bd, 0x000000e4, 0x000000c4 },
{ 0x00600001, 0x202003be, 0x000000e0, 0x00000000 },
{ 0x00600001, 0x204003be, 0x000000e4, 0x00000000 },
{ 0x00600001, 0x206003be, 0x008d0060, 0x00000000 },
{ 0x00600031, 0x20001fbc, 0x008d0000, 0x8640c800 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },

17
src/rotation_sf_prog90.h Normal file
View File

@ -0,0 +1,17 @@
{ 0x00000031, 0x20c01fbd, 0x00000034, 0x01110081 },
{ 0x00000031, 0x20c41fbd, 0x0000002c, 0x01110081 },
{ 0x00600040, 0x20e077bd, 0x008d0080, 0x008d4060 },
{ 0x00000041, 0x20e077bd, 0x000000e0, 0x000000c0 },
{ 0x00000041, 0x20e477bd, 0x000000e4, 0x000000c4 },
{ 0x00600001, 0x202003be, 0x000000e0, 0x00000000 },
{ 0x00600001, 0x204003be, 0x000000e4, 0x00000000 },
{ 0x00600001, 0x206003be, 0x008d0060, 0x00000000 },
{ 0x00600031, 0x20001fbc, 0x008d0000, 0x8640c800 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },

123
src/rotation_wm0.g4a Normal file
View File

@ -0,0 +1,123 @@
/* The initial payload of the thread is always g0.
* WM_URB (incoming URB entries) is g3
* X0_R is g4
* X1_R is g5
* Y0_R is g6
* Y1_R is g7
*/
/* Set up the X/Y screen coordinates of the pixels in our 4 subspans. Each
* subspan is a 2x2 rectangle, and the screen x/y of the upper left of each
* subspan are given in GRF register 1.2 through 1.5 (which, with the word
* addressing below, are 1.4 through 1.11).
*
* The result is WM_X*_R and WM_Y*R being:
*
* X0: {ss0.x, ss0.x+1, ss0.x, ss0.x+1, ss1.x, ss1.x+1, ss1.x, ss1.x+y}
* Y0: {ss0.y, ss0.y, ss0.y+1, ss0.y+1, ss1.y, ss1.y, ss1.y+1, ss1.y+1}
* X1: {ss2.x, ss2.x+1, ss2.x, ss2.x+1, ss3.x, ss3.x+1, ss3.x, ss3.x+y}
* Y1: {ss2.y, ss2.y, ss2.y+1, ss2.y+1, ss3.y, ss3.y, ss3.y+1, ss3.y+1}
*/
/* Set up ss0.x coordinates*/
mov (1) g4<1>F g1.8<0,1,0>UW { align1 };
add (1) g4.4<1>F g1.8<0,1,0>UW 1UB { align1 };
mov (1) g4.8<1>F g1.8<0,1,0>UW { align1 };
add (1) g4.12<1>F g1.8<0,1,0>UW 1UB { align1 };
/* Set up ss0.y coordinates */
mov (1) g6<1>F g1.10<0,1,0>UW { align1 };
mov (1) g6.4<1>F g1.10<0,1,0>UW { align1 };
add (1) g6.8<1>F g1.10<0,1,0>UW 1UB { align1 };
add (1) g6.12<1>F g1.10<0,1,0>UW 1UB { align1 };
/* set up ss1.x coordinates */
mov (1) g4.16<1>F g1.12<0,1,0>UW { align1 };
add (1) g4.20<1>F g1.12<0,1,0>UW 1UB { align1 };
mov (1) g4.24<1>F g1.12<0,1,0>UW { align1 };
add (1) g4.28<1>F g1.12<0,1,0>UW 1UB { align1 };
/* set up ss1.y coordinates */
mov (1) g6.16<1>F g1.14<0,1,0>UW { align1 };
mov (1) g6.20<1>F g1.14<0,1,0>UW { align1 };
add (1) g6.24<1>F g1.14<0,1,0>UW 1UB { align1 };
add (1) g6.28<1>F g1.14<0,1,0>UW 1UB { align1 };
/* Set up ss2.x coordinates */
mov (1) g5<1>F g1.16<0,1,0>UW { align1 };
add (1) g5.4<1>F g1.16<0,1,0>UW 1UB { align1 };
mov (1) g5.8<1>F g1.16<0,1,0>UW { align1 };
add (1) g5.12<1>F g1.16<0,1,0>UW 1UB { align1 };
/* Set up ss2.y coordinates */
mov (1) g7<1>F g1.18<0,1,0>UW { align1 };
mov (1) g7.4<1>F g1.18<0,1,0>UW { align1 };
add (1) g7.8<1>F g1.18<0,1,0>UW 1UB { align1 };
add (1) g7.12<1>F g1.18<0,1,0>UW 1UB { align1 };
/* Set up ss3.x coordinates */
mov (1) g5.16<1>F g1.20<0,1,0>UW { align1 };
add (1) g5.20<1>F g1.20<0,1,0>UW 1UB { align1 };
mov (1) g5.24<1>F g1.20<0,1,0>UW { align1 };
add (1) g5.28<1>F g1.20<0,1,0>UW 1UB { align1 };
/* Set up ss3.y coordinates */
mov (1) g7.16<1>F g1.22<0,1,0>UW { align1 };
mov (1) g7.20<1>F g1.22<0,1,0>UW { align1 };
add (1) g7.24<1>F g1.22<0,1,0>UW 1UB { align1 };
add (1) g7.28<1>F g1.22<0,1,0>UW 1UB { align1 };
/* Now, map these screen space coordinates into texture coordinates. */
/* subtract screen-space X origin of vertex 0. */
add (8) g4<1>F g4<8,8,1>F -g1<0,1,0>F { align1 };
add (8) g5<1>F g5<8,8,1>F -g1<0,1,0>F { align1 };
/* scale by texture X increment */
mul (8) g4<1>F g4<8,8,1>F g3<0,1,0>F { align1 };
mul (8) g5<1>F g5<8,8,1>F g3<0,1,0>F { align1 };
/* add in texture X offset */
add (8) g4<1>F g4<8,8,1>F g3.12<0,1,0>F { align1 };
add (8) g5<1>F g5<8,8,1>F g3.12<0,1,0>F { align1 };
/* subtract screen-space Y origin of vertex 0. */
add (8) g6<1>F g6<8,8,1>F -g1.4<0,1,0>F { align1 };
add (8) g7<1>F g7<8,8,1>F -g1.4<0,1,0>F { align1 };
/* scale by texture Y increment */
/* XXX: double check the fields in Cx,Cy,Co and attributes*/
mul (8) g6<1>F g6<8,8,1>F g3.20<0,1,0>F { align1 };
mul (8) g7<1>F g7<8,8,1>F g3.20<0,1,0>F { align1 };
/* add in texture Y offset */
add (8) g6<1>F g6<8,8,1>F g3.28<0,1,0>F { align1 };
add (8) g7<1>F g7<8,8,1>F g3.28<0,1,0>F { align1 };
/* sampler */
mov (8) m1<1>F g4<8,8,1>F { align1 };
mov (8) m2<1>F g5<8,8,1>F { align1 };
mov (8) m3<1>F g6<8,8,1>F { align1 };
mov (8) m4<1>F g7<8,8,1>F { align1 };
/*
* g0 holds the PS thread payload, which (oddly) contains
* precisely what the sampler wants to see in m0
*/
send (16) 0 g12<1>UW g0<8,8,1>UW sampler (1,0,F) mlen 5 rlen 8 { align1 };
mov (8) g19<1>UD g19<8,8,1>UD { align1 };
mov (8) m2<1>F g12<8,8,1>F { align1 };
mov (8) m3<1>F g14<8,8,1>F { align1 };
mov (8) m4<1>F g16<8,8,1>F { align1 };
mov (8) m5<1>F g18<8,8,1>F { align1 };
mov (8) m6<1>F g13<8,8,1>F { align1 };
mov (8) m7<1>F g15<8,8,1>F { align1 };
mov (8) m8<1>F g17<8,8,1>F { align1 };
mov (8) m9<1>F g19<8,8,1>F { align1 };
/* Pass through control information:
*/
mov (8) m1<1>UD g1<8,8,1>UD { align1 mask_disable };
/* Send framebuffer write message: XXX: acc0? */
send (16) 0 acc0<1>UW g0<8,8,1>UW write (
0, /* binding table index 0 */
8, /* pixel scoreboard clear */
4, /* render target write */
0 /* no write commit message */
) mlen 10 rlen 0 { align1 EOT };
/* padding */
nop;
nop;
nop;
nop;
nop;
nop;
nop;
nop;

127
src/rotation_wm90.g4a Normal file
View File

@ -0,0 +1,127 @@
/* The initial payload of the thread is always g0.
* WM_URB (incoming URB entries) is g3
* X0_R is g4
* X1_R is g5
* Y0_R is g6
* Y1_R is g7
*/
/* Set up the X/Y screen coordinates of the pixels in our 4 subspans. Each
* subspan is a 2x2 rectangle, and the screen x/y of the upper left of each
* subspan are given in GRF register 1.2 through 1.5 (which, with the word
* addressing below, are 1.4 through 1.11).
*
* The result is WM_X*_R and WM_Y*R being:
*
* X0: {ss0.x, ss0.x+1, ss0.x, ss0.x+1, ss1.x, ss1.x+1, ss1.x, ss1.x+y}
* Y0: {ss0.y, ss0.y, ss0.y+1, ss0.y+1, ss1.y, ss1.y, ss1.y+1, ss1.y+1}
* X1: {ss2.x, ss2.x+1, ss2.x, ss2.x+1, ss3.x, ss3.x+1, ss3.x, ss3.x+y}
* Y1: {ss2.y, ss2.y, ss2.y+1, ss2.y+1, ss3.y, ss3.y, ss3.y+1, ss3.y+1}
*/
/* Set up ss0.x coordinates*/
mov (1) g4<1>F g1.8<0,1,0>UW { align1 };
add (1) g4.4<1>F g1.8<0,1,0>UW 1UB { align1 };
mov (1) g4.8<1>F g1.8<0,1,0>UW { align1 };
add (1) g4.12<1>F g1.8<0,1,0>UW 1UB { align1 };
/* Set up ss0.y coordinates */
mov (1) g6<1>F g1.10<0,1,0>UW { align1 };
mov (1) g6.4<1>F g1.10<0,1,0>UW { align1 };
add (1) g6.8<1>F g1.10<0,1,0>UW 1UB { align1 };
add (1) g6.12<1>F g1.10<0,1,0>UW 1UB { align1 };
/* set up ss1.x coordinates */
mov (1) g4.16<1>F g1.12<0,1,0>UW { align1 };
add (1) g4.20<1>F g1.12<0,1,0>UW 1UB { align1 };
mov (1) g4.24<1>F g1.12<0,1,0>UW { align1 };
add (1) g4.28<1>F g1.12<0,1,0>UW 1UB { align1 };
/* set up ss1.y coordinates */
mov (1) g6.16<1>F g1.14<0,1,0>UW { align1 };
mov (1) g6.20<1>F g1.14<0,1,0>UW { align1 };
add (1) g6.24<1>F g1.14<0,1,0>UW 1UB { align1 };
add (1) g6.28<1>F g1.14<0,1,0>UW 1UB { align1 };
/* Set up ss2.x coordinates */
mov (1) g5<1>F g1.16<0,1,0>UW { align1 };
add (1) g5.4<1>F g1.16<0,1,0>UW 1UB { align1 };
mov (1) g5.8<1>F g1.16<0,1,0>UW { align1 };
add (1) g5.12<1>F g1.16<0,1,0>UW 1UB { align1 };
/* Set up ss2.y coordinates */
mov (1) g7<1>F g1.18<0,1,0>UW { align1 };
mov (1) g7.4<1>F g1.18<0,1,0>UW { align1 };
add (1) g7.8<1>F g1.18<0,1,0>UW 1UB { align1 };
add (1) g7.12<1>F g1.18<0,1,0>UW 1UB { align1 };
/* Set up ss3.x coordinates */
mov (1) g5.16<1>F g1.20<0,1,0>UW { align1 };
add (1) g5.20<1>F g1.20<0,1,0>UW 1UB { align1 };
mov (1) g5.24<1>F g1.20<0,1,0>UW { align1 };
add (1) g5.28<1>F g1.20<0,1,0>UW 1UB { align1 };
/* Set up ss3.y coordinates */
mov (1) g7.16<1>F g1.22<0,1,0>UW { align1 };
mov (1) g7.20<1>F g1.22<0,1,0>UW { align1 };
add (1) g7.24<1>F g1.22<0,1,0>UW 1UB { align1 };
add (1) g7.28<1>F g1.22<0,1,0>UW 1UB { align1 };
/* Now, map these screen space coordinates into texture coordinates. */
/* XXX: convert it to calculate (u,v) in 90 and 270 case */
/* subtract screen-space Y origin of vertex 0. */
add (8) g6<1>F g6<8,8,1>F -g1.4<0,1,0>F { align1 };
add (8) g7<1>F g7<8,8,1>F -g1.4<0,1,0>F { align1 };
/* (Yp - Ystart) * Cx */
mul (8) g6<1>F g6<8,8,1>F g3<0,1,0>F { align1 };
mul (8) g7<1>F g7<8,8,1>F g3<0,1,0>F { align1 };
/* scale by texture Y increment */
add (8) g6<1>F g6<8,8,1>F g3.12<0,1,0>F { align1 };
add (8) g7<1>F g7<8,8,1>F g3.12<0,1,0>F { align1 };
/* subtract screen-space X origin of vertex 0. */
add (8) g4<1>F g4<8,8,1>F -g1<0,1,0>F { align1 };
add (8) g5<1>F g5<8,8,1>F -g1<0,1,0>F { align1 };
/* scale by texture X increment */
mul (8) g4<1>F g4<8,8,1>F g3.20<0,1,0>F { align1 };
mul (8) g5<1>F g5<8,8,1>F g3.20<0,1,0>F { align1 };
/* add in texture X offset */
add (8) g4<1>F g4<8,8,1>F g3.28<0,1,0>F { align1 };
add (8) g5<1>F g5<8,8,1>F g3.28<0,1,0>F { align1 };
/* sampler */
mov (8) m1<1>F g6<8,8,1>F { align1 };
mov (8) m2<1>F g7<8,8,1>F { align1 };
mov (8) m3<1>F g4<8,8,1>F { align1 };
mov (8) m4<1>F g5<8,8,1>F { align1 };
/*
* g0 holds the PS thread payload, which (oddly) contains
* precisely what the sampler wants to see in m0
*/
send (16) 0 g12<1>UW g0<8,8,1>UW sampler (1,0,F) mlen 5 rlen 8 { align1 };
mov (8) g19<1>UD g19<8,8,1>UD { align1 };
mov (8) m2<1>F g12<8,8,1>F { align1 };
mov (8) m3<1>F g14<8,8,1>F { align1 };
mov (8) m4<1>F g16<8,8,1>F { align1 };
mov (8) m5<1>F g18<8,8,1>F { align1 };
mov (8) m6<1>F g13<8,8,1>F { align1 };
mov (8) m7<1>F g15<8,8,1>F { align1 };
mov (8) m8<1>F g17<8,8,1>F { align1 };
mov (8) m9<1>F g19<8,8,1>F { align1 };
/* Pass through control information:
*/
mov (8) m1<1>UD g1<8,8,1>UD { align1 mask_disable };
/* Send framebuffer write message: XXX: acc0? */
send (16) 0 acc0<1>UW g0<8,8,1>UW write (
0, /* binding table index 0 */
8, /* pixel scoreboard clear */
4, /* render target write */
0 /* no write commit message */
) mlen 10 rlen 0 { align1 EOT };
/* padding */
nop;
nop;
nop;
nop;
nop;
nop;
nop;
nop;

68
src/rotation_wm_prog0.h Normal file
View File

@ -0,0 +1,68 @@
{ 0x00000001, 0x2080013d, 0x00000028, 0x00000000 },
{ 0x00000040, 0x20840d3d, 0x00000028, 0x00000001 },
{ 0x00000001, 0x2088013d, 0x00000028, 0x00000000 },
{ 0x00000040, 0x208c0d3d, 0x00000028, 0x00000001 },
{ 0x00000001, 0x20c0013d, 0x0000002a, 0x00000000 },
{ 0x00000001, 0x20c4013d, 0x0000002a, 0x00000000 },
{ 0x00000040, 0x20c80d3d, 0x0000002a, 0x00000001 },
{ 0x00000040, 0x20cc0d3d, 0x0000002a, 0x00000001 },
{ 0x00000001, 0x2090013d, 0x0000002c, 0x00000000 },
{ 0x00000040, 0x20940d3d, 0x0000002c, 0x00000001 },
{ 0x00000001, 0x2098013d, 0x0000002c, 0x00000000 },
{ 0x00000040, 0x209c0d3d, 0x0000002c, 0x00000001 },
{ 0x00000001, 0x20d0013d, 0x0000002e, 0x00000000 },
{ 0x00000001, 0x20d4013d, 0x0000002e, 0x00000000 },
{ 0x00000040, 0x20d80d3d, 0x0000002e, 0x00000001 },
{ 0x00000040, 0x20dc0d3d, 0x0000002e, 0x00000001 },
{ 0x00000001, 0x20a0013d, 0x00000030, 0x00000000 },
{ 0x00000040, 0x20a40d3d, 0x00000030, 0x00000001 },
{ 0x00000001, 0x20a8013d, 0x00000030, 0x00000000 },
{ 0x00000040, 0x20ac0d3d, 0x00000030, 0x00000001 },
{ 0x00000001, 0x20e0013d, 0x00000032, 0x00000000 },
{ 0x00000001, 0x20e4013d, 0x00000032, 0x00000000 },
{ 0x00000040, 0x20e80d3d, 0x00000032, 0x00000001 },
{ 0x00000040, 0x20ec0d3d, 0x00000032, 0x00000001 },
{ 0x00000001, 0x20b0013d, 0x00000034, 0x00000000 },
{ 0x00000040, 0x20b40d3d, 0x00000034, 0x00000001 },
{ 0x00000001, 0x20b8013d, 0x00000034, 0x00000000 },
{ 0x00000040, 0x20bc0d3d, 0x00000034, 0x00000001 },
{ 0x00000001, 0x20f0013d, 0x00000036, 0x00000000 },
{ 0x00000001, 0x20f4013d, 0x00000036, 0x00000000 },
{ 0x00000040, 0x20f80d3d, 0x00000036, 0x00000001 },
{ 0x00000040, 0x20fc0d3d, 0x00000036, 0x00000001 },
{ 0x00600040, 0x208077bd, 0x008d0080, 0x00004020 },
{ 0x00600040, 0x20a077bd, 0x008d00a0, 0x00004020 },
{ 0x00600041, 0x208077bd, 0x008d0080, 0x00000060 },
{ 0x00600041, 0x20a077bd, 0x008d00a0, 0x00000060 },
{ 0x00600040, 0x208077bd, 0x008d0080, 0x0000006c },
{ 0x00600040, 0x20a077bd, 0x008d00a0, 0x0000006c },
{ 0x00600040, 0x20c077bd, 0x008d00c0, 0x00004024 },
{ 0x00600040, 0x20e077bd, 0x008d00e0, 0x00004024 },
{ 0x00600041, 0x20c077bd, 0x008d00c0, 0x00000074 },
{ 0x00600041, 0x20e077bd, 0x008d00e0, 0x00000074 },
{ 0x00600040, 0x20c077bd, 0x008d00c0, 0x0000007c },
{ 0x00600040, 0x20e077bd, 0x008d00e0, 0x0000007c },
{ 0x00600001, 0x202003be, 0x008d0080, 0x00000000 },
{ 0x00600001, 0x204003be, 0x008d00a0, 0x00000000 },
{ 0x00600001, 0x206003be, 0x008d00c0, 0x00000000 },
{ 0x00600001, 0x208003be, 0x008d00e0, 0x00000000 },
{ 0x00800031, 0x21801d29, 0x008d0000, 0x02580001 },
{ 0x00600001, 0x22600021, 0x008d0260, 0x00000000 },
{ 0x00600001, 0x204003be, 0x008d0180, 0x00000000 },
{ 0x00600001, 0x206003be, 0x008d01c0, 0x00000000 },
{ 0x00600001, 0x208003be, 0x008d0200, 0x00000000 },
{ 0x00600001, 0x20a003be, 0x008d0240, 0x00000000 },
{ 0x00600001, 0x20c003be, 0x008d01a0, 0x00000000 },
{ 0x00600001, 0x20e003be, 0x008d01e0, 0x00000000 },
{ 0x00600001, 0x210003be, 0x008d0220, 0x00000000 },
{ 0x00600001, 0x212003be, 0x008d0260, 0x00000000 },
{ 0x00600201, 0x20200022, 0x008d0020, 0x00000000 },
{ 0x00800031, 0x24001d28, 0x008d0000, 0x85a04800 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },

68
src/rotation_wm_prog90.h Normal file
View File

@ -0,0 +1,68 @@
{ 0x00000001, 0x2080013d, 0x00000028, 0x00000000 },
{ 0x00000040, 0x20840d3d, 0x00000028, 0x00000001 },
{ 0x00000001, 0x2088013d, 0x00000028, 0x00000000 },
{ 0x00000040, 0x208c0d3d, 0x00000028, 0x00000001 },
{ 0x00000001, 0x20c0013d, 0x0000002a, 0x00000000 },
{ 0x00000001, 0x20c4013d, 0x0000002a, 0x00000000 },
{ 0x00000040, 0x20c80d3d, 0x0000002a, 0x00000001 },
{ 0x00000040, 0x20cc0d3d, 0x0000002a, 0x00000001 },
{ 0x00000001, 0x2090013d, 0x0000002c, 0x00000000 },
{ 0x00000040, 0x20940d3d, 0x0000002c, 0x00000001 },
{ 0x00000001, 0x2098013d, 0x0000002c, 0x00000000 },
{ 0x00000040, 0x209c0d3d, 0x0000002c, 0x00000001 },
{ 0x00000001, 0x20d0013d, 0x0000002e, 0x00000000 },
{ 0x00000001, 0x20d4013d, 0x0000002e, 0x00000000 },
{ 0x00000040, 0x20d80d3d, 0x0000002e, 0x00000001 },
{ 0x00000040, 0x20dc0d3d, 0x0000002e, 0x00000001 },
{ 0x00000001, 0x20a0013d, 0x00000030, 0x00000000 },
{ 0x00000040, 0x20a40d3d, 0x00000030, 0x00000001 },
{ 0x00000001, 0x20a8013d, 0x00000030, 0x00000000 },
{ 0x00000040, 0x20ac0d3d, 0x00000030, 0x00000001 },
{ 0x00000001, 0x20e0013d, 0x00000032, 0x00000000 },
{ 0x00000001, 0x20e4013d, 0x00000032, 0x00000000 },
{ 0x00000040, 0x20e80d3d, 0x00000032, 0x00000001 },
{ 0x00000040, 0x20ec0d3d, 0x00000032, 0x00000001 },
{ 0x00000001, 0x20b0013d, 0x00000034, 0x00000000 },
{ 0x00000040, 0x20b40d3d, 0x00000034, 0x00000001 },
{ 0x00000001, 0x20b8013d, 0x00000034, 0x00000000 },
{ 0x00000040, 0x20bc0d3d, 0x00000034, 0x00000001 },
{ 0x00000001, 0x20f0013d, 0x00000036, 0x00000000 },
{ 0x00000001, 0x20f4013d, 0x00000036, 0x00000000 },
{ 0x00000040, 0x20f80d3d, 0x00000036, 0x00000001 },
{ 0x00000040, 0x20fc0d3d, 0x00000036, 0x00000001 },
{ 0x00600040, 0x20c077bd, 0x008d00c0, 0x00004024 },
{ 0x00600040, 0x20e077bd, 0x008d00e0, 0x00004024 },
{ 0x00600041, 0x20c077bd, 0x008d00c0, 0x00000060 },
{ 0x00600041, 0x20e077bd, 0x008d00e0, 0x00000060 },
{ 0x00600040, 0x20c077bd, 0x008d00c0, 0x0000006c },
{ 0x00600040, 0x20e077bd, 0x008d00e0, 0x0000006c },
{ 0x00600040, 0x208077bd, 0x008d0080, 0x00004020 },
{ 0x00600040, 0x20a077bd, 0x008d00a0, 0x00004020 },
{ 0x00600041, 0x208077bd, 0x008d0080, 0x00000074 },
{ 0x00600041, 0x20a077bd, 0x008d00a0, 0x00000074 },
{ 0x00600040, 0x208077bd, 0x008d0080, 0x0000007c },
{ 0x00600040, 0x20a077bd, 0x008d00a0, 0x0000007c },
{ 0x00600001, 0x202003be, 0x008d00c0, 0x00000000 },
{ 0x00600001, 0x204003be, 0x008d00e0, 0x00000000 },
{ 0x00600001, 0x206003be, 0x008d0080, 0x00000000 },
{ 0x00600001, 0x208003be, 0x008d00a0, 0x00000000 },
{ 0x00800031, 0x21801d29, 0x008d0000, 0x02580001 },
{ 0x00600001, 0x22600021, 0x008d0260, 0x00000000 },
{ 0x00600001, 0x204003be, 0x008d0180, 0x00000000 },
{ 0x00600001, 0x206003be, 0x008d01c0, 0x00000000 },
{ 0x00600001, 0x208003be, 0x008d0200, 0x00000000 },
{ 0x00600001, 0x20a003be, 0x008d0240, 0x00000000 },
{ 0x00600001, 0x20c003be, 0x008d01a0, 0x00000000 },
{ 0x00600001, 0x20e003be, 0x008d01e0, 0x00000000 },
{ 0x00600001, 0x210003be, 0x008d0220, 0x00000000 },
{ 0x00600001, 0x212003be, 0x008d0260, 0x00000000 },
{ 0x00600201, 0x20200022, 0x008d0020, 0x00000000 },
{ 0x00800031, 0x24001d28, 0x008d0000, 0x85a04800 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },
{ 0x0000007e, 0x00000000, 0x00000000, 0x00000000 },