Subversion Repositories Kolibri OS

Rev

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

  1.  
  2.  
  3. #define BEGIN_ACCEL(n)          BEGIN_RING(2*(n))
  4. //#define FINISH_ACCEL()          ADVANCE_RING()
  5. #define FINISH_ACCEL()          COMMIT_RING()
  6.  
  7. #define OUT_ACCEL_REG(reg, val) OUT_RING_REG(reg, val)
  8.  
  9. #define RADEON_SWITCH_TO_3D()                                           \
  10. do {                                                                    \
  11.         u32_t wait_until = 0;                        \
  12.         BEGIN_ACCEL(1);                                                 \
  13.         wait_until |= RADEON_WAIT_HOST_IDLECLEAN | RADEON_WAIT_3D_IDLECLEAN;        \
  14.         OUT_ACCEL_REG(RADEON_WAIT_UNTIL, wait_until);                   \
  15.         FINISH_ACCEL();                                                 \
  16. } while (0);
  17.  
  18.  
  19. struct blendinfo {
  20.     Bool dst_alpha;
  21.     Bool src_alpha;
  22.     u32_t blend_cntl;
  23. };
  24.  
  25. static struct blendinfo RadeonBlendOp[] = {
  26.     /* 0 - Clear */
  27.     {0, 0, RADEON_SRC_BLEND_GL_ZERO           | RADEON_DST_BLEND_GL_ZERO},
  28.     /* 1 - Src */
  29.     {0, 0, RADEON_SRC_BLEND_GL_ONE            | RADEON_DST_BLEND_GL_ZERO},
  30.     /* 2 - Dst */
  31.     {0, 0, RADEON_SRC_BLEND_GL_ZERO           | RADEON_DST_BLEND_GL_ONE},
  32.     /* 3 - Over */
  33.     {0, 1, RADEON_SRC_BLEND_GL_ONE            | RADEON_DST_BLEND_GL_ONE_MINUS_SRC_ALPHA},
  34.     /* 4 - OverReverse */
  35.     {1, 0, RADEON_SRC_BLEND_GL_ONE_MINUS_DST_ALPHA | RADEON_DST_BLEND_GL_ONE},
  36.     /* 5 - In */
  37.     {1, 0, RADEON_SRC_BLEND_GL_DST_ALPHA     | RADEON_DST_BLEND_GL_ZERO},
  38.     /* 6 - InReverse */
  39.     {0, 1, RADEON_SRC_BLEND_GL_ZERO           | RADEON_DST_BLEND_GL_SRC_ALPHA},
  40.     /* 7 - Out */
  41.     {1, 0, RADEON_SRC_BLEND_GL_ONE_MINUS_DST_ALPHA | RADEON_DST_BLEND_GL_ZERO},
  42.     /* 8 - OutReverse */
  43.     {0, 1, RADEON_SRC_BLEND_GL_ZERO           | RADEON_DST_BLEND_GL_ONE_MINUS_SRC_ALPHA},
  44.     /* 9 - Atop */
  45.     {1, 1, RADEON_SRC_BLEND_GL_DST_ALPHA     | RADEON_DST_BLEND_GL_ONE_MINUS_SRC_ALPHA},
  46.     /* 10- AtopReverse */
  47.     {1, 1, RADEON_SRC_BLEND_GL_ONE_MINUS_DST_ALPHA | RADEON_DST_BLEND_GL_SRC_ALPHA},
  48.     /* 11 - Xor */
  49.     {1, 1, RADEON_SRC_BLEND_GL_ONE_MINUS_DST_ALPHA | RADEON_DST_BLEND_GL_ONE_MINUS_SRC_ALPHA},
  50.     /* 12 - Add */
  51.     {0, 0, RADEON_SRC_BLEND_GL_ONE            | RADEON_DST_BLEND_GL_ONE},
  52. };
  53.  
  54.  
  55. static void Init3DEngine(RHDPtr rhdPtr)
  56. {
  57.    // RADEONInfoPtr  info       = RADEONPTR(pScrn);
  58.     u32_t gb_tile_config, su_reg_dest, vap_cntl;
  59.    // ACCEL_PREAMBLE();
  60.  
  61.     u32_t *ring, write;
  62.  
  63.    // info->texW[0] = info->texH[0] = info->texW[1] = info->texH[1] = 1;
  64.  
  65.     if (IS_R300_3D || IS_R500_3D)
  66.     {
  67.  
  68.         BEGIN_ACCEL(3);
  69.         OUT_ACCEL_REG(R300_RB3D_DSTCACHE_CTLSTAT, R300_DC_FLUSH_3D | R300_DC_FREE_3D);
  70.         OUT_ACCEL_REG(R300_RB3D_ZCACHE_CTLSTAT, R300_ZC_FLUSH | R300_ZC_FREE);
  71.         OUT_ACCEL_REG(RADEON_WAIT_UNTIL, RADEON_WAIT_2D_IDLECLEAN | RADEON_WAIT_3D_IDLECLEAN);
  72.         FINISH_ACCEL();
  73.  
  74.         if ( IS_R500_3D)
  75.         {
  76.            u32_t gb_pipe_sel = INREG(R400_GB_PIPE_SELECT);
  77.  
  78.            rhdPtr->num_gb_pipes = ((gb_pipe_sel >> 12) & 0x3) + 1;
  79.            RADEONOUTPLL(R500_DYN_SCLK_PWMEM_PIPE, (1 | ((gb_pipe_sel >> 8) & 0xf) << 4));
  80.         }
  81.  
  82.         dbgprintf("Pipes count %d\n", rhdPtr->num_gb_pipes );
  83.  
  84.         gb_tile_config = (R300_ENABLE_TILING | R300_TILE_SIZE_16 | R300_SUBPIXEL_1_16);
  85.  
  86.         switch(rhdPtr->num_gb_pipes) {
  87.         case 2: gb_tile_config |= R300_PIPE_COUNT_R300; break;
  88.         case 3: gb_tile_config |= R300_PIPE_COUNT_R420_3P; break;
  89.         case 4: gb_tile_config |= R300_PIPE_COUNT_R420; break;
  90.         default:
  91.         case 1: gb_tile_config |= R300_PIPE_COUNT_RV350; break;
  92.         }
  93.  
  94.         BEGIN_ACCEL(5);
  95.         OUT_ACCEL_REG(R300_GB_TILE_CONFIG, gb_tile_config);
  96.         OUT_ACCEL_REG(RADEON_WAIT_UNTIL, RADEON_WAIT_2D_IDLECLEAN | RADEON_WAIT_3D_IDLECLEAN);
  97.         OUT_ACCEL_REG(R300_DST_PIPE_CONFIG, R300_PIPE_AUTO_CONFIG);
  98.         OUT_ACCEL_REG(R300_GB_SELECT, 0);
  99.         OUT_ACCEL_REG(R300_GB_ENABLE, 0);
  100.         FINISH_ACCEL();
  101.  
  102.         if (IS_R500_3D) {
  103.             su_reg_dest = ((1 << rhdPtr->num_gb_pipes) - 1);
  104.             BEGIN_ACCEL(2);
  105.             OUT_ACCEL_REG(R500_SU_REG_DEST, su_reg_dest);
  106.             OUT_ACCEL_REG(R500_VAP_INDEX_OFFSET, 0);
  107.             FINISH_ACCEL();
  108.         }
  109.  
  110.         BEGIN_ACCEL(3);
  111.         OUT_ACCEL_REG(R300_RB3D_DSTCACHE_CTLSTAT, R300_DC_FLUSH_3D | R300_DC_FREE_3D);
  112.         OUT_ACCEL_REG(R300_RB3D_ZCACHE_CTLSTAT, R300_ZC_FLUSH | R300_ZC_FREE);
  113.         OUT_ACCEL_REG(RADEON_WAIT_UNTIL, RADEON_WAIT_2D_IDLECLEAN | RADEON_WAIT_3D_IDLECLEAN);
  114.         FINISH_ACCEL();
  115.  
  116.         BEGIN_ACCEL(5);
  117.         OUT_ACCEL_REG(R300_GB_AA_CONFIG, 0);
  118.         OUT_ACCEL_REG(R300_RB3D_DSTCACHE_CTLSTAT, R300_DC_FLUSH_3D | R300_DC_FREE_3D);
  119.         OUT_ACCEL_REG(R300_RB3D_ZCACHE_CTLSTAT, R300_ZC_FLUSH | R300_ZC_FREE);
  120.         OUT_ACCEL_REG(R300_GB_MSPOS0, ((8 << R300_MS_X0_SHIFT) |
  121.                                        (8 << R300_MS_Y0_SHIFT) |
  122.                                        (8 << R300_MS_X1_SHIFT) |
  123.                                        (8 << R300_MS_Y1_SHIFT) |
  124.                                        (8 << R300_MS_X2_SHIFT) |
  125.                                        (8 << R300_MS_Y2_SHIFT) |
  126.                                        (8 << R300_MSBD0_Y_SHIFT) |
  127.                                        (7 << R300_MSBD0_X_SHIFT)));
  128.         OUT_ACCEL_REG(R300_GB_MSPOS1, ((8 << R300_MS_X3_SHIFT) |
  129.                                        (8 << R300_MS_Y3_SHIFT) |
  130.                                        (8 << R300_MS_X4_SHIFT) |
  131.                                        (8 << R300_MS_Y4_SHIFT) |
  132.                                        (8 << R300_MS_X5_SHIFT) |
  133.                                        (8 << R300_MS_Y5_SHIFT) |
  134.                                        (8 << R300_MSBD1_SHIFT)));
  135.         FINISH_ACCEL();
  136.  
  137.         BEGIN_ACCEL(5);
  138.         OUT_ACCEL_REG(R300_GA_ENHANCE, R300_GA_DEADLOCK_CNTL | R300_GA_FASTSYNC_CNTL);
  139.         OUT_ACCEL_REG(R300_GA_POLY_MODE, R300_FRONT_PTYPE_TRIANGE | R300_BACK_PTYPE_TRIANGE);
  140.         OUT_ACCEL_REG(R300_GA_ROUND_MODE, (R300_GEOMETRY_ROUND_NEAREST |
  141.                                            R300_COLOR_ROUND_NEAREST));
  142.         OUT_ACCEL_REG(R300_GA_COLOR_CONTROL, (R300_RGB0_SHADING_GOURAUD |
  143.                                               R300_ALPHA0_SHADING_GOURAUD |
  144.                                               R300_RGB1_SHADING_GOURAUD |
  145.                                               R300_ALPHA1_SHADING_GOURAUD |
  146.                                               R300_RGB2_SHADING_GOURAUD |
  147.                                               R300_ALPHA2_SHADING_GOURAUD |
  148.                                               R300_RGB3_SHADING_GOURAUD |
  149.                                               R300_ALPHA3_SHADING_GOURAUD));
  150.         OUT_ACCEL_REG(R300_GA_OFFSET, 0);
  151.         FINISH_ACCEL();
  152.  
  153.         BEGIN_ACCEL(5);
  154.         OUT_ACCEL_REG(R300_SU_TEX_WRAP, 0);
  155.         OUT_ACCEL_REG(R300_SU_POLY_OFFSET_ENABLE, 0);
  156.         OUT_ACCEL_REG(R300_SU_CULL_MODE, R300_FACE_NEG);
  157.         OUT_ACCEL_REG(R300_SU_DEPTH_SCALE, 0x4b7fffff);
  158.         OUT_ACCEL_REG(R300_SU_DEPTH_OFFSET, 0);
  159.         FINISH_ACCEL();
  160.  
  161.         /* setup the VAP */
  162.         if (rhdPtr->has_tcl)
  163.             vap_cntl = ((5 << R300_PVS_NUM_SLOTS_SHIFT) |
  164.                         (5 << R300_PVS_NUM_CNTLRS_SHIFT) |
  165.                         (9 << R300_VF_MAX_VTX_NUM_SHIFT));
  166.         else
  167.             vap_cntl = ((10 << R300_PVS_NUM_SLOTS_SHIFT) |
  168.                         (5 << R300_PVS_NUM_CNTLRS_SHIFT) |
  169.                         (5 << R300_VF_MAX_VTX_NUM_SHIFT));
  170.  
  171.         if (rhdPtr->ChipSet == RHD_FAMILY_RV515)
  172.             vap_cntl |= (2 << R300_PVS_NUM_FPUS_SHIFT);
  173.         else if ((rhdPtr->ChipSet == RHD_FAMILY_RV530) ||
  174.                  (rhdPtr->ChipSet == RHD_FAMILY_RV560))
  175.             vap_cntl |= (5 << R300_PVS_NUM_FPUS_SHIFT);
  176.         else if (rhdPtr->ChipSet == RHD_FAMILY_R420)
  177.             vap_cntl |= (6 << R300_PVS_NUM_FPUS_SHIFT);
  178.         else if ((rhdPtr->ChipSet == RHD_FAMILY_R520) ||
  179.                  (rhdPtr->ChipSet == RHD_FAMILY_R580) ||
  180.                  (rhdPtr->ChipSet == RHD_FAMILY_RV570))
  181.             vap_cntl |= (8 << R300_PVS_NUM_FPUS_SHIFT);
  182.         else
  183.             vap_cntl |= (4 << R300_PVS_NUM_FPUS_SHIFT);
  184.  
  185.         if (rhdPtr->has_tcl)
  186.             BEGIN_ACCEL(15);
  187.         else
  188.             BEGIN_ACCEL(9);
  189.         OUT_ACCEL_REG(R300_VAP_VTX_STATE_CNTL, 0);
  190.         OUT_ACCEL_REG(R300_VAP_PVS_STATE_FLUSH_REG, 0);
  191.  
  192.         if (rhdPtr->has_tcl)
  193.             OUT_ACCEL_REG(R300_VAP_CNTL_STATUS, 0);
  194.         else
  195.             OUT_ACCEL_REG(R300_VAP_CNTL_STATUS, R300_PVS_BYPASS);
  196.         OUT_ACCEL_REG(R300_VAP_CNTL, vap_cntl);
  197.         OUT_ACCEL_REG(R300_VAP_PVS_STATE_FLUSH_REG, 0);
  198.         OUT_ACCEL_REG(R300_VAP_VTE_CNTL, R300_VTX_XY_FMT | R300_VTX_Z_FMT);
  199.         OUT_ACCEL_REG(R300_VAP_PSC_SGN_NORM_CNTL, 0);
  200.  
  201.         OUT_ACCEL_REG(R300_VAP_PROG_STREAM_CNTL_EXT_0,
  202.                       ((R300_SWIZZLE_SELECT_X << R300_SWIZZLE_SELECT_X_0_SHIFT) |
  203.                        (R300_SWIZZLE_SELECT_Y << R300_SWIZZLE_SELECT_Y_0_SHIFT) |
  204.                        (R300_SWIZZLE_SELECT_Z << R300_SWIZZLE_SELECT_Z_0_SHIFT) |
  205.                        (R300_SWIZZLE_SELECT_W << R300_SWIZZLE_SELECT_W_0_SHIFT) |
  206.                        ((R300_WRITE_ENA_X | R300_WRITE_ENA_Y | R300_WRITE_ENA_Z | R300_WRITE_ENA_W)
  207.                         << R300_WRITE_ENA_0_SHIFT) |
  208.                        (R300_SWIZZLE_SELECT_X << R300_SWIZZLE_SELECT_X_1_SHIFT) |
  209.                        (R300_SWIZZLE_SELECT_Y << R300_SWIZZLE_SELECT_Y_1_SHIFT) |
  210.                        (R300_SWIZZLE_SELECT_Z << R300_SWIZZLE_SELECT_Z_1_SHIFT) |
  211.                        (R300_SWIZZLE_SELECT_W << R300_SWIZZLE_SELECT_W_1_SHIFT) |
  212.                        ((R300_WRITE_ENA_X | R300_WRITE_ENA_Y | R300_WRITE_ENA_Z | R300_WRITE_ENA_W)
  213.                         << R300_WRITE_ENA_1_SHIFT)));
  214.         OUT_ACCEL_REG(R300_VAP_PROG_STREAM_CNTL_EXT_1,
  215.                       ((R300_SWIZZLE_SELECT_X << R300_SWIZZLE_SELECT_X_2_SHIFT) |
  216.                        (R300_SWIZZLE_SELECT_Y << R300_SWIZZLE_SELECT_Y_2_SHIFT) |
  217.                        (R300_SWIZZLE_SELECT_Z << R300_SWIZZLE_SELECT_Z_2_SHIFT) |
  218.                        (R300_SWIZZLE_SELECT_W << R300_SWIZZLE_SELECT_W_2_SHIFT) |
  219.                        ((R300_WRITE_ENA_X | R300_WRITE_ENA_Y | R300_WRITE_ENA_Z | R300_WRITE_ENA_W)
  220.                         << R300_WRITE_ENA_2_SHIFT)));
  221.  
  222.         if (rhdPtr->has_tcl) {
  223.             OUT_ACCEL_REG(R300_VAP_PVS_FLOW_CNTL_OPC, 0);
  224.             OUT_ACCEL_REG(R300_VAP_GB_VERT_CLIP_ADJ, 0x3f800000);
  225.             OUT_ACCEL_REG(R300_VAP_GB_VERT_DISC_ADJ, 0x3f800000);
  226.             OUT_ACCEL_REG(R300_VAP_GB_HORZ_CLIP_ADJ, 0x3f800000);
  227.             OUT_ACCEL_REG(R300_VAP_GB_HORZ_DISC_ADJ, 0x3f800000);
  228.             OUT_ACCEL_REG(R300_VAP_CLIP_CNTL, R300_CLIP_DISABLE);
  229.         }
  230.         FINISH_ACCEL();
  231.  
  232.         /* pre-load the vertex shaders */
  233.         if (rhdPtr->has_tcl) {
  234.             /* exa mask shader program */
  235.             BEGIN_ACCEL(13);
  236.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_INDX_REG, 0);
  237.             /* PVS inst 0 */
  238.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  239.                           (R300_PVS_DST_OPCODE(R300_VE_ADD) |
  240.                            R300_PVS_DST_REG_TYPE(R300_PVS_DST_REG_OUT) |
  241.                            R300_PVS_DST_OFFSET(0) |
  242.                            R300_PVS_DST_WE_X | R300_PVS_DST_WE_Y |
  243.                            R300_PVS_DST_WE_Z | R300_PVS_DST_WE_W));
  244.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  245.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  246.                            R300_PVS_SRC_OFFSET(0) |
  247.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_X) |
  248.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_Y) |
  249.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_Z) |
  250.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_W)));
  251.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  252.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  253.                            R300_PVS_SRC_OFFSET(0) |
  254.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_FORCE_0) |
  255.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_FORCE_0) |
  256.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_FORCE_0) |
  257.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_FORCE_0)));
  258.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  259.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  260.                            R300_PVS_SRC_OFFSET(0) |
  261.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_FORCE_0) |
  262.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_FORCE_0) |
  263.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_FORCE_0) |
  264.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_FORCE_0)));
  265.  
  266.             /* PVS inst 1 */
  267.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  268.                           (R300_PVS_DST_OPCODE(R300_VE_ADD) |
  269.                            R300_PVS_DST_REG_TYPE(R300_PVS_DST_REG_OUT) |
  270.                            R300_PVS_DST_OFFSET(1) |
  271.                            R300_PVS_DST_WE_X | R300_PVS_DST_WE_Y |
  272.                            R300_PVS_DST_WE_Z | R300_PVS_DST_WE_W));
  273.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  274.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  275.                            R300_PVS_SRC_OFFSET(6) |
  276.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_X) |
  277.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_Y) |
  278.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_Z) |
  279.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_W)));
  280.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  281.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  282.                            R300_PVS_SRC_OFFSET(6) |
  283.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_FORCE_0) |
  284.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_FORCE_0) |
  285.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_FORCE_0) |
  286.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_FORCE_0)));
  287.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  288.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  289.                            R300_PVS_SRC_OFFSET(6) |
  290.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_FORCE_0) |
  291.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_FORCE_0) |
  292.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_FORCE_0) |
  293.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_FORCE_0)));
  294.  
  295.             /* PVS inst 2 */
  296.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  297.                           (R300_PVS_DST_OPCODE(R300_VE_ADD) |
  298.                            R300_PVS_DST_REG_TYPE(R300_PVS_DST_REG_OUT) |
  299.                            R300_PVS_DST_OFFSET(2) |
  300.                            R300_PVS_DST_WE_X | R300_PVS_DST_WE_Y |
  301.                            R300_PVS_DST_WE_Z | R300_PVS_DST_WE_W));
  302.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  303.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  304.                            R300_PVS_SRC_OFFSET(7) |
  305.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_X) |
  306.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_Y) |
  307.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_Z) |
  308.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_W)));
  309.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  310.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  311.                            R300_PVS_SRC_OFFSET(7) |
  312.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_FORCE_0) |
  313.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_FORCE_0) |
  314.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_FORCE_0) |
  315.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_FORCE_0)));
  316.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  317.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  318.                            R300_PVS_SRC_OFFSET(7) |
  319.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_FORCE_0) |
  320.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_FORCE_0) |
  321.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_FORCE_0) |
  322.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_FORCE_0)));
  323.             FINISH_ACCEL();
  324.  
  325.             BEGIN_ACCEL(9);
  326.             /* exa no mask instruction */
  327.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_INDX_REG, 3);
  328.             /* PVS inst 0 */
  329.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  330.                           (R300_PVS_DST_OPCODE(R300_VE_ADD) |
  331.                            R300_PVS_DST_REG_TYPE(R300_PVS_DST_REG_OUT) |
  332.                            R300_PVS_DST_OFFSET(0) |
  333.                            R300_PVS_DST_WE_X | R300_PVS_DST_WE_Y |
  334.                            R300_PVS_DST_WE_Z | R300_PVS_DST_WE_W));
  335.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  336.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  337.                            R300_PVS_SRC_OFFSET(0) |
  338.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_X) |
  339.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_Y) |
  340.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_Z) |
  341.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_W)));
  342.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  343.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  344.                            R300_PVS_SRC_OFFSET(0) |
  345.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_FORCE_0) |
  346.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_FORCE_0) |
  347.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_FORCE_0) |
  348.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_FORCE_0)));
  349.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  350.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  351.                            R300_PVS_SRC_OFFSET(0) |
  352.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_FORCE_0) |
  353.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_FORCE_0) |
  354.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_FORCE_0) |
  355.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_FORCE_0)));
  356.  
  357.             /* PVS inst 1 */
  358.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  359.                           (R300_PVS_DST_OPCODE(R300_VE_ADD) |
  360.                            R300_PVS_DST_REG_TYPE(R300_PVS_DST_REG_OUT) |
  361.                            R300_PVS_DST_OFFSET(1) |
  362.                            R300_PVS_DST_WE_X | R300_PVS_DST_WE_Y |
  363.                            R300_PVS_DST_WE_Z | R300_PVS_DST_WE_W));
  364.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  365.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  366.                            R300_PVS_SRC_OFFSET(6) |
  367.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_X) |
  368.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_Y) |
  369.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_Z) |
  370.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_W)));
  371.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  372.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  373.                            R300_PVS_SRC_OFFSET(6) |
  374.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_FORCE_0) |
  375.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_FORCE_0) |
  376.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_FORCE_0) |
  377.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_FORCE_0)));
  378.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  379.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  380.                            R300_PVS_SRC_OFFSET(6) |
  381.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_FORCE_0) |
  382.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_FORCE_0) |
  383.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_FORCE_0) |
  384.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_FORCE_0)));
  385.             FINISH_ACCEL();
  386.  
  387.             /* Xv shader program */
  388.             BEGIN_ACCEL(9);
  389.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_INDX_REG, 5);
  390.  
  391.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  392.                           (R300_PVS_DST_OPCODE(R300_VE_ADD) |
  393.                            R300_PVS_DST_REG_TYPE(R300_PVS_DST_REG_OUT) |
  394.                            R300_PVS_DST_OFFSET(0) |
  395.                            R300_PVS_DST_WE_X | R300_PVS_DST_WE_Y |
  396.                            R300_PVS_DST_WE_Z | R300_PVS_DST_WE_W));
  397.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  398.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  399.                            R300_PVS_SRC_OFFSET(0) |
  400.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_X) |
  401.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_Y) |
  402.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_Z) |
  403.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_W)));
  404.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  405.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  406.                            R300_PVS_SRC_OFFSET(0) |
  407.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_FORCE_0) |
  408.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_FORCE_0) |
  409.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_FORCE_0) |
  410.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_FORCE_0)));
  411.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  412.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  413.                            R300_PVS_SRC_OFFSET(0) |
  414.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_FORCE_0) |
  415.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_FORCE_0) |
  416.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_FORCE_0) |
  417.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_FORCE_0)));
  418.  
  419.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  420.                           (R300_PVS_DST_OPCODE(R300_VE_ADD) |
  421.                            R300_PVS_DST_REG_TYPE(R300_PVS_DST_REG_OUT) |
  422.                            R300_PVS_DST_OFFSET(1) |
  423.                            R300_PVS_DST_WE_X | R300_PVS_DST_WE_Y |
  424.                            R300_PVS_DST_WE_Z | R300_PVS_DST_WE_W));
  425.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  426.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  427.                            R300_PVS_SRC_OFFSET(6) |
  428.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_X) |
  429.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_Y) |
  430.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_Z) |
  431.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_W)));
  432.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  433.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  434.                            R300_PVS_SRC_OFFSET(6) |
  435.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_FORCE_0) |
  436.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_FORCE_0) |
  437.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_FORCE_0) |
  438.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_FORCE_0)));
  439.             OUT_ACCEL_REG(R300_VAP_PVS_VECTOR_DATA_REG,
  440.                           (R300_PVS_SRC_REG_TYPE(R300_PVS_SRC_REG_INPUT) |
  441.                            R300_PVS_SRC_OFFSET(6) |
  442.                            R300_PVS_SRC_SWIZZLE_X(R300_PVS_SRC_SELECT_FORCE_0) |
  443.                            R300_PVS_SRC_SWIZZLE_Y(R300_PVS_SRC_SELECT_FORCE_0) |
  444.                            R300_PVS_SRC_SWIZZLE_Z(R300_PVS_SRC_SELECT_FORCE_0) |
  445.                            R300_PVS_SRC_SWIZZLE_W(R300_PVS_SRC_SELECT_FORCE_0)));
  446.             FINISH_ACCEL();
  447.         }
  448.  
  449.         /* pre-load the RS instructions */
  450.         BEGIN_ACCEL(4);
  451.         if (IS_R300_3D) {
  452.             /* rasterizer source table
  453.              * R300_RS_TEX_PTR is the offset into the input RS stream
  454.              * 0,1 are tex0
  455.              * 2,3 are tex1
  456.              */
  457.             OUT_ACCEL_REG(R300_RS_IP_0,
  458.                           (R300_RS_TEX_PTR(0) |
  459.                            R300_RS_SEL_S(R300_RS_SEL_C0) |
  460.                            R300_RS_SEL_T(R300_RS_SEL_C1) |
  461.                            R300_RS_SEL_R(R300_RS_SEL_K0) |
  462.                            R300_RS_SEL_Q(R300_RS_SEL_K1)));
  463.             OUT_ACCEL_REG(R300_RS_IP_1,
  464.                           (R300_RS_TEX_PTR(2) |
  465.                            R300_RS_SEL_S(R300_RS_SEL_C0) |
  466.                            R300_RS_SEL_T(R300_RS_SEL_C1) |
  467.                            R300_RS_SEL_R(R300_RS_SEL_K0) |
  468.                            R300_RS_SEL_Q(R300_RS_SEL_K1)));
  469.             /* src tex */
  470.             /* R300_INST_TEX_ID - select the RS source table entry
  471.              * R300_INST_TEX_ADDR - the FS temp register for the texture data
  472.              */
  473.             OUT_ACCEL_REG(R300_RS_INST_0, (R300_INST_TEX_ID(0) |
  474.                                            R300_RS_INST_TEX_CN_WRITE |
  475.                                            R300_INST_TEX_ADDR(0)));
  476.             /* mask tex */
  477.             OUT_ACCEL_REG(R300_RS_INST_1, (R300_INST_TEX_ID(1) |
  478.                                            R300_RS_INST_TEX_CN_WRITE |
  479.                                            R300_INST_TEX_ADDR(1)));
  480.  
  481.         } else {
  482.             /* rasterizer source table
  483.              * R300_RS_TEX_PTR is the offset into the input RS stream
  484.              * 0,1 are tex0
  485.              * 2,3 are tex1
  486.              */
  487.             OUT_ACCEL_REG(R500_RS_IP_0, ((0 << R500_RS_IP_TEX_PTR_S_SHIFT) |
  488.                                          (1 << R500_RS_IP_TEX_PTR_T_SHIFT) |
  489.                                          (R500_RS_IP_PTR_K0 << R500_RS_IP_TEX_PTR_R_SHIFT) |
  490.                                          (R500_RS_IP_PTR_K1 << R500_RS_IP_TEX_PTR_Q_SHIFT)));
  491.  
  492.             OUT_ACCEL_REG(R500_RS_IP_1, ((2 << R500_RS_IP_TEX_PTR_S_SHIFT) |
  493.                                          (3 << R500_RS_IP_TEX_PTR_T_SHIFT) |
  494.                                          (R500_RS_IP_PTR_K0 << R500_RS_IP_TEX_PTR_R_SHIFT) |
  495.                                          (R500_RS_IP_PTR_K1 << R500_RS_IP_TEX_PTR_Q_SHIFT)));
  496.             /* src tex */
  497.             /* R500_RS_INST_TEX_ID_SHIFT - select the RS source table entry
  498.              * R500_RS_INST_TEX_ADDR_SHIFT - the FS temp register for the texture data
  499.              */
  500.             OUT_ACCEL_REG(R500_RS_INST_0, ((0 << R500_RS_INST_TEX_ID_SHIFT) |
  501.                                            R500_RS_INST_TEX_CN_WRITE |
  502.                                            (0 << R500_RS_INST_TEX_ADDR_SHIFT)));
  503.             /* mask tex */
  504.             OUT_ACCEL_REG(R500_RS_INST_1, ((1 << R500_RS_INST_TEX_ID_SHIFT) |
  505.                                            R500_RS_INST_TEX_CN_WRITE |
  506.                                            (1 << R500_RS_INST_TEX_ADDR_SHIFT)));
  507.         }
  508.         FINISH_ACCEL();
  509.  
  510.         /* pre-load FS tex instructions */
  511.         if (IS_R300_3D) {
  512.             BEGIN_ACCEL(2);
  513.             /* tex inst for src texture */
  514.             OUT_ACCEL_REG(R300_US_TEX_INST_0,
  515.                           (R300_TEX_SRC_ADDR(0) |
  516.                            R300_TEX_DST_ADDR(0) |
  517.                            R300_TEX_ID(0) |
  518.                            R300_TEX_INST(R300_TEX_INST_LD)));
  519.  
  520.             /* tex inst for mask texture */
  521.             OUT_ACCEL_REG(R300_US_TEX_INST_1,
  522.                           (R300_TEX_SRC_ADDR(1) |
  523.                            R300_TEX_DST_ADDR(1) |
  524.                            R300_TEX_ID(1) |
  525.                            R300_TEX_INST(R300_TEX_INST_LD)));
  526.             FINISH_ACCEL();
  527.         }
  528.  
  529.         if (IS_R300_3D) {
  530.             BEGIN_ACCEL(9);
  531.             OUT_ACCEL_REG(R300_US_CONFIG, (0 << R300_NLEVEL_SHIFT) | R300_FIRST_TEX);
  532.             OUT_ACCEL_REG(R300_US_PIXSIZE, 1); /* highest temp used */
  533.             OUT_ACCEL_REG(R300_US_CODE_ADDR_0,
  534.                           (R300_ALU_START(0) |
  535.                            R300_ALU_SIZE(0) |
  536.                            R300_TEX_START(0) |
  537.                            R300_TEX_SIZE(0)));
  538.             OUT_ACCEL_REG(R300_US_CODE_ADDR_1,
  539.                           (R300_ALU_START(0) |
  540.                            R300_ALU_SIZE(0) |
  541.                            R300_TEX_START(0) |
  542.                            R300_TEX_SIZE(0)));
  543.             OUT_ACCEL_REG(R300_US_CODE_ADDR_2,
  544.                           (R300_ALU_START(0) |
  545.                            R300_ALU_SIZE(0) |
  546.                            R300_TEX_START(0) |
  547.                            R300_TEX_SIZE(0)));
  548.         } else {
  549.             BEGIN_ACCEL(7);
  550.             OUT_ACCEL_REG(R300_US_CONFIG, R500_ZERO_TIMES_ANYTHING_EQUALS_ZERO);
  551.             OUT_ACCEL_REG(R300_US_PIXSIZE, 1); /* highest temp used */
  552.             OUT_ACCEL_REG(R500_US_FC_CTRL, 0);
  553.         }
  554.         OUT_ACCEL_REG(R300_US_W_FMT, 0);
  555.         OUT_ACCEL_REG(R300_US_OUT_FMT_1, (R300_OUT_FMT_UNUSED |
  556.                                           R300_OUT_FMT_C0_SEL_BLUE |
  557.                                           R300_OUT_FMT_C1_SEL_GREEN |
  558.                                           R300_OUT_FMT_C2_SEL_RED |
  559.                                           R300_OUT_FMT_C3_SEL_ALPHA));
  560.         OUT_ACCEL_REG(R300_US_OUT_FMT_2, (R300_OUT_FMT_UNUSED |
  561.                                           R300_OUT_FMT_C0_SEL_BLUE |
  562.                                           R300_OUT_FMT_C1_SEL_GREEN |
  563.                                           R300_OUT_FMT_C2_SEL_RED |
  564.                                           R300_OUT_FMT_C3_SEL_ALPHA));
  565.         OUT_ACCEL_REG(R300_US_OUT_FMT_3, (R300_OUT_FMT_UNUSED |
  566.                                           R300_OUT_FMT_C0_SEL_BLUE |
  567.                                           R300_OUT_FMT_C1_SEL_GREEN |
  568.                                           R300_OUT_FMT_C2_SEL_RED |
  569.                                           R300_OUT_FMT_C3_SEL_ALPHA));
  570.         FINISH_ACCEL();
  571.  
  572.  
  573.         BEGIN_ACCEL(3);
  574.         OUT_ACCEL_REG(R300_FG_DEPTH_SRC, 0);
  575.         OUT_ACCEL_REG(R300_FG_FOG_BLEND, 0);
  576.         OUT_ACCEL_REG(R300_FG_ALPHA_FUNC, 0);
  577.         FINISH_ACCEL();
  578.  
  579.         BEGIN_ACCEL(13);
  580.         OUT_ACCEL_REG(R300_RB3D_ABLENDCNTL, 0);
  581.         OUT_ACCEL_REG(R300_RB3D_ZSTENCILCNTL, 0);
  582.         OUT_ACCEL_REG(R300_RB3D_ZCACHE_CTLSTAT, R300_ZC_FLUSH | R300_ZC_FREE);
  583.         OUT_ACCEL_REG(R300_RB3D_BW_CNTL, 0);
  584.         OUT_ACCEL_REG(R300_RB3D_ZCNTL, 0);
  585.         OUT_ACCEL_REG(R300_RB3D_ZTOP, 0);
  586.         OUT_ACCEL_REG(R300_RB3D_ROPCNTL, 0);
  587.  
  588.         OUT_ACCEL_REG(R300_RB3D_AARESOLVE_CTL, 0);
  589.         OUT_ACCEL_REG(R300_RB3D_COLOR_CHANNEL_MASK, (R300_BLUE_MASK_EN |
  590.                                                      R300_GREEN_MASK_EN |
  591.                                                      R300_RED_MASK_EN |
  592.                                                      R300_ALPHA_MASK_EN));
  593.         OUT_ACCEL_REG(R300_RB3D_DSTCACHE_CTLSTAT, R300_DC_FLUSH_3D | R300_DC_FREE_3D);
  594.         OUT_ACCEL_REG(R300_RB3D_CCTL, 0);
  595.         OUT_ACCEL_REG(R300_RB3D_DITHER_CTL, 0);
  596.         OUT_ACCEL_REG(R300_RB3D_DSTCACHE_CTLSTAT, R300_DC_FLUSH_3D | R300_DC_FREE_3D);
  597.         FINISH_ACCEL();
  598.  
  599.         BEGIN_ACCEL(7);
  600.         OUT_ACCEL_REG(R300_SC_EDGERULE, 0xA5294A5);
  601.         OUT_ACCEL_REG(R300_SC_SCISSOR0, ((0 << R300_SCISSOR_X_SHIFT) |
  602.                                          (0 << R300_SCISSOR_Y_SHIFT)));
  603.         OUT_ACCEL_REG(R300_SC_SCISSOR1, ((8191 << R300_SCISSOR_X_SHIFT) |
  604.                                          (8191 << R300_SCISSOR_Y_SHIFT)));
  605.  
  606.         if (IS_R300_3D) {
  607.             /* clip has offset 1440 */
  608.             OUT_ACCEL_REG(R300_SC_CLIP_0_A, ((1088 << R300_CLIP_X_SHIFT) |
  609.                                              (1088 << R300_CLIP_Y_SHIFT)));
  610.             OUT_ACCEL_REG(R300_SC_CLIP_0_B, (((1080 + 2920) << R300_CLIP_X_SHIFT) |
  611.                                              ((1080 + 2920) << R300_CLIP_Y_SHIFT)));
  612.         } else {
  613.             OUT_ACCEL_REG(R300_SC_CLIP_0_A, ((0 << R300_CLIP_X_SHIFT) |
  614.                                              (0 << R300_CLIP_Y_SHIFT)));
  615.             OUT_ACCEL_REG(R300_SC_CLIP_0_B, ((4080 << R300_CLIP_X_SHIFT) |
  616.                                              (4080 << R300_CLIP_Y_SHIFT)));
  617.         }
  618.         OUT_ACCEL_REG(R300_SC_CLIP_RULE, 0xAAAA);
  619.         OUT_ACCEL_REG(R300_SC_SCREENDOOR, 0xffffff);
  620.         FINISH_ACCEL();
  621.     } else if ((rhdPtr->ChipSet == RHD_FAMILY_RV250) ||
  622.                (rhdPtr->ChipSet == RHD_FAMILY_RV280) ||
  623.                (rhdPtr->ChipSet == RHD_FAMILY_RS300) ||
  624.                (rhdPtr->ChipSet == RHD_FAMILY_R200)) {
  625.  
  626.         BEGIN_ACCEL(7);
  627.         if (rhdPtr->ChipSet == RHD_FAMILY_RS300) {
  628.             OUT_ACCEL_REG(R200_SE_VAP_CNTL_STATUS, RADEON_TCL_BYPASS);
  629.         } else {
  630.             OUT_ACCEL_REG(R200_SE_VAP_CNTL_STATUS, 0);
  631.         }
  632.         OUT_ACCEL_REG(R200_PP_CNTL_X, 0);
  633.         OUT_ACCEL_REG(R200_PP_TXMULTI_CTL_0, 0);
  634.         OUT_ACCEL_REG(R200_SE_VTX_STATE_CNTL, 0);
  635.         OUT_ACCEL_REG(R200_RE_CNTL, 0x0);
  636.         OUT_ACCEL_REG(R200_SE_VTE_CNTL, 0);
  637.         OUT_ACCEL_REG(R200_SE_VAP_CNTL, R200_VAP_FORCE_W_TO_ONE |
  638.             R200_VAP_VF_MAX_VTX_NUM);
  639.         FINISH_ACCEL();
  640.  
  641.         BEGIN_ACCEL(5);
  642.         OUT_ACCEL_REG(RADEON_RE_TOP_LEFT, 0);
  643.         OUT_ACCEL_REG(RADEON_RE_WIDTH_HEIGHT, 0x07ff07ff);
  644.         OUT_ACCEL_REG(RADEON_AUX_SC_CNTL, 0);
  645.         OUT_ACCEL_REG(RADEON_RB3D_PLANEMASK, 0xffffffff);
  646.         OUT_ACCEL_REG(RADEON_SE_CNTL, (RADEON_DIFFUSE_SHADE_GOURAUD |
  647.                                        RADEON_BFACE_SOLID |
  648.                                        RADEON_FFACE_SOLID |
  649.                                        RADEON_VTX_PIX_CENTER_OGL |
  650.                                        RADEON_ROUND_MODE_ROUND |
  651.                                        RADEON_ROUND_PREC_4TH_PIX));
  652.         FINISH_ACCEL();
  653.     } else {
  654.         BEGIN_ACCEL(2);
  655.         if ((rhdPtr->ChipSet == RHD_FAMILY_RADEON) ||
  656.             (rhdPtr->ChipSet == RHD_FAMILY_RV200))
  657.             OUT_ACCEL_REG(RADEON_SE_CNTL_STATUS, 0);
  658.         else
  659.             OUT_ACCEL_REG(RADEON_SE_CNTL_STATUS, RADEON_TCL_BYPASS);
  660.         OUT_ACCEL_REG(RADEON_SE_COORD_FMT,
  661.             RADEON_VTX_XY_PRE_MULT_1_OVER_W0 |
  662.             RADEON_VTX_ST0_NONPARAMETRIC |
  663.             RADEON_VTX_ST1_NONPARAMETRIC |
  664.             RADEON_TEX1_W_ROUTING_USE_W0);
  665.         FINISH_ACCEL();
  666.  
  667.         BEGIN_ACCEL(5);
  668.         OUT_ACCEL_REG(RADEON_RE_TOP_LEFT, 0);
  669.         OUT_ACCEL_REG(RADEON_RE_WIDTH_HEIGHT, 0x07ff07ff);
  670.         OUT_ACCEL_REG(RADEON_AUX_SC_CNTL, 0);
  671.         OUT_ACCEL_REG(RADEON_RB3D_PLANEMASK, 0xffffffff);
  672.         OUT_ACCEL_REG(RADEON_SE_CNTL, (RADEON_DIFFUSE_SHADE_GOURAUD |
  673.                                        RADEON_BFACE_SOLID |
  674.                                        RADEON_FFACE_SOLID |
  675.                                        RADEON_VTX_PIX_CENTER_OGL |
  676.                                        RADEON_ROUND_MODE_ROUND |
  677.                                        RADEON_ROUND_PREC_4TH_PIX));
  678.         FINISH_ACCEL();
  679.     }
  680.  
  681. }
  682.  
  683. static Bool R300TextureSetup(int w, int h, int unit)
  684. {
  685.     //RINFO_FROM_SCREEN(pPix->drawable.pScreen);
  686.     u32_t txfilter, txformat0, txformat1, txoffset, txpitch;
  687.  //   int w = pPict->pDrawable->width;
  688.  //   int h = pPict->pDrawable->height;
  689.     int i, pixel_shift;
  690.  
  691.     //ACCEL_PREAMBLE();
  692.  
  693.     //TRACE;
  694.  
  695.     //txpitch = exaGetPixmapPitch(pPix);
  696.     txpitch = rhd.displayWidth * 4;
  697.  
  698.    // txoffset = exaGetPixmapOffset(pPix) + info->fbLocation + pScrn->fbOffset;
  699.     txoffset = rhd.FbIntAddress + rhd.FbScanoutStart;
  700.  
  701.     if ((txoffset & 0x1f) != 0)
  702.         dbgprintf("Bad texture offset 0x%x\n", (int)txoffset);
  703.     if ((txpitch & 0x1f) != 0)
  704.         dbgprintf("Bad texture pitch 0x%x\n", (int)txpitch);
  705.  
  706.     /* TXPITCH = pixels (texels) per line - 1 */
  707.     pixel_shift = 32 >> 4;
  708.     txpitch >>= pixel_shift;
  709.     txpitch -= 1;
  710.  
  711.   //  if (RADEONPixmapIsColortiled(pPix))
  712.   //      txoffset |= R300_MACRO_TILE;
  713.  
  714.  //   for (i = 0; i < sizeof(R300TexFormats) / sizeof(R300TexFormats[0]); i++)
  715.  //   {
  716.  //       if (R300TexFormats[i].fmt == pPict->format)
  717.  //           break;
  718.  //   }
  719.  
  720.     //txformat1 = R300TexFormats[i].card_fmt;
  721.     txformat1 = R300_EASY_TX_FORMAT(X, Y, Z, W, W8Z8Y8X8);
  722.  
  723.     txformat0 = ((((w - 1) & 0x7ff) << R300_TXWIDTH_SHIFT) |
  724.                  (((h - 1) & 0x7ff) << R300_TXHEIGHT_SHIFT));
  725.  
  726.     if (IS_R500_3D && ((w - 1) & 0x800))
  727.         txpitch |= R500_TXWIDTH_11;
  728.  
  729.     if (IS_R500_3D && ((h - 1) & 0x800))
  730.         txpitch |= R500_TXHEIGHT_11;
  731.  
  732.     /* Use TXPITCH instead of TXWIDTH for address computations: we could
  733.      * omit this if there is no padding, but there is no apparent advantage
  734.      * in doing so.
  735.      */
  736.     txformat0 |= R300_TXPITCH_EN;
  737.  
  738.   //  info->texW[unit] = w;
  739.   //  info->texH[unit] = h;
  740.  
  741.   //  if (pPict->repeat && !(unit == 0 && need_src_tile_x))
  742.   //    txfilter = R300_TX_CLAMP_S(R300_TX_CLAMP_WRAP);
  743.   //  else
  744.       txfilter = R300_TX_CLAMP_S(R300_TX_CLAMP_CLAMP_GL);
  745.  
  746.   //  if (pPict->repeat && !(unit == 0 && need_src_tile_y))
  747.   //    txfilter |= R300_TX_CLAMP_T(R300_TX_CLAMP_WRAP);
  748.   //  else
  749.       txfilter |= R300_TX_CLAMP_T(R300_TX_CLAMP_CLAMP_GL);
  750.  
  751.     txfilter |= (unit << R300_TX_ID_SHIFT);
  752.  
  753. //    switch (pPict->filter) {
  754. //    case PictFilterNearest:
  755.         txfilter |= (R300_TX_MAG_FILTER_NEAREST | R300_TX_MIN_FILTER_NEAREST);
  756. //        break;
  757. //    case PictFilterBilinear:
  758. //        txfilter |= (R300_TX_MAG_FILTER_LINEAR | R300_TX_MIN_FILTER_LINEAR);
  759. //        break;
  760. //    default:
  761. //        RADEON_FALLBACK(("Bad filter 0x%x\n", pPict->filter));
  762. //    }
  763.  
  764.     {
  765.       u32_t *ring, write;
  766.  
  767.       BEGIN_ACCEL(7);
  768.       OUT_ACCEL_REG(R300_TX_FILTER0_0 + (unit * 4), txfilter);
  769.       OUT_ACCEL_REG(R300_TX_FILTER1_0 + (unit * 4), 0);
  770.       OUT_ACCEL_REG(R300_TX_FORMAT0_0 + (unit * 4), txformat0);
  771.       OUT_ACCEL_REG(R300_TX_FORMAT1_0 + (unit * 4), txformat1);
  772.       OUT_ACCEL_REG(R300_TX_FORMAT2_0 + (unit * 4), txpitch);
  773.       OUT_ACCEL_REG(R300_TX_OFFSET_0 + (unit * 4), txoffset);
  774. //    if (!pPict->repeat)
  775.       OUT_ACCEL_REG(R300_TX_BORDER_COLOR_0 + (unit * 4), 0);
  776.       FINISH_ACCEL();
  777.     }
  778. //    if (pPict->transform != 0) {
  779. //        is_transform[unit] = TRUE;
  780. //        transform[unit] = pPict->transform;
  781. //    } else {
  782. //        is_transform[unit] = FALSE;
  783. //    }
  784.  
  785.     return TRUE;
  786. }
  787.  
  788. static u32_t RADEONGetBlendCntl(int op, u32_t dst_format)
  789. {
  790.     u32_t sblend, dblend;
  791.  
  792.     sblend = RadeonBlendOp[op].blend_cntl & RADEON_SRC_BLEND_MASK;
  793.     dblend = RadeonBlendOp[op].blend_cntl & RADEON_DST_BLEND_MASK;
  794.  
  795.     /* If there's no dst alpha channel, adjust the blend op so that we'll treat
  796.      * it as always 1.
  797.      */
  798.     if (PICT_FORMAT_A(dst_format) == 0 && RadeonBlendOp[op].dst_alpha) {
  799.         if (sblend == RADEON_SRC_BLEND_GL_DST_ALPHA)
  800.             sblend = RADEON_SRC_BLEND_GL_ONE;
  801.         else if (sblend == RADEON_SRC_BLEND_GL_ONE_MINUS_DST_ALPHA)
  802.             sblend = RADEON_SRC_BLEND_GL_ZERO;
  803.     }
  804.  
  805.     return sblend | dblend;
  806. }
  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.  
  1069.  
  1070.  
  1071. static void RadeonCompositeTile(int srcX, int srcY,
  1072.                                 int dstX, int dstY,
  1073.                                 int w, int h)
  1074. {
  1075.   //  RINFO_FROM_SCREEN(pDst->drawable.pScreen);
  1076.     int vtx_count;
  1077.     xPointFixed srcTopLeft, srcTopRight, srcBottomLeft, srcBottomRight;
  1078.     xPointFixed maskTopLeft, maskTopRight, maskBottomLeft, maskBottomRight;
  1079.  
  1080.     u32_t *ring, write;
  1081.  
  1082.  
  1083.  //   ACCEL_PREAMBLE();
  1084.  
  1085.  //   ENTER_DRAW(0);
  1086.  
  1087.     /* ErrorF("RadeonComposite (%d,%d) (%d,%d) (%d,%d) (%d,%d)\n",
  1088.        srcX, srcY, maskX, maskY,dstX, dstY, w, h); */
  1089.  
  1090.     srcTopLeft.x     = IntToxFixed(srcX);
  1091.     srcTopLeft.y     = IntToxFixed(srcY);
  1092.     srcTopRight.x    = IntToxFixed(srcX + w);
  1093.     srcTopRight.y    = IntToxFixed(srcY);
  1094.     srcBottomLeft.x  = IntToxFixed(srcX);
  1095.     srcBottomLeft.y  = IntToxFixed(srcY + h);
  1096.     srcBottomRight.x = IntToxFixed(srcX + w);
  1097.     srcBottomRight.y = IntToxFixed(srcY + h);
  1098.  
  1099. /*
  1100.     if (is_transform[0]) {
  1101.         transformPoint(transform[0], &srcTopLeft);
  1102.         transformPoint(transform[0], &srcTopRight);
  1103.         transformPoint(transform[0], &srcBottomLeft);
  1104.         transformPoint(transform[0], &srcBottomRight);
  1105.     }
  1106.     if (is_transform[1]) {
  1107.         transformPoint(transform[1], &maskTopLeft);
  1108.         transformPoint(transform[1], &maskTopRight);
  1109.         transformPoint(transform[1], &maskBottomLeft);
  1110.         transformPoint(transform[1], &maskBottomRight);
  1111.     }
  1112. */
  1113.     vtx_count = VTX_COUNT;
  1114.  
  1115.     BEGIN_ACCEL(1);
  1116.     OUT_ACCEL_REG(R300_VAP_VTX_SIZE, vtx_count);
  1117.     FINISH_ACCEL();
  1118.  
  1119.     BEGIN_RING(4 * vtx_count + 4);
  1120.  
  1121.       OUT_RING(CP_PACKET3(R200_CP_PACKET3_3D_DRAW_IMMD_2,
  1122.                         4 * vtx_count));
  1123.       OUT_RING(RADEON_CP_VC_CNTL_PRIM_TYPE_TRI_FAN |
  1124.               RADEON_CP_VC_CNTL_PRIM_WALK_RING |
  1125.               (4 << RADEON_CP_VC_CNTL_NUM_SHIFT));
  1126.  
  1127.  
  1128.       VTX_OUT((float)dstX, (float)dstY,
  1129.               xFixedToFloat(srcTopLeft.x) / w,      // info->texW[0],
  1130.               xFixedToFloat(srcTopLeft.y) / h);     // info->texH[0]);
  1131.  
  1132.       VTX_OUT((float)dstX, (float)(dstY + h),
  1133.               xFixedToFloat(srcBottomLeft.x) / w,   // info->texW[0],
  1134.               xFixedToFloat(srcBottomLeft.y) / h);  // info->texH[0]);
  1135.  
  1136.       VTX_OUT((float)(dstX + w), (float)(dstY + h),
  1137.               xFixedToFloat(srcBottomRight.x) / w,  // info->texW[0],
  1138.               xFixedToFloat(srcBottomRight.y) / h); // info->texH[0]);
  1139.  
  1140.       VTX_OUT((float)(dstX + w), (float)dstY,
  1141.               xFixedToFloat(srcTopRight.x) / w,     // info->texW[0],
  1142.               xFixedToFloat(srcTopRight.y) / h);    // info->texH[0]);
  1143.  
  1144.           /* flushing is pipelined, free/finish is not */
  1145.       OUT_ACCEL_REG(R300_RB3D_DSTCACHE_CTLSTAT, R300_DC_FLUSH_3D);
  1146.  
  1147.  //     OUT_ACCEL_REG(RADEON_WAIT_UNTIL, RADEON_WAIT_3D_IDLECLEAN);
  1148.  
  1149.     COMMIT_RING();
  1150.  
  1151.  //   LEAVE_DRAW(0);
  1152. }
  1153. #undef VTX_OUT
  1154. #undef VTX_OUT_MASK
  1155.  
  1156. #if 0
  1157.  
  1158. int RadeonComposite( blit_t *blit)
  1159. {
  1160.     int tileSrcY, tileMaskY, tileDstY;
  1161.     int remainingHeight;
  1162.  
  1163.     R300PrepareComposite(3, blit->src_x, blit->src_y,
  1164.                              blit->dst_x, blit->dst_y,
  1165.                              blit->w, blit->h);
  1166.  
  1167. //    if (!need_src_tile_x && !need_src_tile_y) {
  1168.         RadeonCompositeTile( blit->src_x, blit->src_y,
  1169.                              blit->dst_x, blit->dst_y,
  1170.                              blit->w, blit->h);
  1171.         return 0;
  1172.   //  }
  1173.  
  1174.     /* Tiling logic borrowed from exaFillRegionTiled */
  1175.  
  1176. #if 0
  1177.     modulus(srcY, src_tile_height, tileSrcY);
  1178.     tileMaskY = maskY;
  1179.     tileDstY = dstY;
  1180.  
  1181.     remainingHeight = height;
  1182.     while (remainingHeight > 0) {
  1183.         int remainingWidth = width;
  1184.         int tileSrcX, tileMaskX, tileDstX;
  1185.         int h = src_tile_height - tileSrcY;
  1186.  
  1187.         if (h > remainingHeight)
  1188.             h = remainingHeight;
  1189.         remainingHeight -= h;
  1190.  
  1191.         modulus(srcX, src_tile_width, tileSrcX);
  1192.         tileMaskX = maskX;
  1193.         tileDstX = dstX;
  1194.  
  1195.         while (remainingWidth > 0) {
  1196.             int w = src_tile_width - tileSrcX;
  1197.             if (w > remainingWidth)
  1198.                 w = remainingWidth;
  1199.             remainingWidth -= w;
  1200.  
  1201.             FUNC_NAME(RadeonCompositeTile)(pDst,
  1202.                                            tileSrcX, tileSrcY,
  1203.                                            tileMaskX, tileMaskY,
  1204.                                            tileDstX, tileDstY,
  1205.                                            w, h);
  1206.  
  1207.             tileSrcX = 0;
  1208.             tileMaskX += w;
  1209.             tileDstX += w;
  1210.         }
  1211.         tileSrcY = 0;
  1212.         tileMaskY += h;
  1213.         tileDstY += h;
  1214.     }
  1215. #endif
  1216. }
  1217.  
  1218. #endif
  1219.