Subversion Repositories Kolibri OS

Rev

Rev 877 | Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1.  
  2. #include "radeon_reg.h"
  3.  
  4. #define BEGIN_ACCEL(n)          BEGIN_RING(2*(n))
  5. //#define FINISH_ACCEL()          ADVANCE_RING()
  6. #define FINISH_ACCEL()          COMMIT_RING()
  7.  
  8. #define OUT_ACCEL_REG(reg, val) OUT_RING_REG(reg, val)
  9.  
  10. #define RADEON_SWITCH_TO_3D()                                           \
  11. do {                                                                    \
  12.         u32_t wait_until = 0;                        \
  13.         BEGIN_ACCEL(1);                                                 \
  14.         wait_until |= RADEON_WAIT_HOST_IDLECLEAN | RADEON_WAIT_3D_IDLECLEAN;        \
  15.         OUT_ACCEL_REG(RADEON_WAIT_UNTIL, wait_until);                   \
  16.         FINISH_ACCEL();                                                 \
  17. } while (0);
  18.  
  19.  
  20. struct blendinfo {
  21.     Bool dst_alpha;
  22.     Bool src_alpha;
  23.     u32_t blend_cntl;
  24. };
  25.  
  26. static struct blendinfo RadeonBlendOp[] = {
  27.     /* 0 - Clear */
  28.     {0, 0, RADEON_SRC_BLEND_GL_ZERO           | RADEON_DST_BLEND_GL_ZERO},
  29.     /* 1 - Src */
  30.     {0, 0, RADEON_SRC_BLEND_GL_ONE            | RADEON_DST_BLEND_GL_ZERO},
  31.     /* 2 - Dst */
  32.     {0, 0, RADEON_SRC_BLEND_GL_ZERO           | RADEON_DST_BLEND_GL_ONE},
  33.     /* 3 - Over */
  34.     {0, 1, RADEON_SRC_BLEND_GL_ONE            | RADEON_DST_BLEND_GL_ONE_MINUS_SRC_ALPHA},
  35.     /* 4 - OverReverse */
  36.     {1, 0, RADEON_SRC_BLEND_GL_ONE_MINUS_DST_ALPHA | RADEON_DST_BLEND_GL_ONE},
  37.     /* 5 - In */
  38.     {1, 0, RADEON_SRC_BLEND_GL_DST_ALPHA     | RADEON_DST_BLEND_GL_ZERO},
  39.     /* 6 - InReverse */
  40.     {0, 1, RADEON_SRC_BLEND_GL_ZERO           | RADEON_DST_BLEND_GL_SRC_ALPHA},
  41.     /* 7 - Out */
  42.     {1, 0, RADEON_SRC_BLEND_GL_ONE_MINUS_DST_ALPHA | RADEON_DST_BLEND_GL_ZERO},
  43.     /* 8 - OutReverse */
  44.     {0, 1, RADEON_SRC_BLEND_GL_ZERO           | RADEON_DST_BLEND_GL_ONE_MINUS_SRC_ALPHA},
  45.     /* 9 - Atop */
  46.     {1, 1, RADEON_SRC_BLEND_GL_DST_ALPHA     | RADEON_DST_BLEND_GL_ONE_MINUS_SRC_ALPHA},
  47.     /* 10- AtopReverse */
  48.     {1, 1, RADEON_SRC_BLEND_GL_ONE_MINUS_DST_ALPHA | RADEON_DST_BLEND_GL_SRC_ALPHA},
  49.     /* 11 - Xor */
  50.     {1, 1, RADEON_SRC_BLEND_GL_ONE_MINUS_DST_ALPHA | RADEON_DST_BLEND_GL_ONE_MINUS_SRC_ALPHA},
  51.     /* 12 - Add */
  52.     {0, 0, RADEON_SRC_BLEND_GL_ONE            | RADEON_DST_BLEND_GL_ONE},
  53. };
  54.  
  55.  
  56. static void Init3DEngine(RHDPtr rhdPtr)
  57. {
  58.    // RADEONInfoPtr  info       = RADEONPTR(pScrn);
  59.     u32_t gb_tile_config, su_reg_dest, vap_cntl;
  60.    // ACCEL_PREAMBLE();
  61.  
  62.     u32_t *ring, write;
  63.  
  64.    // info->texW[0] = info->texH[0] = info->texW[1] = info->texH[1] = 1;
  65.  
  66.     if (IS_R300_3D || IS_R500_3D)
  67.     {
  68.  
  69.         BEGIN_ACCEL(3);
  70.         OUT_ACCEL_REG(R300_RB3D_DSTCACHE_CTLSTAT, R300_DC_FLUSH_3D | R300_DC_FREE_3D);
  71.         OUT_ACCEL_REG(R300_RB3D_ZCACHE_CTLSTAT, R300_ZC_FLUSH | R300_ZC_FREE);
  72.         OUT_ACCEL_REG(RADEON_WAIT_UNTIL, RADEON_WAIT_2D_IDLECLEAN | RADEON_WAIT_3D_IDLECLEAN);
  73.         FINISH_ACCEL();
  74.  
  75.         if ( IS_R500_3D)
  76.         {
  77.            u32_t gb_pipe_sel = INREG(R400_GB_PIPE_SELECT);
  78.  
  79.            rhdPtr->num_gb_pipes = ((gb_pipe_sel >> 12) & 0x3) + 1;
  80.            RADEONOUTPLL(R500_DYN_SCLK_PWMEM_PIPE, (1 | ((gb_pipe_sel >> 8) & 0xf) << 4));
  81.         }
  82.  
  83.         dbgprintf("Pipes count %d\n", rhdPtr->num_gb_pipes );
  84.  
  85.         gb_tile_config = (R300_ENABLE_TILING | R300_TILE_SIZE_16 | R300_SUBPIXEL_1_16);
  86.  
  87.         switch(rhdPtr->num_gb_pipes) {
  88.         case 2: gb_tile_config |= R300_PIPE_COUNT_R300; break;
  89.         case 3: gb_tile_config |= R300_PIPE_COUNT_R420_3P; break;
  90.         case 4: gb_tile_config |= R300_PIPE_COUNT_R420; break;
  91.         default:
  92.         case 1: gb_tile_config |= R300_PIPE_COUNT_RV350; break;
  93.         }
  94.  
  95.         BEGIN_ACCEL(5);
  96.         OUT_ACCEL_REG(R300_GB_TILE_CONFIG, gb_tile_config);
  97.         OUT_ACCEL_REG(RADEON_WAIT_UNTIL, RADEON_WAIT_2D_IDLECLEAN | RADEON_WAIT_3D_IDLECLEAN);
  98.         OUT_ACCEL_REG(R300_DST_PIPE_CONFIG, R300_PIPE_AUTO_CONFIG);
  99.         OUT_ACCEL_REG(R300_GB_SELECT, 0);
  100.         OUT_ACCEL_REG(R300_GB_ENABLE, 0);
  101.         FINISH_ACCEL();
  102.  
  103.         if (IS_R500_3D) {
  104.             su_reg_dest = ((1 << rhdPtr->num_gb_pipes) - 1);
  105.             BEGIN_ACCEL(2);
  106.             OUT_ACCEL_REG(R500_SU_REG_DEST, su_reg_dest);
  107.             OUT_ACCEL_REG(R500_VAP_INDEX_OFFSET, 0);
  108.             FINISH_ACCEL();
  109.         }
  110.  
  111.         BEGIN_ACCEL(3);
  112.         OUT_ACCEL_REG(R300_RB3D_DSTCACHE_CTLSTAT, R300_DC_FLUSH_3D | R300_DC_FREE_3D);
  113.         OUT_ACCEL_REG(R300_RB3D_ZCACHE_CTLSTAT, R300_ZC_FLUSH | R300_ZC_FREE);
  114.         OUT_ACCEL_REG(RADEON_WAIT_UNTIL, RADEON_WAIT_2D_IDLECLEAN | RADEON_WAIT_3D_IDLECLEAN);
  115.         FINISH_ACCEL();
  116.  
  117.         BEGIN_ACCEL(5);
  118.         OUT_ACCEL_REG(R300_GB_AA_CONFIG, 0);
  119.         OUT_ACCEL_REG(R300_RB3D_DSTCACHE_CTLSTAT, R300_DC_FLUSH_3D | R300_DC_FREE_3D);
  120.         OUT_ACCEL_REG(R300_RB3D_ZCACHE_CTLSTAT, R300_ZC_FLUSH | R300_ZC_FREE);
  121.         OUT_ACCEL_REG(R300_GB_MSPOS0, ((8 << R300_MS_X0_SHIFT) |
  122.                                        (8 << R300_MS_Y0_SHIFT) |
  123.                                        (8 << R300_MS_X1_SHIFT) |
  124.                                        (8 << R300_MS_Y1_SHIFT) |
  125.                                        (8 << R300_MS_X2_SHIFT) |
  126.                                        (8 << R300_MS_Y2_SHIFT) |
  127.                                        (8 << R300_MSBD0_Y_SHIFT) |
  128.                                        (7 << R300_MSBD0_X_SHIFT)));
  129.         OUT_ACCEL_REG(R300_GB_MSPOS1, ((8 << R300_MS_X3_SHIFT) |
  130.                                        (8 << R300_MS_Y3_SHIFT) |
  131.                                        (8 << R300_MS_X4_SHIFT) |
  132.                                        (8 << R300_MS_Y4_SHIFT) |
  133.                                        (8 << R300_MS_X5_SHIFT) |
  134.                                        (8 << R300_MS_Y5_SHIFT) |
  135.                                        (8 << R300_MSBD1_SHIFT)));
  136.         FINISH_ACCEL();
  137.  
  138.         BEGIN_ACCEL(5);
  139.         OUT_ACCEL_REG(R300_GA_ENHANCE, R300_GA_DEADLOCK_CNTL | R300_GA_FASTSYNC_CNTL);
  140.         OUT_ACCEL_REG(R300_GA_POLY_MODE, R300_FRONT_PTYPE_TRIANGE | R300_BACK_PTYPE_TRIANGE);
  141.         OUT_ACCEL_REG(R300_GA_ROUND_MODE, (R300_GEOMETRY_ROUND_NEAREST |
  142.                                            R300_COLOR_ROUND_NEAREST));
  143.         OUT_ACCEL_REG(R300_GA_COLOR_CONTROL, (R300_RGB0_SHADING_GOURAUD |
  144.                                               R300_ALPHA0_SHADING_GOURAUD |
  145.                                               R300_RGB1_SHADING_GOURAUD |
  146.                                               R300_ALPHA1_SHADING_GOURAUD |
  147.                                               R300_RGB2_SHADING_GOURAUD |
  148.                                               R300_ALPHA2_SHADING_GOURAUD |
  149.                                               R300_RGB3_SHADING_GOURAUD |
  150.                                               R300_ALPHA3_SHADING_GOURAUD));
  151.         OUT_ACCEL_REG(R300_GA_OFFSET, 0);
  152.         FINISH_ACCEL();
  153.  
  154.         BEGIN_ACCEL(5);
  155.         OUT_ACCEL_REG(R300_SU_TEX_WRAP, 0);
  156.         OUT_ACCEL_REG(R300_SU_POLY_OFFSET_ENABLE, 0);
  157.         OUT_ACCEL_REG(R300_SU_CULL_MODE, R300_FACE_NEG);
  158.         OUT_ACCEL_REG(R300_SU_DEPTH_SCALE, 0x4b7fffff);
  159.         OUT_ACCEL_REG(R300_SU_DEPTH_OFFSET, 0);
  160.         FINISH_ACCEL();
  161.  
  162.         /* setup the VAP */
  163.         if (rhdPtr->has_tcl)
  164.             vap_cntl = ((5 << R300_PVS_NUM_SLOTS_SHIFT) |
  165.                         (5 << R300_PVS_NUM_CNTLRS_SHIFT) |
  166.                         (9 << R300_VF_MAX_VTX_NUM_SHIFT));
  167.         else
  168.             vap_cntl = ((10 << R300_PVS_NUM_SLOTS_SHIFT) |
  169.                         (5 << R300_PVS_NUM_CNTLRS_SHIFT) |
  170.                         (5 << R300_VF_MAX_VTX_NUM_SHIFT));
  171.  
  172.         if (rhdPtr->ChipSet == RHD_FAMILY_RV515)
  173.             vap_cntl |= (2 << R300_PVS_NUM_FPUS_SHIFT);
  174.         else if ((rhdPtr->ChipSet == RHD_FAMILY_RV530) ||
  175.                  (rhdPtr->ChipSet == RHD_FAMILY_RV560))
  176.             vap_cntl |= (5 << R300_PVS_NUM_FPUS_SHIFT);
  177.         else if (rhdPtr->ChipSet == RHD_FAMILY_R420)
  178.             vap_cntl |= (6 << R300_PVS_NUM_FPUS_SHIFT);
  179.         else if ((rhdPtr->ChipSet == RHD_FAMILY_R520) ||
  180.                  (rhdPtr->ChipSet == RHD_FAMILY_R580) ||
  181.                  (rhdPtr->ChipSet == RHD_FAMILY_RV570))
  182.             vap_cntl |= (8 << R300_PVS_NUM_FPUS_SHIFT);
  183.         else
  184.             vap_cntl |= (4 << R300_PVS_NUM_FPUS_SHIFT);
  185.  
  186.         if (rhdPtr->has_tcl)
  187.             BEGIN_ACCEL(15);
  188.         else
  189.             BEGIN_ACCEL(9);
  190.         OUT_ACCEL_REG(R300_VAP_VTX_STATE_CNTL, 0);
  191.         OUT_ACCEL_REG(R300_VAP_PVS_STATE_FLUSH_REG, 0);
  192.  
  193.         if (rhdPtr->has_tcl)
  194.             OUT_ACCEL_REG(R300_VAP_CNTL_STATUS, 0);
  195.         else
  196.             OUT_ACCEL_REG(R300_VAP_CNTL_STATUS, R300_PVS_BYPASS);
  197.         OUT_ACCEL_REG(R300_VAP_CNTL, vap_cntl);
  198.         OUT_ACCEL_REG(R300_VAP_PVS_STATE_FLUSH_REG, 0);
  199.         OUT_ACCEL_REG(R300_VAP_VTE_CNTL, R300_VTX_XY_FMT | R300_VTX_Z_FMT);
  200.         OUT_ACCEL_REG(R300_VAP_PSC_SGN_NORM_CNTL, 0);
  201.  
  202.         OUT_ACCEL_REG(R300_VAP_PROG_STREAM_CNTL_EXT_0,
  203.                       ((R300_SWIZZLE_SELECT_X << R300_SWIZZLE_SELECT_X_0_SHIFT) |
  204.                        (R300_SWIZZLE_SELECT_Y << R300_SWIZZLE_SELECT_Y_0_SHIFT) |
  205.                        (R300_SWIZZLE_SELECT_Z << R300_SWIZZLE_SELECT_Z_0_SHIFT) |
  206.                        (R300_SWIZZLE_SELECT_W << R300_SWIZZLE_SELECT_W_0_SHIFT) |
  207.                        ((R300_WRITE_ENA_X | R300_WRITE_ENA_Y | R300_WRITE_ENA_Z | R300_WRITE_ENA_W)
  208.                         << R300_WRITE_ENA_0_SHIFT) |
  209.                        (R300_SWIZZLE_SELECT_X << R300_SWIZZLE_SELECT_X_1_SHIFT) |
  210.                        (R300_SWIZZLE_SELECT_Y << R300_SWIZZLE_SELECT_Y_1_SHIFT) |
  211.                        (R300_SWIZZLE_SELECT_Z << R300_SWIZZLE_SELECT_Z_1_SHIFT) |
  212.                        (R300_SWIZZLE_SELECT_W << R300_SWIZZLE_SELECT_W_1_SHIFT) |
  213.                        ((R300_WRITE_ENA_X | R300_WRITE_ENA_Y | R300_WRITE_ENA_Z | R300_WRITE_ENA_W)
  214.                         << R300_WRITE_ENA_1_SHIFT)));
  215.         OUT_ACCEL_REG(R300_VAP_PROG_STREAM_CNTL_EXT_1,
  216.                       ((R300_SWIZZLE_SELECT_X << R300_SWIZZLE_SELECT_X_2_SHIFT) |
  217.                        (R300_SWIZZLE_SELECT_Y << R300_SWIZZLE_SELECT_Y_2_SHIFT) |
  218.                        (R300_SWIZZLE_SELECT_Z << R300_SWIZZLE_SELECT_Z_2_SHIFT) |
  219.                        (R300_SWIZZLE_SELECT_W << R300_SWIZZLE_SELECT_W_2_SHIFT) |
  220.                        ((R300_WRITE_ENA_X | R300_WRITE_ENA_Y | R300_WRITE_ENA_Z | R300_WRITE_ENA_W)
  221.                         << R300_WRITE_ENA_2_SHIFT)));
  222.  
  223.         if (rhdPtr->has_tcl) {
  224.             OUT_ACCEL_REG(R300_VAP_PVS_FLOW_CNTL_OPC, 0);
  225.             OUT_ACCEL_REG(R300_VAP_GB_VERT_CLIP_ADJ, 0x3f800000);
  226.             OUT_ACCEL_REG(R300_VAP_GB_VERT_DISC_ADJ, 0x3f800000);
  227.             OUT_ACCEL_REG(R300_VAP_GB_HORZ_CLIP_ADJ, 0x3f800000);
  228.             OUT_ACCEL_REG(R300_VAP_GB_HORZ_DISC_ADJ, 0x3f800000);
  229.             OUT_ACCEL_REG(R300_VAP_CLIP_CNTL, R300_CLIP_DISABLE);
  230.         }
  231.         FINISH_ACCEL();
  232.  
  233.         /* pre-load the vertex shaders */
  234.         if (rhdPtr->has_tcl) {
  235.             /* exa mask shader program */
  236.             BEGIN_ACCEL(13);
  237.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_INDX_REG, 0);
  238.             /* PVS inst 0 */
  239.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  240.                           (R300_PVS_DST_OPCODE(R300_VE_ADD) |
  241.                            R300_PVS_DST_REG_TYPE(R300_PVS_DST_REG_OUT) |
  242.                            R300_PVS_DST_OFFSET(0) |
  243.                            R300_PVS_DST_WE_X | R300_PVS_DST_WE_Y |
  244.                            R300_PVS_DST_WE_Z | R300_PVS_DST_WE_W));
  245.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  246.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  247.                            R300_PVS_SRC_OFFSET(0) |
  248.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_X) |
  249.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_Y) |
  250.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_Z) |
  251.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_W)));
  252.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  253.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  254.                            R300_PVS_SRC_OFFSET(0) |
  255.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_FORCE_0) |
  256.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_FORCE_0) |
  257.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_FORCE_0) |
  258.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_FORCE_0)));
  259.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  260.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  261.                            R300_PVS_SRC_OFFSET(0) |
  262.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_FORCE_0) |
  263.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_FORCE_0) |
  264.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_FORCE_0) |
  265.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_FORCE_0)));
  266.  
  267.             /* PVS inst 1 */
  268.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  269.                           (R300_PVS_DST_OPCODE(R300_VE_ADD) |
  270.                            R300_PVS_DST_REG_TYPE(R300_PVS_DST_REG_OUT) |
  271.                            R300_PVS_DST_OFFSET(1) |
  272.                            R300_PVS_DST_WE_X | R300_PVS_DST_WE_Y |
  273.                            R300_PVS_DST_WE_Z | R300_PVS_DST_WE_W));
  274.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  275.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  276.                            R300_PVS_SRC_OFFSET(6) |
  277.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_X) |
  278.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_Y) |
  279.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_Z) |
  280.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_W)));
  281.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  282.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  283.                            R300_PVS_SRC_OFFSET(6) |
  284.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_FORCE_0) |
  285.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_FORCE_0) |
  286.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_FORCE_0) |
  287.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_FORCE_0)));
  288.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  289.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  290.                            R300_PVS_SRC_OFFSET(6) |
  291.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_FORCE_0) |
  292.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_FORCE_0) |
  293.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_FORCE_0) |
  294.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_FORCE_0)));
  295.  
  296.             /* PVS inst 2 */
  297.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  298.                           (R300_PVS_DST_OPCODE(R300_VE_ADD) |
  299.                            R300_PVS_DST_REG_TYPE(R300_PVS_DST_REG_OUT) |
  300.                            R300_PVS_DST_OFFSET(2) |
  301.                            R300_PVS_DST_WE_X | R300_PVS_DST_WE_Y |
  302.                            R300_PVS_DST_WE_Z | R300_PVS_DST_WE_W));
  303.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  304.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  305.                            R300_PVS_SRC_OFFSET(7) |
  306.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_X) |
  307.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_Y) |
  308.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_Z) |
  309.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_W)));
  310.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  311.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  312.                            R300_PVS_SRC_OFFSET(7) |
  313.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_FORCE_0) |
  314.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_FORCE_0) |
  315.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_FORCE_0) |
  316.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_FORCE_0)));
  317.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  318.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  319.                            R300_PVS_SRC_OFFSET(7) |
  320.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_FORCE_0) |
  321.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_FORCE_0) |
  322.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_FORCE_0) |
  323.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_FORCE_0)));
  324.             FINISH_ACCEL();
  325.  
  326.             BEGIN_ACCEL(9);
  327.             /* exa no mask instruction */
  328.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_INDX_REG, 3);
  329.             /* PVS inst 0 */
  330.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  331.                           (R300_PVS_DST_OPCODE(R300_VE_ADD) |
  332.                            R300_PVS_DST_REG_TYPE(R300_PVS_DST_REG_OUT) |
  333.                            R300_PVS_DST_OFFSET(0) |
  334.                            R300_PVS_DST_WE_X | R300_PVS_DST_WE_Y |
  335.                            R300_PVS_DST_WE_Z | R300_PVS_DST_WE_W));
  336.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  337.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  338.                            R300_PVS_SRC_OFFSET(0) |
  339.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_X) |
  340.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_Y) |
  341.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_Z) |
  342.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_W)));
  343.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  344.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  345.                            R300_PVS_SRC_OFFSET(0) |
  346.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_FORCE_0) |
  347.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_FORCE_0) |
  348.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_FORCE_0) |
  349.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_FORCE_0)));
  350.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  351.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  352.                            R300_PVS_SRC_OFFSET(0) |
  353.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_FORCE_0) |
  354.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_FORCE_0) |
  355.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_FORCE_0) |
  356.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_FORCE_0)));
  357.  
  358.             /* PVS inst 1 */
  359.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  360.                           (R300_PVS_DST_OPCODE(R300_VE_ADD) |
  361.                            R300_PVS_DST_REG_TYPE(R300_PVS_DST_REG_OUT) |
  362.                            R300_PVS_DST_OFFSET(1) |
  363.                            R300_PVS_DST_WE_X | R300_PVS_DST_WE_Y |
  364.                            R300_PVS_DST_WE_Z | R300_PVS_DST_WE_W));
  365.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  366.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  367.                            R300_PVS_SRC_OFFSET(6) |
  368.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_X) |
  369.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_Y) |
  370.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_Z) |
  371.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_W)));
  372.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  373.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  374.                            R300_PVS_SRC_OFFSET(6) |
  375.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_FORCE_0) |
  376.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_FORCE_0) |
  377.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_FORCE_0) |
  378.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_FORCE_0)));
  379.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  380.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  381.                            R300_PVS_SRC_OFFSET(6) |
  382.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_FORCE_0) |
  383.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_FORCE_0) |
  384.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_FORCE_0) |
  385.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_FORCE_0)));
  386.             FINISH_ACCEL();
  387.  
  388.             /* Xv shader program */
  389.             BEGIN_ACCEL(9);
  390.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_INDX_REG, 5);
  391.  
  392.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  393.                           (R300_PVS_DST_OPCODE(R300_VE_ADD) |
  394.                            R300_PVS_DST_REG_TYPE(R300_PVS_DST_REG_OUT) |
  395.                            R300_PVS_DST_OFFSET(0) |
  396.                            R300_PVS_DST_WE_X | R300_PVS_DST_WE_Y |
  397.                            R300_PVS_DST_WE_Z | R300_PVS_DST_WE_W));
  398.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  399.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  400.                            R300_PVS_SRC_OFFSET(0) |
  401.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_X) |
  402.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_Y) |
  403.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_Z) |
  404.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_W)));
  405.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  406.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  407.                            R300_PVS_SRC_OFFSET(0) |
  408.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_FORCE_0) |
  409.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_FORCE_0) |
  410.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_FORCE_0) |
  411.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_FORCE_0)));
  412.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  413.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  414.                            R300_PVS_SRC_OFFSET(0) |
  415.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_FORCE_0) |
  416.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_FORCE_0) |
  417.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_FORCE_0) |
  418.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_FORCE_0)));
  419.  
  420.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  421.                           (R300_PVS_DST_OPCODE(R300_VE_ADD) |
  422.                            R300_PVS_DST_REG_TYPE(R300_PVS_DST_REG_OUT) |
  423.                            R300_PVS_DST_OFFSET(1) |
  424.                            R300_PVS_DST_WE_X | R300_PVS_DST_WE_Y |
  425.                            R300_PVS_DST_WE_Z | R300_PVS_DST_WE_W));
  426.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  427.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  428.                            R300_PVS_SRC_OFFSET(6) |
  429.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_X) |
  430.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_Y) |
  431.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_Z) |
  432.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_W)));
  433.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  434.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  435.                            R300_PVS_SRC_OFFSET(6) |
  436.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_FORCE_0) |
  437.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_FORCE_0) |
  438.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_FORCE_0) |
  439.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_FORCE_0)));
  440.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  441.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  442.                            R300_PVS_SRC_OFFSET(6) |
  443.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_FORCE_0) |
  444.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_FORCE_0) |
  445.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_FORCE_0) |
  446.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_FORCE_0)));
  447.             FINISH_ACCEL();
  448.         }
  449.  
  450.         /* pre-load the RS instructions */
  451.         BEGIN_ACCEL(4);
  452.         if (IS_R300_3D) {
  453.             /* rasterizer source table
  454.              * R300_RS_TEX_PTR is the offset into the input RS stream
  455.              * 0,1 are tex0
  456.              * 2,3 are tex1
  457.              */
  458.             OUT_ACCEL_REG(R300_RS_IP_0,
  459.                           (R300_RS_TEX_PTR(0) |
  460.                            R300_RS_SEL_S(R300_RS_SEL_C0) |
  461.                            R300_RS_SEL_T(R300_RS_SEL_C1) |
  462.                            R300_RS_SEL_R(R300_RS_SEL_K0) |
  463.                            R300_RS_SEL_Q(R300_RS_SEL_K1)));
  464.             OUT_ACCEL_REG(R300_RS_IP_1,
  465.                           (R300_RS_TEX_PTR(2) |
  466.                            R300_RS_SEL_S(R300_RS_SEL_C0) |
  467.                            R300_RS_SEL_T(R300_RS_SEL_C1) |
  468.                            R300_RS_SEL_R(R300_RS_SEL_K0) |
  469.                            R300_RS_SEL_Q(R300_RS_SEL_K1)));
  470.             /* src tex */
  471.             /* R300_INST_TEX_ID - select the RS source table entry
  472.              * R300_INST_TEX_ADDR - the FS temp register for the texture data
  473.              */
  474.             OUT_ACCEL_REG(R300_RS_INST_0, (R300_INST_TEX_ID(0) |
  475.                                            R300_RS_INST_TEX_CN_WRITE |
  476.                                            R300_INST_TEX_ADDR(0)));
  477.             /* mask tex */
  478.             OUT_ACCEL_REG(R300_RS_INST_1, (R300_INST_TEX_ID(1) |
  479.                                            R300_RS_INST_TEX_CN_WRITE |
  480.                                            R300_INST_TEX_ADDR(1)));
  481.  
  482.         } else {
  483.             /* rasterizer source table
  484.              * R300_RS_TEX_PTR is the offset into the input RS stream
  485.              * 0,1 are tex0
  486.              * 2,3 are tex1
  487.              */
  488.             OUT_ACCEL_REG(R500_RS_IP_0, ((0 << R500_RS_IP_TEX_PTR_S_SHIFT) |
  489.                                          (1 << R500_RS_IP_TEX_PTR_T_SHIFT) |
  490.                                          (R500_RS_IP_PTR_K0 << R500_RS_IP_TEX_PTR_R_SHIFT) |
  491.                                          (R500_RS_IP_PTR_K1 << R500_RS_IP_TEX_PTR_Q_SHIFT)));
  492.  
  493.             OUT_ACCEL_REG(R500_RS_IP_1, ((2 << R500_RS_IP_TEX_PTR_S_SHIFT) |
  494.                                          (3 << R500_RS_IP_TEX_PTR_T_SHIFT) |
  495.                                          (R500_RS_IP_PTR_K0 << R500_RS_IP_TEX_PTR_R_SHIFT) |
  496.                                          (R500_RS_IP_PTR_K1 << R500_RS_IP_TEX_PTR_Q_SHIFT)));
  497.             /* src tex */
  498.             /* R500_RS_INST_TEX_ID_SHIFT - select the RS source table entry
  499.              * R500_RS_INST_TEX_ADDR_SHIFT - the FS temp register for the texture data
  500.              */
  501.             OUT_ACCEL_REG(R500_RS_INST_0, ((0 << R500_RS_INST_TEX_ID_SHIFT) |
  502.                                            R500_RS_INST_TEX_CN_WRITE |
  503.                                            (0 << R500_RS_INST_TEX_ADDR_SHIFT)));
  504.             /* mask tex */
  505.             OUT_ACCEL_REG(R500_RS_INST_1, ((1 << R500_RS_INST_TEX_ID_SHIFT) |
  506.                                            R500_RS_INST_TEX_CN_WRITE |
  507.                                            (1 << R500_RS_INST_TEX_ADDR_SHIFT)));
  508.         }
  509.         FINISH_ACCEL();
  510.  
  511.         /* pre-load FS tex instructions */
  512.         if (IS_R300_3D) {
  513.             BEGIN_ACCEL(2);
  514.             /* tex inst for src texture */
  515.             OUT_ACCEL_REG(R300_US_TEX_INST_0,
  516.                           (R300_TEX_SRC_ADDR(0) |
  517.                            R300_TEX_DST_ADDR(0) |
  518.                            R300_TEX_ID(0) |
  519.                            R300_TEX_INST(R300_TEX_INST_LD)));
  520.  
  521.             /* tex inst for mask texture */
  522.             OUT_ACCEL_REG(R300_US_TEX_INST_1,
  523.                           (R300_TEX_SRC_ADDR(1) |
  524.                            R300_TEX_DST_ADDR(1) |
  525.                            R300_TEX_ID(1) |
  526.                            R300_TEX_INST(R300_TEX_INST_LD)));
  527.             FINISH_ACCEL();
  528.         }
  529.  
  530.         if (IS_R300_3D) {
  531.             BEGIN_ACCEL(9);
  532.             OUT_ACCEL_REG(R300_US_CONFIG, (0 << R300_NLEVEL_SHIFT) | R300_FIRST_TEX);
  533.             OUT_ACCEL_REG(R300_US_PIXSIZE, 1); /* highest temp used */
  534.             OUT_ACCEL_REG(R300_US_CODE_ADDR_0,
  535.                           (R300_ALU_START(0) |
  536.                            R300_ALU_SIZE(0) |
  537.                            R300_TEX_START(0) |
  538.                            R300_TEX_SIZE(0)));
  539.             OUT_ACCEL_REG(R300_US_CODE_ADDR_1,
  540.                           (R300_ALU_START(0) |
  541.                            R300_ALU_SIZE(0) |
  542.                            R300_TEX_START(0) |
  543.                            R300_TEX_SIZE(0)));
  544.             OUT_ACCEL_REG(R300_US_CODE_ADDR_2,
  545.                           (R300_ALU_START(0) |
  546.                            R300_ALU_SIZE(0) |
  547.                            R300_TEX_START(0) |
  548.                            R300_TEX_SIZE(0)));
  549.         } else {
  550.             BEGIN_ACCEL(7);
  551.             OUT_ACCEL_REG(R300_US_CONFIG, R500_ZERO_TIMES_ANYTHING_EQUALS_ZERO);
  552.             OUT_ACCEL_REG(R300_US_PIXSIZE, 1); /* highest temp used */
  553.             OUT_ACCEL_REG(R500_US_FC_CTRL, 0);
  554.         }
  555.         OUT_ACCEL_REG(R300_US_W_FMT, 0);
  556.         OUT_ACCEL_REG(R300_US_OUT_FMT_1, (R300_OUT_FMT_UNUSED |
  557.                                           R300_OUT_FMT_C0_SEL_BLUE |
  558.                                           R300_OUT_FMT_C1_SEL_GREEN |
  559.                                           R300_OUT_FMT_C2_SEL_RED |
  560.                                           R300_OUT_FMT_C3_SEL_ALPHA));
  561.         OUT_ACCEL_REG(R300_US_OUT_FMT_2, (R300_OUT_FMT_UNUSED |
  562.                                           R300_OUT_FMT_C0_SEL_BLUE |
  563.                                           R300_OUT_FMT_C1_SEL_GREEN |
  564.                                           R300_OUT_FMT_C2_SEL_RED |
  565.                                           R300_OUT_FMT_C3_SEL_ALPHA));
  566.         OUT_ACCEL_REG(R300_US_OUT_FMT_3, (R300_OUT_FMT_UNUSED |
  567.                                           R300_OUT_FMT_C0_SEL_BLUE |
  568.                                           R300_OUT_FMT_C1_SEL_GREEN |
  569.                                           R300_OUT_FMT_C2_SEL_RED |
  570.                                           R300_OUT_FMT_C3_SEL_ALPHA));
  571.         FINISH_ACCEL();
  572.  
  573.  
  574.         BEGIN_ACCEL(3);
  575.         OUT_ACCEL_REG(R300_FG_DEPTH_SRC, 0);
  576.         OUT_ACCEL_REG(R300_FG_FOG_BLEND, 0);
  577.         OUT_ACCEL_REG(R300_FG_ALPHA_FUNC, 0);
  578.         FINISH_ACCEL();
  579.  
  580.         BEGIN_ACCEL(13);
  581.         OUT_ACCEL_REG(R300_RB3D_ABLENDCNTL, 0);
  582.         OUT_ACCEL_REG(R300_RB3D_ZSTENCILCNTL, 0);
  583.         OUT_ACCEL_REG(R300_RB3D_ZCACHE_CTLSTAT, R300_ZC_FLUSH | R300_ZC_FREE);
  584.         OUT_ACCEL_REG(R300_RB3D_BW_CNTL, 0);
  585.         OUT_ACCEL_REG(R300_RB3D_ZCNTL, 0);
  586.         OUT_ACCEL_REG(R300_RB3D_ZTOP, 0);
  587.         OUT_ACCEL_REG(R300_RB3D_ROPCNTL, 0);
  588.  
  589.         OUT_ACCEL_REG(R300_RB3D_AARESOLVE_CTL, 0);
  590.         OUT_ACCEL_REG(R300_RB3D_COLOR_CHANNEL_MASK, (R300_BLUE_MASK_EN |
  591.                                                      R300_GREEN_MASK_EN |
  592.                                                      R300_RED_MASK_EN |
  593.                                                      R300_ALPHA_MASK_EN));
  594.         OUT_ACCEL_REG(R300_RB3D_DSTCACHE_CTLSTAT, R300_DC_FLUSH_3D | R300_DC_FREE_3D);
  595.         OUT_ACCEL_REG(R300_RB3D_CCTL, 0);
  596.         OUT_ACCEL_REG(R300_RB3D_DITHER_CTL, 0);
  597.         OUT_ACCEL_REG(R300_RB3D_DSTCACHE_CTLSTAT, R300_DC_FLUSH_3D | R300_DC_FREE_3D);
  598.         FINISH_ACCEL();
  599.  
  600.         BEGIN_ACCEL(7);
  601.         OUT_ACCEL_REG(R300_SC_EDGERULE, 0xA5294A5);
  602.         OUT_ACCEL_REG(R300_SC_SCISSOR0, ((0 << R300_SCISSOR_X_SHIFT) |
  603.                                          (0 << R300_SCISSOR_Y_SHIFT)));
  604.         OUT_ACCEL_REG(R300_SC_SCISSOR1, ((8191 << R300_SCISSOR_X_SHIFT) |
  605.                                          (8191 << R300_SCISSOR_Y_SHIFT)));
  606.  
  607.         if (IS_R300_3D) {
  608.             /* clip has offset 1440 */
  609.             OUT_ACCEL_REG(R300_SC_CLIP_0_A, ((1088 << R300_CLIP_X_SHIFT) |
  610.                                              (1088 << R300_CLIP_Y_SHIFT)));
  611.             OUT_ACCEL_REG(R300_SC_CLIP_0_B, (((1080 + 2920) << R300_CLIP_X_SHIFT) |
  612.                                              ((1080 + 2920) << R300_CLIP_Y_SHIFT)));
  613.         } else {
  614.             OUT_ACCEL_REG(R300_SC_CLIP_0_A, ((0 << R300_CLIP_X_SHIFT) |
  615.                                              (0 << R300_CLIP_Y_SHIFT)));
  616.             OUT_ACCEL_REG(R300_SC_CLIP_0_B, ((4080 << R300_CLIP_X_SHIFT) |
  617.                                              (4080 << R300_CLIP_Y_SHIFT)));
  618.         }
  619.         OUT_ACCEL_REG(R300_SC_CLIP_RULE, 0xAAAA);
  620.         OUT_ACCEL_REG(R300_SC_SCREENDOOR, 0xffffff);
  621.         FINISH_ACCEL();
  622.     } else if ((rhdPtr->ChipSet == RHD_FAMILY_RV250) ||
  623.                (rhdPtr->ChipSet == RHD_FAMILY_RV280) ||
  624.                (rhdPtr->ChipSet == RHD_FAMILY_RS300) ||
  625.                (rhdPtr->ChipSet == RHD_FAMILY_R200)) {
  626.  
  627.         BEGIN_ACCEL(7);
  628.         if (rhdPtr->ChipSet == RHD_FAMILY_RS300) {
  629.             OUT_ACCEL_REG(R200_SE_VAP_CNTL_STATUS, RADEON_TCL_BYPASS);
  630.         } else {
  631.             OUT_ACCEL_REG(R200_SE_VAP_CNTL_STATUS, 0);
  632.         }
  633.         OUT_ACCEL_REG(R200_PP_CNTL_X, 0);
  634.         OUT_ACCEL_REG(R200_PP_TXMULTI_CTL_0, 0);
  635.         OUT_ACCEL_REG(R200_SE_VTX_STATE_CNTL, 0);
  636.         OUT_ACCEL_REG(R200_RE_CNTL, 0x0);
  637.         OUT_ACCEL_REG(R200_SE_VTE_CNTL, 0);
  638.         OUT_ACCEL_REG(R200_SE_VAP_CNTL, R200_VAP_FORCE_W_TO_ONE |
  639.             R200_VAP_VF_MAX_VTX_NUM);
  640.         FINISH_ACCEL();
  641.  
  642.         BEGIN_ACCEL(5);
  643.         OUT_ACCEL_REG(RADEON_RE_TOP_LEFT, 0);
  644.         OUT_ACCEL_REG(RADEON_RE_WIDTH_HEIGHT, 0x07ff07ff);
  645.         OUT_ACCEL_REG(RADEON_AUX_SC_CNTL, 0);
  646.         OUT_ACCEL_REG(RADEON_RB3D_PLANEMASK, 0xffffffff);
  647.         OUT_ACCEL_REG(RADEON_SE_CNTL, (RADEON_DIFFUSE_SHADE_GOURAUD |
  648.                                        RADEON_BFACE_SOLID |
  649.                                        RADEON_FFACE_SOLID |
  650.                                        RADEON_VTX_PIX_CENTER_OGL |
  651.                                        RADEON_ROUND_MODE_ROUND |
  652.                                        RADEON_ROUND_PREC_4TH_PIX));
  653.         FINISH_ACCEL();
  654.     } else {
  655.         BEGIN_ACCEL(2);
  656.         if ((rhdPtr->ChipSet == RHD_FAMILY_RADEON) ||
  657.             (rhdPtr->ChipSet == RHD_FAMILY_RV200))
  658.             OUT_ACCEL_REG(RADEON_SE_CNTL_STATUS, 0);
  659.         else
  660.             OUT_ACCEL_REG(RADEON_SE_CNTL_STATUS, RADEON_TCL_BYPASS);
  661.         OUT_ACCEL_REG(RADEON_SE_COORD_FMT,
  662.             RADEON_VTX_XY_PRE_MULT_1_OVER_W0 |
  663.             RADEON_VTX_ST0_NONPARAMETRIC |
  664.             RADEON_VTX_ST1_NONPARAMETRIC |
  665.             RADEON_TEX1_W_ROUTING_USE_W0);
  666.         FINISH_ACCEL();
  667.  
  668.         BEGIN_ACCEL(5);
  669.         OUT_ACCEL_REG(RADEON_RE_TOP_LEFT, 0);
  670.         OUT_ACCEL_REG(RADEON_RE_WIDTH_HEIGHT, 0x07ff07ff);
  671.         OUT_ACCEL_REG(RADEON_AUX_SC_CNTL, 0);
  672.         OUT_ACCEL_REG(RADEON_RB3D_PLANEMASK, 0xffffffff);
  673.         OUT_ACCEL_REG(RADEON_SE_CNTL, (RADEON_DIFFUSE_SHADE_GOURAUD |
  674.                                        RADEON_BFACE_SOLID |
  675.                                        RADEON_FFACE_SOLID |
  676.                                        RADEON_VTX_PIX_CENTER_OGL |
  677.                                        RADEON_ROUND_MODE_ROUND |
  678.                                        RADEON_ROUND_PREC_4TH_PIX));
  679.         FINISH_ACCEL();
  680.     }
  681.  
  682. }
  683.  
  684. static Bool R300TextureSetup(int w, int h, int unit)
  685. {
  686.     //RINFO_FROM_SCREEN(pPix->drawable.pScreen);
  687.     u32_t txfilter, txformat0, txformat1, txoffset, txpitch;
  688.  //   int w = pPict->pDrawable->width;
  689.  //   int h = pPict->pDrawable->height;
  690.     int i, pixel_shift;
  691.  
  692.     //ACCEL_PREAMBLE();
  693.  
  694.     //TRACE;
  695.  
  696.     //txpitch = exaGetPixmapPitch(pPix);
  697.     txpitch = rhd.displayWidth * 4;
  698.  
  699.    // txoffset = exaGetPixmapOffset(pPix) + info->fbLocation + pScrn->fbOffset;
  700.     txoffset = rhd.FbIntAddress + rhd.FbScanoutStart;
  701.  
  702.     if ((txoffset & 0x1f) != 0)
  703.         dbgprintf("Bad texture offset 0x%x\n", (int)txoffset);
  704.     if ((txpitch & 0x1f) != 0)
  705.         dbgprintf("Bad texture pitch 0x%x\n", (int)txpitch);
  706.  
  707.     /* TXPITCH = pixels (texels) per line - 1 */
  708.     pixel_shift = 32 >> 4;
  709.     txpitch >>= pixel_shift;
  710.     txpitch -= 1;
  711.  
  712.   //  if (RADEONPixmapIsColortiled(pPix))
  713.   //      txoffset |= R300_MACRO_TILE;
  714.  
  715.  //   for (i = 0; i < sizeof(R300TexFormats) / sizeof(R300TexFormats[0]); i++)
  716.  //   {
  717.  //       if (R300TexFormats[i].fmt == pPict->format)
  718.  //           break;
  719.  //   }
  720.  
  721.     //txformat1 = R300TexFormats[i].card_fmt;
  722.     txformat1 = R300_EASY_TX_FORMAT(X, Y, Z, W, W8Z8Y8X8);
  723.  
  724.     txformat0 = ((((w - 1) & 0x7ff) << R300_TXWIDTH_SHIFT) |
  725.                  (((h - 1) & 0x7ff) << R300_TXHEIGHT_SHIFT));
  726.  
  727.     if (IS_R500_3D && ((w - 1) & 0x800))
  728.         txpitch |= R500_TXWIDTH_11;
  729.  
  730.     if (IS_R500_3D && ((h - 1) & 0x800))
  731.         txpitch |= R500_TXHEIGHT_11;
  732.  
  733.     /* Use TXPITCH instead of TXWIDTH for address computations: we could
  734.      * omit this if there is no padding, but there is no apparent advantage
  735.      * in doing so.
  736.      */
  737.     txformat0 |= R300_TXPITCH_EN;
  738.  
  739.   //  info->texW[unit] = w;
  740.   //  info->texH[unit] = h;
  741.  
  742.   //  if (pPict->repeat && !(unit == 0 && need_src_tile_x))
  743.   //    txfilter = R300_TX_CLAMP_S(R300_TX_CLAMP_WRAP);
  744.   //  else
  745.       txfilter = R300_TX_CLAMP_S(R300_TX_CLAMP_CLAMP_GL);
  746.  
  747.   //  if (pPict->repeat && !(unit == 0 && need_src_tile_y))
  748.   //    txfilter |= R300_TX_CLAMP_T(R300_TX_CLAMP_WRAP);
  749.   //  else
  750.       txfilter |= R300_TX_CLAMP_T(R300_TX_CLAMP_CLAMP_GL);
  751.  
  752.     txfilter |= (unit << R300_TX_ID_SHIFT);
  753.  
  754. //    switch (pPict->filter) {
  755. //    case PictFilterNearest:
  756.         txfilter |= (R300_TX_MAG_FILTER_NEAREST | R300_TX_MIN_FILTER_NEAREST);
  757. //        break;
  758. //    case PictFilterBilinear:
  759. //        txfilter |= (R300_TX_MAG_FILTER_LINEAR | R300_TX_MIN_FILTER_LINEAR);
  760. //        break;
  761. //    default:
  762. //        RADEON_FALLBACK(("Bad filter 0x%x\n", pPict->filter));
  763. //    }
  764.  
  765.     {
  766.       u32_t *ring, write;
  767.  
  768.       BEGIN_ACCEL(7);
  769.       OUT_ACCEL_REG(R300_TX_FILTER0_0 + (unit * 4), txfilter);
  770.       OUT_ACCEL_REG(R300_TX_FILTER1_0 + (unit * 4), 0);
  771.       OUT_ACCEL_REG(R300_TX_FORMAT0_0 + (unit * 4), txformat0);
  772.       OUT_ACCEL_REG(R300_TX_FORMAT1_0 + (unit * 4), txformat1);
  773.       OUT_ACCEL_REG(R300_TX_FORMAT2_0 + (unit * 4), txpitch);
  774.       OUT_ACCEL_REG(R300_TX_OFFSET_0 + (unit * 4), txoffset);
  775. //    if (!pPict->repeat)
  776.       OUT_ACCEL_REG(R300_TX_BORDER_COLOR_0 + (unit * 4), 0);
  777.       FINISH_ACCEL();
  778.     }
  779. //    if (pPict->transform != 0) {
  780. //        is_transform[unit] = TRUE;
  781. //        transform[unit] = pPict->transform;
  782. //    } else {
  783. //        is_transform[unit] = FALSE;
  784. //    }
  785.  
  786.     return TRUE;
  787. }
  788.  
  789. static u32_t RADEONGetBlendCntl(int op, u32_t dst_format)
  790. {
  791.     u32_t sblend, dblend;
  792.  
  793.     sblend = RadeonBlendOp[op].blend_cntl & RADEON_SRC_BLEND_MASK;
  794.     dblend = RadeonBlendOp[op].blend_cntl & RADEON_DST_BLEND_MASK;
  795.  
  796.     /* If there's no dst alpha channel, adjust the blend op so that we'll treat
  797.      * it as always 1.
  798.      */
  799.     if (PICT_FORMAT_A(dst_format) == 0 && RadeonBlendOp[op].dst_alpha) {
  800.         if (sblend == RADEON_SRC_BLEND_GL_DST_ALPHA)
  801.             sblend = RADEON_SRC_BLEND_GL_ONE;
  802.         else if (sblend == RADEON_SRC_BLEND_GL_ONE_MINUS_DST_ALPHA)
  803.             sblend = RADEON_SRC_BLEND_GL_ZERO;
  804.     }
  805.  
  806.     return sblend | dblend;
  807. }
  808.  
  809. static Bool R300PrepareComposite(int op, int srcX, int srcY,
  810.                                 int dstX, int dstY,
  811.                                 int w, int h)
  812. {
  813.   //  RINFO_FROM_SCREEN(pDst->drawable.pScreen);
  814.     u32_t dst_format, dst_offset, dst_pitch;
  815.     u32_t txenable, colorpitch;
  816.     u32_t blendcntl;
  817.     int pixel_shift;
  818.     u32_t *ring, write;
  819.  
  820.     //ACCEL_PREAMBLE();
  821.  
  822.     //TRACE;
  823.  
  824.     //if (!info->XInited3D)
  825.     //    RADEONInit3DEngine(pScrn);
  826.  
  827.     //if (!R300GetDestFormat(pDstPicture, &dst_format))
  828.     //    return FALSE;
  829.     dst_format = R300_COLORFORMAT_ARGB8888;
  830.  
  831.     pixel_shift = 32 >> 4;
  832.  
  833.     //dst_offset = exaGetPixmapOffset(pDst) + info->fbLocation + pScrn->fbOffset;
  834.     dst_offset = rhd.FbIntAddress + rhd.FbScanoutStart;
  835.  
  836.     //dst_pitch = exaGetPixmapPitch(pDst);
  837.     dst_pitch = rhd.displayWidth * 4;
  838.     colorpitch = dst_pitch >> pixel_shift;
  839.  
  840.   //  if (RADEONPixmapIsColortiled(pDst))
  841.   //      colorpitch |= R300_COLORTILE;
  842.  
  843.     colorpitch |= dst_format;
  844.  
  845.     if ((dst_offset & 0x0f) != 0)
  846.         dbgprintf("Bad destination offset 0x%x\n", (int)dst_offset);
  847.     if (((dst_pitch >> pixel_shift) & 0x7) != 0)
  848.         dbgprintf("Bad destination pitch 0x%x\n", (int)dst_pitch);
  849.  
  850.   //  if (!RADEONSetupSourceTile(pSrcPicture, pSrc, TRUE, FALSE))
  851.   //      return FALSE;
  852.  
  853.     if (!R300TextureSetup(w, h, 0))
  854.         return FALSE;
  855.  
  856.     txenable = R300_TEX_0_ENABLE;
  857.  
  858.   //  RADEON_SWITCH_TO_3D();
  859.  
  860.     /* setup the VAP */
  861.     BEGIN_ACCEL(7);
  862.  
  863.     /* These registers define the number, type, and location of data submitted
  864.      * to the PVS unit of GA input (when PVS is disabled)
  865.      * DST_VEC_LOC is the slot in the PVS input vector memory when PVS/TCL is
  866.      * enabled.  This memory provides the imputs to the vertex shader program
  867.      * and ordering is not important.  When PVS/TCL is disabled, this field maps
  868.      * directly to the GA input memory and the order is signifigant.  In
  869.      * PVS_BYPASS mode the order is as follows:
  870.      * Position
  871.      * Point Size
  872.      * Color 0-3
  873.      * Textures 0-7
  874.      * Fog
  875.      */
  876.  
  877.      OUT_ACCEL_REG(R300_VAP_PROG_STREAM_CNTL_0,
  878.                    ((R300_DATA_TYPE_FLOAT_2 << R300_DATA_TYPE_0_SHIFT) |
  879.                     (0 << R300_SKIP_DWORDS_0_SHIFT) |
  880.                     (0 << R300_DST_VEC_LOC_0_SHIFT) |
  881.                      R300_SIGNED_0 |
  882.                     (R300_DATA_TYPE_FLOAT_2 << R300_DATA_TYPE_1_SHIFT) |
  883.                     (0 << R300_SKIP_DWORDS_1_SHIFT) |
  884.                     (6 << R300_DST_VEC_LOC_1_SHIFT) |
  885.                      R300_LAST_VEC_1 |
  886.                      R300_SIGNED_1));
  887.  
  888.     /* load the vertex shader
  889.      * We pre-load vertex programs in RADEONInit3DEngine():
  890.      * - exa no mask
  891.      * - exa mask
  892.      * - Xv
  893.      * Here we select the offset of the vertex program we want to use
  894.      */
  895.             OUT_ACCEL_REG(R300_VAP_PVS_CODE_CNTL_0,
  896.                           ((3 << R300_PVS_FIRST_INST_SHIFT) |
  897.                            (4 << R300_PVS_XYZW_VALID_INST_SHIFT) |
  898.                            (4 << R300_PVS_LAST_INST_SHIFT)));
  899.             OUT_ACCEL_REG(R300_VAP_PVS_CODE_CNTL_1,
  900.                           (4 << R300_PVS_LAST_VTX_SRC_INST_SHIFT));
  901.  
  902.     /* Position and one or two sets of 2 texture coordinates */
  903.     OUT_ACCEL_REG(R300_VAP_OUT_VTX_FMT_0, R300_VTX_POS_PRESENT);
  904.     OUT_ACCEL_REG(R300_VAP_OUT_VTX_FMT_1, (2 << R300_TEX_0_COMP_CNT_SHIFT));
  905.  
  906.     OUT_ACCEL_REG(R300_TX_INVALTAGS, 0x0);
  907.     OUT_ACCEL_REG(R300_TX_ENABLE, txenable);
  908.     FINISH_ACCEL();
  909.  
  910.     /* setup pixel shader */
  911.     if (IS_R300_3D) {
  912.     } else {
  913.         u32_t output_fmt;
  914.         u32_t src_color, src_alpha;
  915.         u32_t mask_color, mask_alpha;
  916.  
  917.         if (PICT_FORMAT_RGB(PICT_a8r8g8b8) == 0)
  918.             src_color = (R500_ALU_RGB_R_SWIZ_A_0 |
  919.                          R500_ALU_RGB_G_SWIZ_A_0 |
  920.                          R500_ALU_RGB_B_SWIZ_A_0);
  921.         else
  922.             src_color = (R500_ALU_RGB_R_SWIZ_A_R |
  923.                          R500_ALU_RGB_G_SWIZ_A_G |
  924.                          R500_ALU_RGB_B_SWIZ_A_B);
  925.  
  926.         if (PICT_FORMAT_A(PICT_a8r8g8b8) == 0)
  927.             src_alpha = R500_ALPHA_SWIZ_A_1;
  928.         else
  929.             src_alpha = R500_ALPHA_SWIZ_A_A;
  930.  
  931.         mask_color = (R500_ALU_RGB_R_SWIZ_B_1 |
  932.                       R500_ALU_RGB_G_SWIZ_B_1 |
  933.                       R500_ALU_RGB_B_SWIZ_B_1);
  934.         mask_alpha = R500_ALPHA_SWIZ_B_1;
  935.  
  936.         /* shader output swizzling */
  937.         output_fmt = (R300_OUT_FMT_C4_8         |
  938.                       R300_OUT_FMT_C0_SEL_BLUE  |
  939.                       R300_OUT_FMT_C1_SEL_GREEN |
  940.                       R300_OUT_FMT_C2_SEL_RED   |
  941.                       R300_OUT_FMT_C3_SEL_ALPHA);
  942.  
  943.         BEGIN_ACCEL(6);
  944.         OUT_ACCEL_REG(R300_RS_COUNT,
  945.                      ((2 << R300_RS_COUNT_IT_COUNT_SHIFT) |
  946.                        R300_RS_COUNT_HIRES_EN));
  947.  
  948.         OUT_ACCEL_REG(R300_RS_INST_COUNT, R300_INST_COUNT_RS(0) | R300_TX_OFFSET_RS(6));
  949.  
  950.         OUT_ACCEL_REG(R500_US_CODE_ADDR, (R500_US_CODE_START_ADDR(0) |
  951.                                           R500_US_CODE_END_ADDR(1)));
  952.         OUT_ACCEL_REG(R500_US_CODE_RANGE, (R500_US_CODE_RANGE_ADDR(0) |
  953.                                            R500_US_CODE_RANGE_SIZE(1)));
  954.         OUT_ACCEL_REG(R500_US_CODE_OFFSET, 0);
  955.  
  956.         OUT_ACCEL_REG(R300_US_OUT_FMT_0, output_fmt);
  957.         FINISH_ACCEL();
  958.  
  959.         BEGIN_ACCEL(13);
  960.         OUT_ACCEL_REG(R500_GA_US_VECTOR_INDEX, 0);
  961.             /* tex inst for src texture */
  962.         OUT_ACCEL_REG(R500_GA_US_VECTOR_DATA, (R500_INST_TYPE_TEX     |
  963.                                                R500_INST_TEX_SEM_WAIT |
  964.                                                R500_INST_RGB_WMASK_R  |
  965.                                                R500_INST_RGB_WMASK_G  |
  966.                                                R500_INST_RGB_WMASK_B  |
  967.                                                R500_INST_ALPHA_WMASK  |
  968.                                                R500_INST_RGB_CLAMP |
  969.                                                R500_INST_ALPHA_CLAMP));
  970.  
  971.        OUT_ACCEL_REG(R500_GA_US_VECTOR_DATA, (R500_TEX_ID(0) |
  972.                                                    R500_TEX_INST_LD |
  973.                                                    R500_TEX_SEM_ACQUIRE |
  974.                                                    R500_TEX_IGNORE_UNCOVERED));
  975.  
  976.             OUT_ACCEL_REG(R500_GA_US_VECTOR_DATA, (R500_TEX_SRC_ADDR(0) |
  977.                                                    R500_TEX_SRC_S_SWIZ_R |
  978.                                                    R500_TEX_SRC_T_SWIZ_G |
  979.                                                    R500_TEX_DST_ADDR(0) |
  980.                                                    R500_TEX_DST_R_SWIZ_R |
  981.                                                    R500_TEX_DST_G_SWIZ_G |
  982.                                                    R500_TEX_DST_B_SWIZ_B |
  983.                                                    R500_TEX_DST_A_SWIZ_A));
  984.             OUT_ACCEL_REG(R500_GA_US_VECTOR_DATA, (R500_DX_ADDR(0) |
  985.                                                    R500_DX_S_SWIZ_R |
  986.                                                    R500_DX_T_SWIZ_R |
  987.                                                    R500_DX_R_SWIZ_R |
  988.                                                    R500_DX_Q_SWIZ_R |
  989.                                                    R500_DY_ADDR(0) |
  990.                                                    R500_DY_S_SWIZ_R |
  991.                                                    R500_DY_T_SWIZ_R |
  992.                                                    R500_DY_R_SWIZ_R |
  993.                                                    R500_DY_Q_SWIZ_R));
  994.             OUT_ACCEL_REG(R500_GA_US_VECTOR_DATA, 0x00000000);
  995.             OUT_ACCEL_REG(R500_GA_US_VECTOR_DATA, 0x00000000);
  996.  
  997.         /* ALU inst */
  998.         /* *_OMASK* - output component write mask */
  999.         OUT_ACCEL_REG(R500_GA_US_VECTOR_DATA, (R500_INST_TYPE_OUT |
  1000.                                                R500_INST_TEX_SEM_WAIT |
  1001.                                                R500_INST_LAST |
  1002.                                                R500_INST_RGB_OMASK_R |
  1003.                                                R500_INST_RGB_OMASK_G |
  1004.                                                R500_INST_RGB_OMASK_B |
  1005.                                                R500_INST_ALPHA_OMASK |
  1006.                                                R500_INST_RGB_CLAMP |
  1007.                                                R500_INST_ALPHA_CLAMP));
  1008.         /* ALU inst
  1009.          * temp addresses for texture inputs
  1010.          * RGB_ADDR0 is src tex (temp 0)
  1011.          * RGB_ADDR1 is mask tex (temp 1)
  1012.          */
  1013.         OUT_ACCEL_REG(R500_GA_US_VECTOR_DATA, (R500_RGB_ADDR0(0) |
  1014.                                                R500_RGB_ADDR1(1) |
  1015.                                                R500_RGB_ADDR2(0)));
  1016.         /* ALU inst
  1017.          * temp addresses for texture inputs
  1018.          * ALPHA_ADDR0 is src tex (temp 0)
  1019.          * ALPHA_ADDR1 is mask tex (temp 1)
  1020.          */
  1021.         OUT_ACCEL_REG(R500_GA_US_VECTOR_DATA, (R500_ALPHA_ADDR0(0) |
  1022.                                                R500_ALPHA_ADDR1(1) |
  1023.                                                R500_ALPHA_ADDR2(0)));
  1024.  
  1025.         /* R500_ALU_RGB_TARGET - RGB render target */
  1026.         OUT_ACCEL_REG(R500_GA_US_VECTOR_DATA, (R500_ALU_RGB_SEL_A_SRC0 |
  1027.                                                src_color |
  1028.                                                R500_ALU_RGB_SEL_B_SRC1 |
  1029.                                                mask_color |
  1030.                                                R500_ALU_RGB_TARGET(0)));
  1031.  
  1032.         /* R500_ALPHA_RGB_TARGET - alpha render target */
  1033.         OUT_ACCEL_REG(R500_GA_US_VECTOR_DATA, (R500_ALPHA_OP_MAD |
  1034.                                                R500_ALPHA_ADDRD(0) |
  1035.                                                R500_ALPHA_SEL_A_SRC0 |
  1036.                                                src_alpha |
  1037.                                                R500_ALPHA_SEL_B_SRC1 |
  1038.                                                mask_alpha |
  1039.                                                R500_ALPHA_TARGET(0)));
  1040.  
  1041.         OUT_ACCEL_REG(R500_GA_US_VECTOR_DATA, (R500_ALU_RGBA_OP_MAD |
  1042.                                                R500_ALU_RGBA_ADDRD(0) |
  1043.                                                R500_ALU_RGBA_R_SWIZ_0 |
  1044.                                                R500_ALU_RGBA_G_SWIZ_0 |
  1045.                                                R500_ALU_RGBA_B_SWIZ_0 |
  1046.                                                R500_ALU_RGBA_A_SWIZ_0));
  1047.         FINISH_ACCEL();
  1048.     }
  1049.  
  1050.     BEGIN_ACCEL(3);
  1051.  
  1052.     OUT_ACCEL_REG(R300_RB3D_COLOROFFSET0, dst_offset);
  1053.     OUT_ACCEL_REG(R300_RB3D_COLORPITCH0, colorpitch);
  1054.  
  1055.     blendcntl = RADEONGetBlendCntl(op, PICT_a8r8g8b8);
  1056.     OUT_ACCEL_REG(R300_RB3D_BLENDCNTL, blendcntl | R300_ALPHA_BLEND_ENABLE | R300_READ_ENABLE);
  1057.  
  1058.     FINISH_ACCEL();
  1059.  
  1060.     return TRUE;
  1061. }
  1062.  
  1063.  
  1064.  
  1065.  
  1066.  
  1067.  
  1068. #define VTX_COUNT 4
  1069.  
  1070. static __inline__ u32_t F_TO_DW(float val)
  1071. {
  1072.     union {
  1073.         float f;
  1074.         u32_t l;
  1075.     } tmp;
  1076.     tmp.f = val;
  1077.     return tmp.l;
  1078. }
  1079.  
  1080. #define OUT_RING_F(x) OUT_RING(F_TO_DW(x))
  1081.  
  1082. #define VTX_OUT(_dstX, _dstY, _srcX, _srcY)     \
  1083. do {                                                            \
  1084.     OUT_RING_F(_dstX);                                          \
  1085.     OUT_RING_F(_dstY);                                          \
  1086.     OUT_RING_F(_srcX);                                          \
  1087.     OUT_RING_F(_srcY);                                          \
  1088. } while (0)
  1089.  
  1090.  
  1091.  
  1092. static void RadeonCompositeTile(int srcX, int srcY,
  1093.                                 int dstX, int dstY,
  1094.                                 int w, int h)
  1095. {
  1096.   //  RINFO_FROM_SCREEN(pDst->drawable.pScreen);
  1097.     int vtx_count;
  1098.     xPointFixed srcTopLeft, srcTopRight, srcBottomLeft, srcBottomRight;
  1099.     xPointFixed maskTopLeft, maskTopRight, maskBottomLeft, maskBottomRight;
  1100.  
  1101.     u32_t *ring, write;
  1102.  
  1103.  
  1104.  //   ACCEL_PREAMBLE();
  1105.  
  1106.  //   ENTER_DRAW(0);
  1107.  
  1108.     /* ErrorF("RadeonComposite (%d,%d) (%d,%d) (%d,%d) (%d,%d)\n",
  1109.        srcX, srcY, maskX, maskY,dstX, dstY, w, h); */
  1110.  
  1111.     srcTopLeft.x     = IntToxFixed(srcX);
  1112.     srcTopLeft.y     = IntToxFixed(srcY);
  1113.     srcTopRight.x    = IntToxFixed(srcX + w);
  1114.     srcTopRight.y    = IntToxFixed(srcY);
  1115.     srcBottomLeft.x  = IntToxFixed(srcX);
  1116.     srcBottomLeft.y  = IntToxFixed(srcY + h);
  1117.     srcBottomRight.x = IntToxFixed(srcX + w);
  1118.     srcBottomRight.y = IntToxFixed(srcY + h);
  1119.  
  1120. /*
  1121.     if (is_transform[0]) {
  1122.         transformPoint(transform[0], &srcTopLeft);
  1123.         transformPoint(transform[0], &srcTopRight);
  1124.         transformPoint(transform[0], &srcBottomLeft);
  1125.         transformPoint(transform[0], &srcBottomRight);
  1126.     }
  1127.     if (is_transform[1]) {
  1128.         transformPoint(transform[1], &maskTopLeft);
  1129.         transformPoint(transform[1], &maskTopRight);
  1130.         transformPoint(transform[1], &maskBottomLeft);
  1131.         transformPoint(transform[1], &maskBottomRight);
  1132.     }
  1133. */
  1134.     vtx_count = VTX_COUNT;
  1135.  
  1136.     BEGIN_ACCEL(1);
  1137.     OUT_ACCEL_REG(R300_VAP_VTX_SIZE, vtx_count);
  1138.     FINISH_ACCEL();
  1139.  
  1140.     BEGIN_RING(4 * vtx_count + 4);
  1141.  
  1142.       OUT_RING(CP_PACKET3(R200_CP_PACKET3_3D_DRAW_IMMD_2,
  1143.                         4 * vtx_count));
  1144.       OUT_RING(RADEON_CP_VC_CNTL_PRIM_TYPE_TRI_FAN |
  1145.               RADEON_CP_VC_CNTL_PRIM_WALK_RING |
  1146.               (4 << RADEON_CP_VC_CNTL_NUM_SHIFT));
  1147.  
  1148.  
  1149.       VTX_OUT((float)dstX, (float)dstY,
  1150.               xFixedToFloat(srcTopLeft.x) / w,      // info->texW[0],
  1151.               xFixedToFloat(srcTopLeft.y) / h);     // info->texH[0]);
  1152.  
  1153.       VTX_OUT((float)dstX, (float)(dstY + h),
  1154.               xFixedToFloat(srcBottomLeft.x) / w,   // info->texW[0],
  1155.               xFixedToFloat(srcBottomLeft.y) / h);  // info->texH[0]);
  1156.  
  1157.       VTX_OUT((float)(dstX + w), (float)(dstY + h),
  1158.               xFixedToFloat(srcBottomRight.x) / w,  // info->texW[0],
  1159.               xFixedToFloat(srcBottomRight.y) / h); // info->texH[0]);
  1160.  
  1161.       VTX_OUT((float)(dstX + w), (float)dstY,
  1162.               xFixedToFloat(srcTopRight.x) / w,     // info->texW[0],
  1163.               xFixedToFloat(srcTopRight.y) / h);    // info->texH[0]);
  1164.  
  1165.           /* flushing is pipelined, free/finish is not */
  1166.       OUT_ACCEL_REG(R300_RB3D_DSTCACHE_CTLSTAT, R300_DC_FLUSH_3D);
  1167.  
  1168.  //     OUT_ACCEL_REG(RADEON_WAIT_UNTIL, RADEON_WAIT_3D_IDLECLEAN);
  1169.  
  1170.     COMMIT_RING();
  1171.  
  1172.  //   LEAVE_DRAW(0);
  1173. }
  1174. #undef VTX_OUT
  1175. #undef VTX_OUT_MASK
  1176.  
  1177. #if 0
  1178.  
  1179. int RadeonComposite( blit_t *blit)
  1180. {
  1181.     int tileSrcY, tileMaskY, tileDstY;
  1182.     int remainingHeight;
  1183.  
  1184.     R300PrepareComposite(3, blit->src_x, blit->src_y,
  1185.                              blit->dst_x, blit->dst_y,
  1186.                              blit->w, blit->h);
  1187.  
  1188. //    if (!need_src_tile_x && !need_src_tile_y) {
  1189.         RadeonCompositeTile( blit->src_x, blit->src_y,
  1190.                              blit->dst_x, blit->dst_y,
  1191.                              blit->w, blit->h);
  1192.         return 0;
  1193.   //  }
  1194.  
  1195.     /* Tiling logic borrowed from exaFillRegionTiled */
  1196.  
  1197. #if 0
  1198.     modulus(srcY, src_tile_height, tileSrcY);
  1199.     tileMaskY = maskY;
  1200.     tileDstY = dstY;
  1201.  
  1202.     remainingHeight = height;
  1203.     while (remainingHeight > 0) {
  1204.         int remainingWidth = width;
  1205.         int tileSrcX, tileMaskX, tileDstX;
  1206.         int h = src_tile_height - tileSrcY;
  1207.  
  1208.         if (h > remainingHeight)
  1209.             h = remainingHeight;
  1210.         remainingHeight -= h;
  1211.  
  1212.         modulus(srcX, src_tile_width, tileSrcX);
  1213.         tileMaskX = maskX;
  1214.         tileDstX = dstX;
  1215.  
  1216.         while (remainingWidth > 0) {
  1217.             int w = src_tile_width - tileSrcX;
  1218.             if (w > remainingWidth)
  1219.                 w = remainingWidth;
  1220.             remainingWidth -= w;
  1221.  
  1222.             FUNC_NAME(RadeonCompositeTile)(pDst,
  1223.                                            tileSrcX, tileSrcY,
  1224.                                            tileMaskX, tileMaskY,
  1225.                                            tileDstX, tileDstY,
  1226.                                            w, h);
  1227.  
  1228.             tileSrcX = 0;
  1229.             tileMaskX += w;
  1230.             tileDstX += w;
  1231.         }
  1232.         tileSrcY = 0;
  1233.         tileMaskY += h;
  1234.         tileDstY += h;
  1235.     }
  1236. #endif
  1237. }
  1238.  
  1239. #endif
  1240.