Subversion Repositories Kolibri OS

Rev

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

  1. /*
  2.  * Copyright © 2006,2008 Intel Corporation
  3.  * Copyright © 2007 Red Hat, Inc.
  4.  *
  5.  * Permission is hereby granted, free of charge, to any person obtaining a
  6.  * copy of this software and associated documentation files (the "Software"),
  7.  * to deal in the Software without restriction, including without limitation
  8.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  9.  * and/or sell copies of the Software, and to permit persons to whom the
  10.  * Software is furnished to do so, subject to the following conditions:
  11.  *
  12.  * The above copyright notice and this permission notice (including the next
  13.  * paragraph) shall be included in all copies or substantial portions of the
  14.  * Software.
  15.  *
  16.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19.  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21.  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22.  * SOFTWARE.
  23.  *
  24.  * Authors:
  25.  *    Wang Zhenyu <zhenyu.z.wang@intel.com>
  26.  *    Eric Anholt <eric@anholt.net>
  27.  *    Carl Worth <cworth@redhat.com>
  28.  *    Keith Packard <keithp@keithp.com>
  29.  *
  30.  */
  31.  
  32. #ifdef HAVE_CONFIG_H
  33. #include "config.h"
  34. #endif
  35.  
  36. #include <assert.h>
  37. #include <stdlib.h>
  38. #include <memory.h>
  39.  
  40. #include <intel_bufmgr.h>
  41. //#include "xf86.h"
  42. #include "intel.h"
  43. #include "i830_reg.h"
  44. #include "i965_reg.h"
  45.  
  46. /* bring in brw structs */
  47. #include "brw_defines.h"
  48. #include "brw_structs.h"
  49.  
  50. #define intel_debug_fallback printf
  51.  
  52.  
  53. // refer vol2, 3d rasterization 3.8.1
  54.  
  55. /* defined in brw_defines.h */
  56. static const struct blendinfo {
  57.         Bool dst_alpha;
  58.         Bool src_alpha;
  59.         uint32_t src_blend;
  60.         uint32_t dst_blend;
  61. } i965_blend_op[] = {
  62.         /* Clear */
  63.         {0, 0, BRW_BLENDFACTOR_ZERO, BRW_BLENDFACTOR_ZERO},
  64.         /* Src */
  65.         {0, 0, BRW_BLENDFACTOR_ONE, BRW_BLENDFACTOR_ZERO},
  66.         /* Dst */
  67.         {0, 0, BRW_BLENDFACTOR_ZERO, BRW_BLENDFACTOR_ONE},
  68.         /* Over */
  69.         {0, 1, BRW_BLENDFACTOR_ONE, BRW_BLENDFACTOR_INV_SRC_ALPHA},
  70.         /* OverReverse */
  71.         {1, 0, BRW_BLENDFACTOR_INV_DST_ALPHA, BRW_BLENDFACTOR_ONE},
  72.         /* In */
  73.         {1, 0, BRW_BLENDFACTOR_DST_ALPHA, BRW_BLENDFACTOR_ZERO},
  74.         /* InReverse */
  75.         {0, 1, BRW_BLENDFACTOR_ZERO, BRW_BLENDFACTOR_SRC_ALPHA},
  76.         /* Out */
  77.         {1, 0, BRW_BLENDFACTOR_INV_DST_ALPHA, BRW_BLENDFACTOR_ZERO},
  78.         /* OutReverse */
  79.         {0, 1, BRW_BLENDFACTOR_ZERO, BRW_BLENDFACTOR_INV_SRC_ALPHA},
  80.         /* Atop */
  81.         {1, 1, BRW_BLENDFACTOR_DST_ALPHA, BRW_BLENDFACTOR_INV_SRC_ALPHA},
  82.         /* AtopReverse */
  83.         {1, 1, BRW_BLENDFACTOR_INV_DST_ALPHA, BRW_BLENDFACTOR_SRC_ALPHA},
  84.         /* Xor */
  85.         {1, 1, BRW_BLENDFACTOR_INV_DST_ALPHA, BRW_BLENDFACTOR_INV_SRC_ALPHA},
  86.         /* Add */
  87.         {0, 0, BRW_BLENDFACTOR_ONE, BRW_BLENDFACTOR_ONE},
  88. };
  89.  
  90. /**
  91.  * Highest-valued BLENDFACTOR used in i965_blend_op.
  92.  *
  93.  * This leaves out BRW_BLENDFACTOR_INV_DST_COLOR,
  94.  * BRW_BLENDFACTOR_INV_CONST_{COLOR,ALPHA},
  95.  * BRW_BLENDFACTOR_INV_SRC1_{COLOR,ALPHA}
  96.  */
  97. #define BRW_BLENDFACTOR_COUNT (BRW_BLENDFACTOR_INV_DST_ALPHA + 1)
  98.  
  99. /* FIXME: surface format defined in brw_defines.h, shared Sampling engine
  100.  * 1.7.2
  101.  */
  102. static const struct formatinfo {
  103.         int fmt;
  104.         uint32_t card_fmt;
  105. } i965_tex_formats[] = {
  106.         {PICT_a8, BRW_SURFACEFORMAT_A8_UNORM},
  107.         {PICT_a8r8g8b8, BRW_SURFACEFORMAT_B8G8R8A8_UNORM},
  108.         {PICT_x8r8g8b8, BRW_SURFACEFORMAT_B8G8R8X8_UNORM},
  109.         {PICT_a8b8g8r8, BRW_SURFACEFORMAT_R8G8B8A8_UNORM},
  110.         {PICT_x8b8g8r8, BRW_SURFACEFORMAT_R8G8B8X8_UNORM},
  111.         {PICT_r8g8b8, BRW_SURFACEFORMAT_R8G8B8_UNORM},
  112.         {PICT_r5g6b5, BRW_SURFACEFORMAT_B5G6R5_UNORM},
  113.         {PICT_a1r5g5b5, BRW_SURFACEFORMAT_B5G5R5A1_UNORM},
  114. #if XORG_VERSION_CURRENT >= 10699900
  115.         {PICT_a2r10g10b10, BRW_SURFACEFORMAT_B10G10R10A2_UNORM},
  116.         {PICT_x2r10g10b10, BRW_SURFACEFORMAT_B10G10R10X2_UNORM},
  117.         {PICT_a2b10g10r10, BRW_SURFACEFORMAT_R10G10B10A2_UNORM},
  118.         {PICT_x2r10g10b10, BRW_SURFACEFORMAT_B10G10R10X2_UNORM},
  119. #endif
  120.         {PICT_a4r4g4b4, BRW_SURFACEFORMAT_B4G4R4A4_UNORM},
  121. };
  122.  
  123. static void i965_get_blend_cntl(int op, PicturePtr mask, uint32_t dst_format,
  124.                                 uint32_t * sblend, uint32_t * dblend)
  125. {
  126.  
  127.         *sblend = i965_blend_op[op].src_blend;
  128.         *dblend = i965_blend_op[op].dst_blend;
  129.  
  130.         /* If there's no dst alpha channel, adjust the blend op so that we'll treat
  131.          * it as always 1.
  132.          */
  133.         if (PICT_FORMAT_A(dst_format) == 0 && i965_blend_op[op].dst_alpha) {
  134.                 if (*sblend == BRW_BLENDFACTOR_DST_ALPHA)
  135.                         *sblend = BRW_BLENDFACTOR_ONE;
  136.                 else if (*sblend == BRW_BLENDFACTOR_INV_DST_ALPHA)
  137.                         *sblend = BRW_BLENDFACTOR_ZERO;
  138.         }
  139.  
  140.         /* If the source alpha is being used, then we should only be in a case where
  141.          * the source blend factor is 0, and the source blend value is the mask
  142.          * channels multiplied by the source picture's alpha.
  143.          */
  144.         if (mask && mask->componentAlpha && PICT_FORMAT_RGB(mask->format)
  145.             && i965_blend_op[op].src_alpha) {
  146.                 if (*dblend == BRW_BLENDFACTOR_SRC_ALPHA) {
  147.                         *dblend = BRW_BLENDFACTOR_SRC_COLOR;
  148.                 } else if (*dblend == BRW_BLENDFACTOR_INV_SRC_ALPHA) {
  149.                         *dblend = BRW_BLENDFACTOR_INV_SRC_COLOR;
  150.                 }
  151.         }
  152.  
  153. }
  154.  
  155. static uint32_t i965_get_dest_format(PicturePtr dest_picture)
  156. {
  157.         switch (dest_picture->format) {
  158.         case PICT_a8r8g8b8:
  159.         case PICT_x8r8g8b8:
  160.                 return BRW_SURFACEFORMAT_B8G8R8A8_UNORM;
  161.         case PICT_a8b8g8r8:
  162.         case PICT_x8b8g8r8:
  163.                 return BRW_SURFACEFORMAT_R8G8B8A8_UNORM;
  164. #if XORG_VERSION_CURRENT >= 10699900
  165.         case PICT_a2r10g10b10:
  166.         case PICT_x2r10g10b10:
  167.                 return BRW_SURFACEFORMAT_B10G10R10A2_UNORM;
  168. #endif
  169.         case PICT_r5g6b5:
  170.                 return BRW_SURFACEFORMAT_B5G6R5_UNORM;
  171.         case PICT_x1r5g5b5:
  172.         case PICT_a1r5g5b5:
  173.                 return BRW_SURFACEFORMAT_B5G5R5A1_UNORM;
  174.         case PICT_a8:
  175.                 return BRW_SURFACEFORMAT_A8_UNORM;
  176.         case PICT_a4r4g4b4:
  177.         case PICT_x4r4g4b4:
  178.                 return BRW_SURFACEFORMAT_B4G4R4A4_UNORM;
  179.         default:
  180.                 return -1;
  181.         }
  182. }
  183.  
  184. Bool
  185. i965_check_composite(int op,
  186.                      PicturePtr source_picture,
  187.                      PicturePtr mask_picture,
  188.                      PicturePtr dest_picture,
  189.                      int width, int height)
  190. {
  191.         /* Check for unsupported compositing operations. */
  192.         if (op >= sizeof(i965_blend_op) / sizeof(i965_blend_op[0])) {
  193.                 intel_debug_fallback("Unsupported Composite op 0x%x\n", op);
  194.                 return FALSE;
  195.         }
  196.  
  197.         if (mask_picture && mask_picture->componentAlpha &&
  198.             PICT_FORMAT_RGB(mask_picture->format)) {
  199.                 /* Check if it's component alpha that relies on a source alpha and on
  200.                  * the source value.  We can only get one of those into the single
  201.                  * source value that we get to blend with.
  202.                  */
  203.                 if (i965_blend_op[op].src_alpha &&
  204.                     (i965_blend_op[op].src_blend != BRW_BLENDFACTOR_ZERO)) {
  205.                         intel_debug_fallback("Component alpha not supported "
  206.                                              "with source alpha and source "
  207.                                              "value blending.\n");
  208.                         return FALSE;
  209.                 }
  210.         }
  211.  
  212.         if (i965_get_dest_format(dest_picture) == -1) {
  213.                 intel_debug_fallback("Usupported Color buffer format 0x%x\n",
  214.                                      (int)dest_picture->format);
  215.                 return FALSE;
  216.         }
  217.  
  218.         return TRUE;
  219. }
  220.  
  221. Bool
  222. i965_check_composite_texture(ScreenPtr screen, PicturePtr picture)
  223. {
  224.         if (picture->repeatType > RepeatReflect) {
  225.                 intel_debug_fallback("extended repeat (%d) not supported\n",
  226.                                      picture->repeatType);
  227.                 return FALSE;
  228.         }
  229.  
  230.         if (picture->filter != PictFilterNearest &&
  231.             picture->filter != PictFilterBilinear) {
  232.                 intel_debug_fallback("Unsupported filter 0x%x\n", picture->filter);
  233.                 return FALSE;
  234.         }
  235.  
  236.         if (picture->pDrawable) {
  237.                 int w, h, i;
  238.  
  239.                 w = picture->pDrawable->width;
  240.                 h = picture->pDrawable->height;
  241.                 if ((w > 8192) || (h > 8192)) {
  242.                         intel_debug_fallback( "Picture w/h too large (%dx%d)\n",w, h);
  243.                         return FALSE;
  244.                 }
  245.  
  246.                 for (i = 0;
  247.                      i < sizeof(i965_tex_formats) / sizeof(i965_tex_formats[0]);
  248.                      i++) {
  249.                         if (i965_tex_formats[i].fmt == picture->format)
  250.                                 break;
  251.                 }
  252.                 if (i == sizeof(i965_tex_formats) / sizeof(i965_tex_formats[0]))
  253.                 {
  254.                         intel_debug_fallback("Unsupported picture format "
  255.                                              "0x%x\n", (int)picture->format);
  256.                         return FALSE;
  257.                 }
  258.  
  259.                 return TRUE;
  260.         }
  261.  
  262.         return FALSE;
  263. }
  264.  
  265.  
  266. #define BRW_GRF_BLOCKS(nreg)    ((nreg + 15) / 16 - 1)
  267.  
  268. /* Set up a default static partitioning of the URB, which is supposed to
  269.  * allow anything we would want to do, at potentially lower performance.
  270.  */
  271. #define URB_CS_ENTRY_SIZE     0
  272. #define URB_CS_ENTRIES        0
  273.  
  274. #define URB_VS_ENTRY_SIZE     1 // each 512-bit row
  275. #define URB_VS_ENTRIES        8 // we needs at least 8 entries
  276.  
  277. #define URB_GS_ENTRY_SIZE     0
  278. #define URB_GS_ENTRIES        0
  279.  
  280. #define URB_CLIP_ENTRY_SIZE   0
  281. #define URB_CLIP_ENTRIES      0
  282.  
  283. #define URB_SF_ENTRY_SIZE     2
  284. #define URB_SF_ENTRIES        1
  285.  
  286. /*
  287.  * this program computes dA/dx and dA/dy for the texture coordinates along
  288.  * with the base texture coordinate. It was extracted from the Mesa driver
  289.  */
  290.  
  291. #define SF_KERNEL_NUM_GRF  16
  292. #define SF_MAX_THREADS     2
  293.  
  294. static const uint32_t sf_kernel_static[][4] = {
  295. #include "exa_sf.g4b"
  296. };
  297.  
  298. static const uint32_t sf_kernel_mask_static[][4] = {
  299. #include "exa_sf_mask.g4b"
  300. };
  301.  
  302. /* ps kernels */
  303. #define PS_KERNEL_NUM_GRF   32
  304. #define PS_MAX_THREADS      48
  305.  
  306. static const uint32_t ps_kernel_nomask_affine_static[][4] = {
  307. #include "exa_wm_xy.g4b"
  308. #include "exa_wm_src_affine.g4b"
  309. #include "exa_wm_src_sample_argb.g4b"
  310. #include "exa_wm_write.g4b"
  311. };
  312.  
  313. static const uint32_t ps_kernel_nomask_projective_static[][4] = {
  314. #include "exa_wm_xy.g4b"
  315. #include "exa_wm_src_projective.g4b"
  316. #include "exa_wm_src_sample_argb.g4b"
  317. #include "exa_wm_write.g4b"
  318. };
  319.  
  320. static const uint32_t ps_kernel_maskca_affine_static[][4] = {
  321. #include "exa_wm_xy.g4b"
  322. #include "exa_wm_src_affine.g4b"
  323. #include "exa_wm_src_sample_argb.g4b"
  324. #include "exa_wm_mask_affine.g4b"
  325. #include "exa_wm_mask_sample_argb.g4b"
  326. #include "exa_wm_ca.g4b"
  327. #include "exa_wm_write.g4b"
  328. };
  329.  
  330. static const uint32_t ps_kernel_maskca_projective_static[][4] = {
  331. #include "exa_wm_xy.g4b"
  332. #include "exa_wm_src_projective.g4b"
  333. #include "exa_wm_src_sample_argb.g4b"
  334. #include "exa_wm_mask_projective.g4b"
  335. #include "exa_wm_mask_sample_argb.g4b"
  336. #include "exa_wm_ca.g4b"
  337. #include "exa_wm_write.g4b"
  338. };
  339.  
  340. static const uint32_t ps_kernel_maskca_srcalpha_affine_static[][4] = {
  341. #include "exa_wm_xy.g4b"
  342. #include "exa_wm_src_affine.g4b"
  343. #include "exa_wm_src_sample_a.g4b"
  344. #include "exa_wm_mask_affine.g4b"
  345. #include "exa_wm_mask_sample_argb.g4b"
  346. #include "exa_wm_ca_srcalpha.g4b"
  347. #include "exa_wm_write.g4b"
  348. };
  349.  
  350. static const uint32_t ps_kernel_maskca_srcalpha_projective_static[][4] = {
  351. #include "exa_wm_xy.g4b"
  352. #include "exa_wm_src_projective.g4b"
  353. #include "exa_wm_src_sample_a.g4b"
  354. #include "exa_wm_mask_projective.g4b"
  355. #include "exa_wm_mask_sample_argb.g4b"
  356. #include "exa_wm_ca_srcalpha.g4b"
  357. #include "exa_wm_write.g4b"
  358. };
  359.  
  360. static const uint32_t ps_kernel_masknoca_affine_static[][4] = {
  361. #include "exa_wm_xy.g4b"
  362. #include "exa_wm_src_affine.g4b"
  363. #include "exa_wm_src_sample_argb.g4b"
  364. #include "exa_wm_mask_affine.g4b"
  365. #include "exa_wm_mask_sample_a.g4b"
  366. #include "exa_wm_noca.g4b"
  367. #include "exa_wm_write.g4b"
  368. };
  369.  
  370. static const uint32_t ps_kernel_masknoca_projective_static[][4] = {
  371. #include "exa_wm_xy.g4b"
  372. #include "exa_wm_src_projective.g4b"
  373. #include "exa_wm_src_sample_argb.g4b"
  374. #include "exa_wm_mask_projective.g4b"
  375. #include "exa_wm_mask_sample_a.g4b"
  376. #include "exa_wm_noca.g4b"
  377. #include "exa_wm_write.g4b"
  378. };
  379.  
  380. /* new programs for Ironlake */
  381. static const uint32_t sf_kernel_static_gen5[][4] = {
  382. #include "exa_sf.g4b.gen5"
  383. };
  384.  
  385. static const uint32_t sf_kernel_mask_static_gen5[][4] = {
  386. #include "exa_sf_mask.g4b.gen5"
  387. };
  388.  
  389. static const uint32_t ps_kernel_nomask_affine_static_gen5[][4] = {
  390. #include "exa_wm_xy.g4b.gen5"
  391. #include "exa_wm_src_affine.g4b.gen5"
  392. #include "exa_wm_src_sample_argb.g4b.gen5"
  393. #include "exa_wm_write.g4b.gen5"
  394. };
  395.  
  396. static const uint32_t ps_kernel_nomask_projective_static_gen5[][4] = {
  397. #include "exa_wm_xy.g4b.gen5"
  398. #include "exa_wm_src_projective.g4b.gen5"
  399. #include "exa_wm_src_sample_argb.g4b.gen5"
  400. #include "exa_wm_write.g4b.gen5"
  401. };
  402.  
  403. static const uint32_t ps_kernel_maskca_affine_static_gen5[][4] = {
  404. #include "exa_wm_xy.g4b.gen5"
  405. #include "exa_wm_src_affine.g4b.gen5"
  406. #include "exa_wm_src_sample_argb.g4b.gen5"
  407. #include "exa_wm_mask_affine.g4b.gen5"
  408. #include "exa_wm_mask_sample_argb.g4b.gen5"
  409. #include "exa_wm_ca.g4b.gen5"
  410. #include "exa_wm_write.g4b.gen5"
  411. };
  412.  
  413. static const uint32_t ps_kernel_maskca_projective_static_gen5[][4] = {
  414. #include "exa_wm_xy.g4b.gen5"
  415. #include "exa_wm_src_projective.g4b.gen5"
  416. #include "exa_wm_src_sample_argb.g4b.gen5"
  417. #include "exa_wm_mask_projective.g4b.gen5"
  418. #include "exa_wm_mask_sample_argb.g4b.gen5"
  419. #include "exa_wm_ca.g4b.gen5"
  420. #include "exa_wm_write.g4b.gen5"
  421. };
  422.  
  423. static const uint32_t ps_kernel_maskca_srcalpha_affine_static_gen5[][4] = {
  424. #include "exa_wm_xy.g4b.gen5"
  425. #include "exa_wm_src_affine.g4b.gen5"
  426. #include "exa_wm_src_sample_a.g4b.gen5"
  427. #include "exa_wm_mask_affine.g4b.gen5"
  428. #include "exa_wm_mask_sample_argb.g4b.gen5"
  429. #include "exa_wm_ca_srcalpha.g4b.gen5"
  430. #include "exa_wm_write.g4b.gen5"
  431. };
  432.  
  433. static const uint32_t ps_kernel_maskca_srcalpha_projective_static_gen5[][4] = {
  434. #include "exa_wm_xy.g4b.gen5"
  435. #include "exa_wm_src_projective.g4b.gen5"
  436. #include "exa_wm_src_sample_a.g4b.gen5"
  437. #include "exa_wm_mask_projective.g4b.gen5"
  438. #include "exa_wm_mask_sample_argb.g4b.gen5"
  439. #include "exa_wm_ca_srcalpha.g4b.gen5"
  440. #include "exa_wm_write.g4b.gen5"
  441. };
  442.  
  443. static const uint32_t ps_kernel_masknoca_affine_static_gen5[][4] = {
  444. #include "exa_wm_xy.g4b.gen5"
  445. #include "exa_wm_src_affine.g4b.gen5"
  446. #include "exa_wm_src_sample_argb.g4b.gen5"
  447. #include "exa_wm_mask_affine.g4b.gen5"
  448. #include "exa_wm_mask_sample_a.g4b.gen5"
  449. #include "exa_wm_noca.g4b.gen5"
  450. #include "exa_wm_write.g4b.gen5"
  451. };
  452.  
  453. static const uint32_t ps_kernel_masknoca_projective_static_gen5[][4] = {
  454. #include "exa_wm_xy.g4b.gen5"
  455. #include "exa_wm_src_projective.g4b.gen5"
  456. #include "exa_wm_src_sample_argb.g4b.gen5"
  457. #include "exa_wm_mask_projective.g4b.gen5"
  458. #include "exa_wm_mask_sample_a.g4b.gen5"
  459. #include "exa_wm_noca.g4b.gen5"
  460. #include "exa_wm_write.g4b.gen5"
  461. };
  462.  
  463. /* programs for GEN6 */
  464. static const uint32_t ps_kernel_nomask_affine_static_gen6[][4] = {
  465. #include "exa_wm_src_affine.g6b"
  466. #include "exa_wm_src_sample_argb.g6b"
  467. #include "exa_wm_write.g6b"
  468. };
  469.  
  470. static const uint32_t ps_kernel_nomask_projective_static_gen6[][4] = {
  471. #include "exa_wm_src_projective.g6b"
  472. #include "exa_wm_src_sample_argb.g6b"
  473. #include "exa_wm_write.g6b"
  474. };
  475.  
  476. static const uint32_t ps_kernel_maskca_affine_static_gen6[][4] = {
  477. #include "exa_wm_src_affine.g6b"
  478. #include "exa_wm_src_sample_argb.g6b"
  479. #include "exa_wm_mask_affine.g6b"
  480. #include "exa_wm_mask_sample_argb.g6b"
  481. #include "exa_wm_ca.g6b"
  482. #include "exa_wm_write.g6b"
  483. };
  484.  
  485. static const uint32_t ps_kernel_maskca_projective_static_gen6[][4] = {
  486. #include "exa_wm_src_projective.g6b"
  487. #include "exa_wm_src_sample_argb.g6b"
  488. #include "exa_wm_mask_projective.g6b"
  489. #include "exa_wm_mask_sample_argb.g6b"
  490. #include "exa_wm_ca.g4b.gen5"
  491. #include "exa_wm_write.g6b"
  492. };
  493.  
  494. static const uint32_t ps_kernel_maskca_srcalpha_affine_static_gen6[][4] = {
  495. #include "exa_wm_src_affine.g6b"
  496. #include "exa_wm_src_sample_a.g6b"
  497. #include "exa_wm_mask_affine.g6b"
  498. #include "exa_wm_mask_sample_argb.g6b"
  499. #include "exa_wm_ca_srcalpha.g6b"
  500. #include "exa_wm_write.g6b"
  501. };
  502.  
  503. static const uint32_t ps_kernel_maskca_srcalpha_projective_static_gen6[][4] = {
  504. #include "exa_wm_src_projective.g6b"
  505. #include "exa_wm_src_sample_a.g6b"
  506. #include "exa_wm_mask_projective.g6b"
  507. #include "exa_wm_mask_sample_argb.g6b"
  508. #include "exa_wm_ca_srcalpha.g6b"
  509. #include "exa_wm_write.g6b"
  510. };
  511.  
  512. static const uint32_t ps_kernel_masknoca_affine_static_gen6[][4] = {
  513. #include "exa_wm_src_affine.g6b"
  514. #include "exa_wm_src_sample_argb.g6b"
  515. #include "exa_wm_mask_affine.g6b"
  516. #include "exa_wm_mask_sample_a.g6b"
  517. #include "exa_wm_noca.g6b"
  518. #include "exa_wm_write.g6b"
  519. };
  520.  
  521. static const uint32_t ps_kernel_masknoca_projective_static_gen6[][4] = {
  522. #include "exa_wm_src_projective.g6b"
  523. #include "exa_wm_src_sample_argb.g6b"
  524. #include "exa_wm_mask_projective.g6b"
  525. #include "exa_wm_mask_sample_a.g6b"
  526. #include "exa_wm_noca.g6b"
  527. #include "exa_wm_write.g6b"
  528. };
  529.  
  530. /* programs for GEN7 */
  531. static const uint32_t ps_kernel_nomask_affine_static_gen7[][4] = {
  532. #include "exa_wm_src_affine.g7b"
  533. #include "exa_wm_src_sample_argb.g7b"
  534. #include "exa_wm_write.g7b"
  535. };
  536.  
  537. static const uint32_t ps_kernel_nomask_projective_static_gen7[][4] = {
  538. #include "exa_wm_src_projective.g7b"
  539. #include "exa_wm_src_sample_argb.g7b"
  540. #include "exa_wm_write.g7b"
  541. };
  542.  
  543. static const uint32_t ps_kernel_maskca_affine_static_gen7[][4] = {
  544. #include "exa_wm_src_affine.g7b"
  545. #include "exa_wm_src_sample_argb.g7b"
  546. #include "exa_wm_mask_affine.g7b"
  547. #include "exa_wm_mask_sample_argb.g7b"
  548. #include "exa_wm_ca.g6b"
  549. #include "exa_wm_write.g7b"
  550. };
  551.  
  552. static const uint32_t ps_kernel_maskca_projective_static_gen7[][4] = {
  553. #include "exa_wm_src_projective.g7b"
  554. #include "exa_wm_src_sample_argb.g7b"
  555. #include "exa_wm_mask_projective.g7b"
  556. #include "exa_wm_mask_sample_argb.g7b"
  557. #include "exa_wm_ca.g4b.gen5"
  558. #include "exa_wm_write.g7b"
  559. };
  560.  
  561. static const uint32_t ps_kernel_maskca_srcalpha_affine_static_gen7[][4] = {
  562. #include "exa_wm_src_affine.g7b"
  563. #include "exa_wm_src_sample_a.g7b"
  564. #include "exa_wm_mask_affine.g7b"
  565. #include "exa_wm_mask_sample_argb.g7b"
  566. #include "exa_wm_ca_srcalpha.g6b"
  567. #include "exa_wm_write.g7b"
  568. };
  569.  
  570. static const uint32_t ps_kernel_maskca_srcalpha_projective_static_gen7[][4] = {
  571. #include "exa_wm_src_projective.g7b"
  572. #include "exa_wm_src_sample_a.g7b"
  573. #include "exa_wm_mask_projective.g7b"
  574. #include "exa_wm_mask_sample_argb.g7b"
  575. #include "exa_wm_ca_srcalpha.g6b"
  576. #include "exa_wm_write.g7b"
  577. };
  578.  
  579. static const uint32_t ps_kernel_masknoca_affine_static_gen7[][4] = {
  580. #include "exa_wm_src_affine.g7b"
  581. #include "exa_wm_src_sample_argb.g7b"
  582. #include "exa_wm_mask_affine.g7b"
  583. #include "exa_wm_mask_sample_a.g7b"
  584. #include "exa_wm_noca.g6b"
  585. #include "exa_wm_write.g7b"
  586. };
  587.  
  588. static const uint32_t ps_kernel_masknoca_projective_static_gen7[][4] = {
  589. #include "exa_wm_src_projective.g7b"
  590. #include "exa_wm_src_sample_argb.g7b"
  591. #include "exa_wm_mask_projective.g7b"
  592. #include "exa_wm_mask_sample_a.g7b"
  593. #include "exa_wm_noca.g6b"
  594. #include "exa_wm_write.g7b"
  595. };
  596.  
  597.  
  598. typedef enum {
  599.         SS_INVALID_FILTER = -1,
  600.         SS_FILTER_NEAREST,
  601.         SS_FILTER_BILINEAR,
  602.         FILTER_COUNT,
  603. } sampler_state_filter_t;
  604.  
  605. typedef enum {
  606.         SS_INVALID_EXTEND = -1,
  607.         SS_EXTEND_NONE,
  608.         SS_EXTEND_REPEAT,
  609.         SS_EXTEND_PAD,
  610.         SS_EXTEND_REFLECT,
  611.         EXTEND_COUNT,
  612. } sampler_state_extend_t;
  613.  
  614. typedef enum {
  615.         WM_KERNEL_NOMASK_AFFINE,
  616.         WM_KERNEL_NOMASK_PROJECTIVE,
  617.         WM_KERNEL_MASKCA_AFFINE,
  618.         WM_KERNEL_MASKCA_PROJECTIVE,
  619.         WM_KERNEL_MASKCA_SRCALPHA_AFFINE,
  620.         WM_KERNEL_MASKCA_SRCALPHA_PROJECTIVE,
  621.         WM_KERNEL_MASKNOCA_AFFINE,
  622.         WM_KERNEL_MASKNOCA_PROJECTIVE,
  623.         KERNEL_COUNT
  624. } wm_kernel_t;
  625.  
  626. #define KERNEL(kernel_enum, kernel, masked) \
  627.     [kernel_enum] = {&kernel, sizeof(kernel), masked}
  628. struct wm_kernel_info {
  629.         const void *data;
  630.         unsigned int size;
  631.         Bool has_mask;
  632. };
  633.  
  634. static const struct wm_kernel_info wm_kernels_gen4[] = {
  635.         KERNEL(WM_KERNEL_NOMASK_AFFINE,
  636.                ps_kernel_nomask_affine_static, FALSE),
  637.         KERNEL(WM_KERNEL_NOMASK_PROJECTIVE,
  638.                ps_kernel_nomask_projective_static, FALSE),
  639.         KERNEL(WM_KERNEL_MASKCA_AFFINE,
  640.                ps_kernel_maskca_affine_static, TRUE),
  641.         KERNEL(WM_KERNEL_MASKCA_PROJECTIVE,
  642.                ps_kernel_maskca_projective_static, TRUE),
  643.         KERNEL(WM_KERNEL_MASKCA_SRCALPHA_AFFINE,
  644.                ps_kernel_maskca_srcalpha_affine_static, TRUE),
  645.         KERNEL(WM_KERNEL_MASKCA_SRCALPHA_PROJECTIVE,
  646.                ps_kernel_maskca_srcalpha_projective_static, TRUE),
  647.         KERNEL(WM_KERNEL_MASKNOCA_AFFINE,
  648.                ps_kernel_masknoca_affine_static, TRUE),
  649.         KERNEL(WM_KERNEL_MASKNOCA_PROJECTIVE,
  650.                ps_kernel_masknoca_projective_static, TRUE),
  651. };
  652.  
  653. static const struct wm_kernel_info wm_kernels_gen5[] = {
  654.         KERNEL(WM_KERNEL_NOMASK_AFFINE,
  655.                ps_kernel_nomask_affine_static_gen5, FALSE),
  656.         KERNEL(WM_KERNEL_NOMASK_PROJECTIVE,
  657.                ps_kernel_nomask_projective_static_gen5, FALSE),
  658.         KERNEL(WM_KERNEL_MASKCA_AFFINE,
  659.                ps_kernel_maskca_affine_static_gen5, TRUE),
  660.         KERNEL(WM_KERNEL_MASKCA_PROJECTIVE,
  661.                ps_kernel_maskca_projective_static_gen5, TRUE),
  662.         KERNEL(WM_KERNEL_MASKCA_SRCALPHA_AFFINE,
  663.                ps_kernel_maskca_srcalpha_affine_static_gen5, TRUE),
  664.         KERNEL(WM_KERNEL_MASKCA_SRCALPHA_PROJECTIVE,
  665.                ps_kernel_maskca_srcalpha_projective_static_gen5, TRUE),
  666.         KERNEL(WM_KERNEL_MASKNOCA_AFFINE,
  667.                ps_kernel_masknoca_affine_static_gen5, TRUE),
  668.         KERNEL(WM_KERNEL_MASKNOCA_PROJECTIVE,
  669.                ps_kernel_masknoca_projective_static_gen5, TRUE),
  670. };
  671.  
  672. static const struct wm_kernel_info wm_kernels_gen6[] = {
  673.         KERNEL(WM_KERNEL_NOMASK_AFFINE,
  674.                ps_kernel_nomask_affine_static_gen6, FALSE),
  675.         KERNEL(WM_KERNEL_NOMASK_PROJECTIVE,
  676.                ps_kernel_nomask_projective_static_gen6, FALSE),
  677.         KERNEL(WM_KERNEL_MASKCA_AFFINE,
  678.                ps_kernel_maskca_affine_static_gen6, TRUE),
  679.         KERNEL(WM_KERNEL_MASKCA_PROJECTIVE,
  680.                ps_kernel_maskca_projective_static_gen6, TRUE),
  681.         KERNEL(WM_KERNEL_MASKCA_SRCALPHA_AFFINE,
  682.                ps_kernel_maskca_srcalpha_affine_static_gen6, TRUE),
  683.         KERNEL(WM_KERNEL_MASKCA_SRCALPHA_PROJECTIVE,
  684.                ps_kernel_maskca_srcalpha_projective_static_gen6, TRUE),
  685.         KERNEL(WM_KERNEL_MASKNOCA_AFFINE,
  686.                ps_kernel_masknoca_affine_static_gen6, TRUE),
  687.         KERNEL(WM_KERNEL_MASKNOCA_PROJECTIVE,
  688.                ps_kernel_masknoca_projective_static_gen6, TRUE),
  689. };
  690.  
  691. static const struct wm_kernel_info wm_kernels_gen7[] = {
  692.         KERNEL(WM_KERNEL_NOMASK_AFFINE,
  693.                ps_kernel_nomask_affine_static_gen7, FALSE),
  694.         KERNEL(WM_KERNEL_NOMASK_PROJECTIVE,
  695.                ps_kernel_nomask_projective_static_gen7, FALSE),
  696.         KERNEL(WM_KERNEL_MASKCA_AFFINE,
  697.                ps_kernel_maskca_affine_static_gen7, TRUE),
  698.         KERNEL(WM_KERNEL_MASKCA_PROJECTIVE,
  699.                ps_kernel_maskca_projective_static_gen7, TRUE),
  700.         KERNEL(WM_KERNEL_MASKCA_SRCALPHA_AFFINE,
  701.                ps_kernel_maskca_srcalpha_affine_static_gen7, TRUE),
  702.         KERNEL(WM_KERNEL_MASKCA_SRCALPHA_PROJECTIVE,
  703.                ps_kernel_maskca_srcalpha_projective_static_gen7, TRUE),
  704.         KERNEL(WM_KERNEL_MASKNOCA_AFFINE,
  705.                ps_kernel_masknoca_affine_static_gen7, TRUE),
  706.         KERNEL(WM_KERNEL_MASKNOCA_PROJECTIVE,
  707.                ps_kernel_masknoca_projective_static_gen7, TRUE),
  708. };
  709.  
  710. #undef KERNEL
  711.  
  712. typedef struct _brw_cc_unit_state_padded {
  713.         struct brw_cc_unit_state state;
  714.         char pad[64 - sizeof(struct brw_cc_unit_state)];
  715. } brw_cc_unit_state_padded;
  716.  
  717. #ifndef MAX
  718. #define MAX(a, b) ((a) > (b) ? (a) : (b))
  719. #endif
  720. #define SURFACE_STATE_PADDED_SIZE ALIGN(MAX(sizeof(struct brw_surface_state), sizeof(struct gen7_surface_state)), 32)
  721.  
  722. struct gen4_cc_unit_state {
  723.         /* Index by [src_blend][dst_blend] */
  724.         brw_cc_unit_state_padded cc_state[BRW_BLENDFACTOR_COUNT][BRW_BLENDFACTOR_COUNT];
  725. };
  726.  
  727. typedef struct gen4_composite_op {
  728.         int op;
  729.         sampler_state_filter_t src_filter;
  730.         sampler_state_filter_t mask_filter;
  731.         sampler_state_extend_t src_extend;
  732.         sampler_state_extend_t mask_extend;
  733.         Bool is_affine;
  734.         wm_kernel_t wm_kernel;
  735.         int vertex_id;
  736. } gen4_composite_op;
  737.  
  738. /** Private data for gen4 render accel implementation. */
  739. struct gen4_render_state {
  740.         drm_intel_bo *vs_state_bo;
  741.         drm_intel_bo *sf_state_bo;
  742.         drm_intel_bo *sf_mask_state_bo;
  743.         drm_intel_bo *cc_state_bo;
  744.         drm_intel_bo *wm_state_bo[KERNEL_COUNT]
  745.             [FILTER_COUNT] [EXTEND_COUNT]
  746.             [FILTER_COUNT] [EXTEND_COUNT];
  747.         drm_intel_bo *wm_kernel_bo[KERNEL_COUNT];
  748.  
  749.         drm_intel_bo *cc_vp_bo;
  750.         drm_intel_bo *gen6_blend_bo;
  751.         drm_intel_bo *gen6_depth_stencil_bo;
  752.         drm_intel_bo *ps_sampler_state_bo[FILTER_COUNT]
  753.             [EXTEND_COUNT]
  754.             [FILTER_COUNT]
  755.             [EXTEND_COUNT];
  756.         gen4_composite_op composite_op;
  757. };
  758.  
  759. static void gen6_emit_composite_state(struct intel_screen_private *intel);
  760. static void gen6_render_state_init();
  761.  
  762. /**
  763.  * Sets up the SF state pointing at an SF kernel.
  764.  *
  765.  * The SF kernel does coord interp: for each attribute,
  766.  * calculate dA/dx and dA/dy.  Hand these interpolation coefficients
  767.  * back to SF which then hands pixels off to WM.
  768.  */
  769. static drm_intel_bo *gen4_create_sf_state(intel_screen_private *intel,
  770.                                           drm_intel_bo * kernel_bo)
  771. {
  772.         struct brw_sf_unit_state *sf_state;
  773.         drm_intel_bo *sf_state_bo;
  774.         int ret;
  775.  
  776.         sf_state_bo = drm_intel_bo_alloc(intel->bufmgr, "gen4 SF state",
  777.                                          sizeof(*sf_state), 4096);
  778.         assert(sf_state_bo);
  779.  
  780.         ret = drm_intel_bo_map(sf_state_bo, TRUE);
  781.         assert(ret == 0);
  782.  
  783.         sf_state = memset(sf_state_bo->virtual, 0, sizeof(*sf_state));
  784.         sf_state->thread0.grf_reg_count = BRW_GRF_BLOCKS(SF_KERNEL_NUM_GRF);
  785.         sf_state->thread0.kernel_start_pointer =
  786.             intel_emit_reloc(sf_state_bo,
  787.                              offsetof(struct brw_sf_unit_state, thread0),
  788.                              kernel_bo, sf_state->thread0.grf_reg_count << 1,
  789.                              I915_GEM_DOMAIN_INSTRUCTION, 0) >> 6;
  790.         sf_state->sf1.single_program_flow = 1;
  791.         sf_state->sf1.binding_table_entry_count = 0;
  792.         sf_state->sf1.thread_priority = 0;
  793.         sf_state->sf1.floating_point_mode = 0;  /* Mesa does this */
  794.         sf_state->sf1.illegal_op_exception_enable = 1;
  795.         sf_state->sf1.mask_stack_exception_enable = 1;
  796.         sf_state->sf1.sw_exception_enable = 1;
  797.         sf_state->thread2.per_thread_scratch_space = 0;
  798.         /* scratch space is not used in our kernel */
  799.         sf_state->thread2.scratch_space_base_pointer = 0;
  800.         sf_state->thread3.const_urb_entry_read_length = 0;      /* no const URBs */
  801.         sf_state->thread3.const_urb_entry_read_offset = 0;      /* no const URBs */
  802.         sf_state->thread3.urb_entry_read_length = 1;    /* 1 URB per vertex */
  803.         /* don't smash vertex header, read start from dw8 */
  804.         sf_state->thread3.urb_entry_read_offset = 1;
  805.         sf_state->thread3.dispatch_grf_start_reg = 3;
  806.         sf_state->thread4.max_threads = SF_MAX_THREADS - 1;
  807.         sf_state->thread4.urb_entry_allocation_size = URB_SF_ENTRY_SIZE - 1;
  808.         sf_state->thread4.nr_urb_entries = URB_SF_ENTRIES;
  809.         sf_state->sf5.viewport_transform = FALSE;       /* skip viewport */
  810.         sf_state->sf6.cull_mode = BRW_CULLMODE_NONE;
  811.         sf_state->sf6.scissor = 0;
  812.         sf_state->sf7.trifan_pv = 2;
  813.         sf_state->sf6.dest_org_vbias = 0x8;
  814.         sf_state->sf6.dest_org_hbias = 0x8;
  815.  
  816.         drm_intel_bo_unmap(sf_state_bo);
  817.  
  818.         return sf_state_bo;
  819.         (void)ret;
  820. }
  821.  
  822. static drm_intel_bo *sampler_border_color_create(intel_screen_private *intel)
  823. {
  824.         struct brw_sampler_legacy_border_color sampler_border_color;
  825.  
  826.         /* Set up the sampler border color (always transparent black) */
  827.         memset(&sampler_border_color, 0, sizeof(sampler_border_color));
  828.         sampler_border_color.color[0] = 0;      /* R */
  829.         sampler_border_color.color[1] = 0;      /* G */
  830.         sampler_border_color.color[2] = 0;      /* B */
  831.         sampler_border_color.color[3] = 0;      /* A */
  832.  
  833.         return intel_bo_alloc_for_data(intel,
  834.                                        &sampler_border_color,
  835.                                        sizeof(sampler_border_color),
  836.                                        "gen4 render sampler border color");
  837. }
  838.  
  839. static void
  840. gen4_sampler_state_init(drm_intel_bo * sampler_state_bo,
  841.                    struct brw_sampler_state *sampler_state,
  842.                    sampler_state_filter_t filter,
  843.                    sampler_state_extend_t extend,
  844.                    drm_intel_bo * border_color_bo)
  845. {
  846.         uint32_t sampler_state_offset;
  847.  
  848.         sampler_state_offset = (char *)sampler_state -
  849.             (char *)sampler_state_bo->virtual;
  850.  
  851.         /* PS kernel use this sampler */
  852.         memset(sampler_state, 0, sizeof(*sampler_state));
  853.  
  854.         sampler_state->ss0.lod_preclamp = 1;    /* GL mode */
  855.  
  856.         /* We use the legacy mode to get the semantics specified by
  857.          * the Render extension. */
  858.         sampler_state->ss0.border_color_mode = BRW_BORDER_COLOR_MODE_LEGACY;
  859.  
  860.         switch (filter) {
  861.         default:
  862.         case SS_FILTER_NEAREST:
  863.                 sampler_state->ss0.min_filter = BRW_MAPFILTER_NEAREST;
  864.                 sampler_state->ss0.mag_filter = BRW_MAPFILTER_NEAREST;
  865.                 break;
  866.         case SS_FILTER_BILINEAR:
  867.                 sampler_state->ss0.min_filter = BRW_MAPFILTER_LINEAR;
  868.                 sampler_state->ss0.mag_filter = BRW_MAPFILTER_LINEAR;
  869.                 break;
  870.         }
  871.  
  872.         switch (extend) {
  873.         default:
  874.         case SS_EXTEND_NONE:
  875.                 sampler_state->ss1.r_wrap_mode = BRW_TEXCOORDMODE_CLAMP_BORDER;
  876.                 sampler_state->ss1.s_wrap_mode = BRW_TEXCOORDMODE_CLAMP_BORDER;
  877.                 sampler_state->ss1.t_wrap_mode = BRW_TEXCOORDMODE_CLAMP_BORDER;
  878.                 break;
  879.         case SS_EXTEND_REPEAT:
  880.                 sampler_state->ss1.r_wrap_mode = BRW_TEXCOORDMODE_WRAP;
  881.                 sampler_state->ss1.s_wrap_mode = BRW_TEXCOORDMODE_WRAP;
  882.                 sampler_state->ss1.t_wrap_mode = BRW_TEXCOORDMODE_WRAP;
  883.                 break;
  884.         case SS_EXTEND_PAD:
  885.                 sampler_state->ss1.r_wrap_mode = BRW_TEXCOORDMODE_CLAMP;
  886.                 sampler_state->ss1.s_wrap_mode = BRW_TEXCOORDMODE_CLAMP;
  887.                 sampler_state->ss1.t_wrap_mode = BRW_TEXCOORDMODE_CLAMP;
  888.                 break;
  889.         case SS_EXTEND_REFLECT:
  890.                 sampler_state->ss1.r_wrap_mode = BRW_TEXCOORDMODE_MIRROR;
  891.                 sampler_state->ss1.s_wrap_mode = BRW_TEXCOORDMODE_MIRROR;
  892.                 sampler_state->ss1.t_wrap_mode = BRW_TEXCOORDMODE_MIRROR;
  893.                 break;
  894.         }
  895.  
  896.         sampler_state->ss2.border_color_pointer =
  897.             intel_emit_reloc(sampler_state_bo, sampler_state_offset +
  898.                              offsetof(struct brw_sampler_state, ss2),
  899.                              border_color_bo, 0,
  900.                              I915_GEM_DOMAIN_SAMPLER, 0) >> 5;
  901.  
  902.         sampler_state->ss3.chroma_key_enable = 0;       /* disable chromakey */
  903. }
  904.  
  905. static void
  906. gen7_sampler_state_init(drm_intel_bo * sampler_state_bo,
  907.                    struct gen7_sampler_state *sampler_state,
  908.                    sampler_state_filter_t filter,
  909.                    sampler_state_extend_t extend,
  910.                    drm_intel_bo * border_color_bo)
  911. {
  912.         uint32_t sampler_state_offset;
  913.  
  914.         sampler_state_offset = (char *)sampler_state -
  915.             (char *)sampler_state_bo->virtual;
  916.  
  917.         /* PS kernel use this sampler */
  918.         memset(sampler_state, 0, sizeof(*sampler_state));
  919.  
  920.         sampler_state->ss0.lod_preclamp = 1;    /* GL mode */
  921.  
  922.         /* We use the legacy mode to get the semantics specified by
  923.          * the Render extension. */
  924.         sampler_state->ss0.default_color_mode = BRW_BORDER_COLOR_MODE_LEGACY;
  925.  
  926.         switch (filter) {
  927.         default:
  928.         case SS_FILTER_NEAREST:
  929.                 sampler_state->ss0.min_filter = BRW_MAPFILTER_NEAREST;
  930.                 sampler_state->ss0.mag_filter = BRW_MAPFILTER_NEAREST;
  931.                 break;
  932.         case SS_FILTER_BILINEAR:
  933.                 sampler_state->ss0.min_filter = BRW_MAPFILTER_LINEAR;
  934.                 sampler_state->ss0.mag_filter = BRW_MAPFILTER_LINEAR;
  935.                 break;
  936.         }
  937.  
  938.         switch (extend) {
  939.         default:
  940.         case SS_EXTEND_NONE:
  941.                 sampler_state->ss3.r_wrap_mode = BRW_TEXCOORDMODE_CLAMP_BORDER;
  942.                 sampler_state->ss3.s_wrap_mode = BRW_TEXCOORDMODE_CLAMP_BORDER;
  943.                 sampler_state->ss3.t_wrap_mode = BRW_TEXCOORDMODE_CLAMP_BORDER;
  944.                 break;
  945.         case SS_EXTEND_REPEAT:
  946.                 sampler_state->ss3.r_wrap_mode = BRW_TEXCOORDMODE_WRAP;
  947.                 sampler_state->ss3.s_wrap_mode = BRW_TEXCOORDMODE_WRAP;
  948.                 sampler_state->ss3.t_wrap_mode = BRW_TEXCOORDMODE_WRAP;
  949.                 break;
  950.         case SS_EXTEND_PAD:
  951.                 sampler_state->ss3.r_wrap_mode = BRW_TEXCOORDMODE_CLAMP;
  952.                 sampler_state->ss3.s_wrap_mode = BRW_TEXCOORDMODE_CLAMP;
  953.                 sampler_state->ss3.t_wrap_mode = BRW_TEXCOORDMODE_CLAMP;
  954.                 break;
  955.         case SS_EXTEND_REFLECT:
  956.                 sampler_state->ss3.r_wrap_mode = BRW_TEXCOORDMODE_MIRROR;
  957.                 sampler_state->ss3.s_wrap_mode = BRW_TEXCOORDMODE_MIRROR;
  958.                 sampler_state->ss3.t_wrap_mode = BRW_TEXCOORDMODE_MIRROR;
  959.                 break;
  960.         }
  961.  
  962.         sampler_state->ss2.default_color_pointer =
  963.             intel_emit_reloc(sampler_state_bo, sampler_state_offset +
  964.                              offsetof(struct gen7_sampler_state, ss2),
  965.                              border_color_bo, 0,
  966.                              I915_GEM_DOMAIN_SAMPLER, 0) >> 5;
  967.  
  968.         sampler_state->ss3.chroma_key_enable = 0;       /* disable chromakey */
  969. }
  970.  
  971.  
  972.  
  973. static drm_intel_bo *gen4_create_sampler_state(intel_screen_private *intel,
  974.                                                sampler_state_filter_t src_filter,
  975.                                                sampler_state_extend_t src_extend,
  976.                                                sampler_state_filter_t mask_filter,
  977.                                                sampler_state_extend_t mask_extend,
  978.                                                drm_intel_bo * border_color_bo)
  979. {
  980.         drm_intel_bo *sampler_state_bo;
  981.         struct brw_sampler_state *sampler_state;
  982.         int ret;
  983.  
  984.         sampler_state_bo =
  985.             drm_intel_bo_alloc(intel->bufmgr, "gen4 sampler state",
  986.                                sizeof(struct brw_sampler_state) * 2, 4096);
  987.         assert(sampler_state_bo);
  988.  
  989.         ret = drm_intel_bo_map(sampler_state_bo, TRUE);
  990.         assert(ret == 0);
  991.  
  992.         sampler_state = sampler_state_bo->virtual;
  993.  
  994.         gen4_sampler_state_init(sampler_state_bo,
  995.                                 &sampler_state[0],
  996.                                 src_filter, src_extend, border_color_bo);
  997.         gen4_sampler_state_init(sampler_state_bo,
  998.                                 &sampler_state[1],
  999.                                 mask_filter, mask_extend, border_color_bo);
  1000.  
  1001.         drm_intel_bo_unmap(sampler_state_bo);
  1002.  
  1003.         return sampler_state_bo;
  1004.         (void)ret;
  1005. }
  1006.  
  1007. static drm_intel_bo *
  1008. gen7_create_sampler_state(intel_screen_private *intel,
  1009.                           sampler_state_filter_t src_filter,
  1010.                           sampler_state_extend_t src_extend,
  1011.                           sampler_state_filter_t mask_filter,
  1012.                           sampler_state_extend_t mask_extend,
  1013.                           drm_intel_bo * border_color_bo)
  1014. {
  1015.         drm_intel_bo *sampler_state_bo;
  1016.         struct gen7_sampler_state *sampler_state;
  1017.         int ret;
  1018.  
  1019.         sampler_state_bo =
  1020.             drm_intel_bo_alloc(intel->bufmgr, "gen7 sampler state",
  1021.                                sizeof(struct gen7_sampler_state) * 2, 4096);
  1022.         assert(sampler_state_bo);
  1023.  
  1024.         ret = drm_intel_bo_map(sampler_state_bo, TRUE);
  1025.         assert(ret == 0);
  1026.  
  1027.         sampler_state = sampler_state_bo->virtual;
  1028.  
  1029.         gen7_sampler_state_init(sampler_state_bo,
  1030.                                 &sampler_state[0],
  1031.                                 src_filter, src_extend, border_color_bo);
  1032.         gen7_sampler_state_init(sampler_state_bo,
  1033.                                 &sampler_state[1],
  1034.                                 mask_filter, mask_extend, border_color_bo);
  1035.  
  1036.         drm_intel_bo_unmap(sampler_state_bo);
  1037.  
  1038.         return sampler_state_bo;
  1039.         (void)ret;
  1040. }
  1041.  
  1042. static inline drm_intel_bo *
  1043. i965_create_sampler_state(intel_screen_private *intel,
  1044.                           sampler_state_filter_t src_filter,
  1045.                           sampler_state_extend_t src_extend,
  1046.                           sampler_state_filter_t mask_filter,
  1047.                           sampler_state_extend_t mask_extend,
  1048.                           drm_intel_bo * border_color_bo)
  1049. {
  1050.         if (INTEL_INFO(intel)->gen < 070)
  1051.                 return gen4_create_sampler_state(intel, src_filter, src_extend,
  1052.                                                  mask_filter, mask_extend,
  1053.                                                  border_color_bo);
  1054.         return gen7_create_sampler_state(intel, src_filter, src_extend,
  1055.                                          mask_filter, mask_extend,
  1056.                                          border_color_bo);
  1057. }
  1058.  
  1059.  
  1060. static void
  1061. cc_state_init(drm_intel_bo * cc_state_bo,
  1062.               uint32_t cc_state_offset,
  1063.               int src_blend, int dst_blend, drm_intel_bo * cc_vp_bo)
  1064. {
  1065.         struct brw_cc_unit_state *cc_state;
  1066.  
  1067.         cc_state = (struct brw_cc_unit_state *)((char *)cc_state_bo->virtual +
  1068.                                                 cc_state_offset);
  1069.  
  1070.         memset(cc_state, 0, sizeof(*cc_state));
  1071.         cc_state->cc0.stencil_enable = 0;       /* disable stencil */
  1072.         cc_state->cc2.depth_test = 0;   /* disable depth test */
  1073.         cc_state->cc2.logicop_enable = 0;       /* disable logic op */
  1074.         cc_state->cc3.ia_blend_enable = 0;      /* blend alpha same as colors */
  1075.         cc_state->cc3.blend_enable = 1; /* enable color blend */
  1076.         cc_state->cc3.alpha_test = 0;   /* disable alpha test */
  1077.  
  1078.         cc_state->cc4.cc_viewport_state_offset =
  1079.             intel_emit_reloc(cc_state_bo, cc_state_offset +
  1080.                              offsetof(struct brw_cc_unit_state, cc4),
  1081.                              cc_vp_bo, 0, I915_GEM_DOMAIN_INSTRUCTION, 0) >> 5;
  1082.  
  1083.         cc_state->cc5.dither_enable = 0;        /* disable dither */
  1084.         cc_state->cc5.logicop_func = 0xc;       /* COPY */
  1085.         cc_state->cc5.statistics_enable = 1;
  1086.         cc_state->cc5.ia_blend_function = BRW_BLENDFUNCTION_ADD;
  1087.  
  1088.         /* Fill in alpha blend factors same as color, for the future. */
  1089.         cc_state->cc5.ia_src_blend_factor = src_blend;
  1090.         cc_state->cc5.ia_dest_blend_factor = dst_blend;
  1091.  
  1092.         cc_state->cc6.blend_function = BRW_BLENDFUNCTION_ADD;
  1093.         cc_state->cc6.clamp_post_alpha_blend = 1;
  1094.         cc_state->cc6.clamp_pre_alpha_blend = 1;
  1095.         cc_state->cc6.clamp_range = 0;  /* clamp range [0,1] */
  1096.  
  1097.         cc_state->cc6.src_blend_factor = src_blend;
  1098.         cc_state->cc6.dest_blend_factor = dst_blend;
  1099. }
  1100.  
  1101. static drm_intel_bo *gen4_create_wm_state(intel_screen_private *intel,
  1102.                                           Bool has_mask,
  1103.                                           drm_intel_bo * kernel_bo,
  1104.                                           drm_intel_bo * sampler_bo)
  1105. {
  1106.         struct brw_wm_unit_state *state;
  1107.         drm_intel_bo *wm_state_bo;
  1108.         int ret;
  1109.  
  1110.         wm_state_bo = drm_intel_bo_alloc(intel->bufmgr, "gen4 WM state",
  1111.                                          sizeof(*state), 4096);
  1112.         assert(wm_state_bo);
  1113.  
  1114.         ret = drm_intel_bo_map(wm_state_bo, TRUE);
  1115.         assert(ret == 0);
  1116.  
  1117.         state = memset(wm_state_bo->virtual, 0, sizeof(*state));
  1118.         state->thread0.grf_reg_count = BRW_GRF_BLOCKS(PS_KERNEL_NUM_GRF);
  1119.         state->thread0.kernel_start_pointer =
  1120.             intel_emit_reloc(wm_state_bo,
  1121.                              offsetof(struct brw_wm_unit_state, thread0),
  1122.                              kernel_bo, state->thread0.grf_reg_count << 1,
  1123.                              I915_GEM_DOMAIN_INSTRUCTION, 0) >> 6;
  1124.  
  1125.         state->thread1.single_program_flow = 0;
  1126.  
  1127.         /* scratch space is not used in our kernel */
  1128.         state->thread2.scratch_space_base_pointer = 0;
  1129.         state->thread2.per_thread_scratch_space = 0;
  1130.  
  1131.         state->thread3.const_urb_entry_read_length = 0;
  1132.         state->thread3.const_urb_entry_read_offset = 0;
  1133.  
  1134.         state->thread3.urb_entry_read_offset = 0;
  1135.         /* wm kernel use urb from 3, see wm_program in compiler module */
  1136.         state->thread3.dispatch_grf_start_reg = 3;      /* must match kernel */
  1137.  
  1138.         if (IS_GEN5(intel))
  1139.                 state->wm4.sampler_count = 0;   /* hardware requirement */
  1140.         else
  1141.                 state->wm4.sampler_count = 1;   /* 1-4 samplers used */
  1142.  
  1143.         state->wm4.sampler_state_pointer =
  1144.             intel_emit_reloc(wm_state_bo,
  1145.                              offsetof(struct brw_wm_unit_state, wm4),
  1146.                              sampler_bo,
  1147.                              state->wm4.sampler_count << 2,
  1148.                              I915_GEM_DOMAIN_INSTRUCTION, 0) >> 5;
  1149.         state->wm5.max_threads = PS_MAX_THREADS - 1;
  1150.         state->wm5.transposed_urb_read = 0;
  1151.         state->wm5.thread_dispatch_enable = 1;
  1152.         /* just use 16-pixel dispatch (4 subspans), don't need to change kernel
  1153.          * start point
  1154.          */
  1155.         state->wm5.enable_16_pix = 1;
  1156.         state->wm5.enable_8_pix = 0;
  1157.         state->wm5.early_depth_test = 1;
  1158.  
  1159.         /* Each pair of attributes (src/mask coords) is two URB entries */
  1160.         if (has_mask) {
  1161.                 state->thread1.binding_table_entry_count = 3;   /* 2 tex and fb */
  1162.                 state->thread3.urb_entry_read_length = 4;
  1163.         } else {
  1164.                 state->thread1.binding_table_entry_count = 2;   /* 1 tex and fb */
  1165.                 state->thread3.urb_entry_read_length = 2;
  1166.         }
  1167.  
  1168.         /* binding table entry count is only used for prefetching, and it has to
  1169.          * be set 0 for Ironlake
  1170.          */
  1171.         if (IS_GEN5(intel))
  1172.                 state->thread1.binding_table_entry_count = 0;
  1173.  
  1174.         drm_intel_bo_unmap(wm_state_bo);
  1175.  
  1176.         return wm_state_bo;
  1177.         (void)ret;
  1178. }
  1179.  
  1180. static drm_intel_bo *gen4_create_cc_viewport(intel_screen_private *intel)
  1181. {
  1182.         drm_intel_bo *bo;
  1183.         struct brw_cc_viewport vp;
  1184.         int ret;
  1185.  
  1186.         vp.min_depth = -1.e35;
  1187.         vp.max_depth = 1.e35;
  1188.  
  1189.         bo = drm_intel_bo_alloc(intel->bufmgr, "gen4 render unit state",
  1190.                                 sizeof(vp), 4096);
  1191.         assert(bo);
  1192.  
  1193.         ret = drm_intel_bo_subdata(bo, 0, sizeof(vp), &vp);
  1194.         assert(ret == 0);
  1195.  
  1196.         return bo;
  1197.         (void)ret;
  1198. }
  1199.  
  1200. static drm_intel_bo *gen4_create_vs_unit_state(intel_screen_private *intel)
  1201. {
  1202.         struct brw_vs_unit_state vs_state;
  1203.         memset(&vs_state, 0, sizeof(vs_state));
  1204.  
  1205.         /* Set up the vertex shader to be disabled (passthrough) */
  1206.         if (IS_GEN5(intel))
  1207.                 vs_state.thread4.nr_urb_entries = URB_VS_ENTRIES >> 2;  /* hardware requirement */
  1208.         else
  1209.                 vs_state.thread4.nr_urb_entries = URB_VS_ENTRIES;
  1210.         vs_state.thread4.urb_entry_allocation_size = URB_VS_ENTRY_SIZE - 1;
  1211.         vs_state.vs6.vs_enable = 0;
  1212.         vs_state.vs6.vert_cache_disable = 1;
  1213.  
  1214.         return intel_bo_alloc_for_data(intel, &vs_state, sizeof(vs_state),
  1215.                                        "gen4 render VS state");
  1216. }
  1217.  
  1218. /**
  1219.  * Set up all combinations of cc state: each blendfactor for source and
  1220.  * dest.
  1221.  */
  1222. static drm_intel_bo *gen4_create_cc_unit_state(intel_screen_private *intel)
  1223. {
  1224.         drm_intel_bo *cc_state_bo, *cc_vp_bo;
  1225.         int i, j, ret;
  1226.  
  1227.         cc_vp_bo = gen4_create_cc_viewport(intel);
  1228.  
  1229.         cc_state_bo = drm_intel_bo_alloc(intel->bufmgr, "gen4 CC state",
  1230.                                          sizeof(struct gen4_cc_unit_state),
  1231.                                          4096);
  1232.         assert(cc_state_bo);
  1233.  
  1234.         ret = drm_intel_bo_map(cc_state_bo, TRUE);
  1235.         assert(ret == 0);
  1236.  
  1237.         for (i = 0; i < BRW_BLENDFACTOR_COUNT; i++) {
  1238.                 for (j = 0; j < BRW_BLENDFACTOR_COUNT; j++) {
  1239.                         cc_state_init(cc_state_bo,
  1240.                                       offsetof(struct gen4_cc_unit_state,
  1241.                                                cc_state[i][j].state),
  1242.                                       i, j, cc_vp_bo);
  1243.                 }
  1244.         }
  1245.         drm_intel_bo_unmap(cc_state_bo);
  1246.  
  1247.         drm_intel_bo_unreference(cc_vp_bo);
  1248.  
  1249.         return cc_state_bo;
  1250.         (void)ret;
  1251. }
  1252.  
  1253. static uint32_t i965_get_card_format(PicturePtr picture)
  1254. {
  1255.         int i;
  1256.  
  1257.         for (i = 0; i < sizeof(i965_tex_formats) / sizeof(i965_tex_formats[0]);
  1258.              i++) {
  1259.                 if (i965_tex_formats[i].fmt == picture->format)
  1260.                         break;
  1261.         }
  1262.         assert(i != sizeof(i965_tex_formats) / sizeof(i965_tex_formats[0]));
  1263.  
  1264.         return i965_tex_formats[i].card_fmt;
  1265. }
  1266.  
  1267. static sampler_state_filter_t sampler_state_filter_from_picture(int filter)
  1268. {
  1269.         switch (filter) {
  1270.         case PictFilterNearest:
  1271.                 return SS_FILTER_NEAREST;
  1272.         case PictFilterBilinear:
  1273.                 return SS_FILTER_BILINEAR;
  1274.         default:
  1275.                 return SS_INVALID_FILTER;
  1276.         }
  1277. }
  1278.  
  1279. static sampler_state_extend_t sampler_state_extend_from_picture(int repeat_type)
  1280. {
  1281.         switch (repeat_type) {
  1282.         case RepeatNone:
  1283.                 return SS_EXTEND_NONE;
  1284.         case RepeatNormal:
  1285.                 return SS_EXTEND_REPEAT;
  1286.         case RepeatPad:
  1287.                 return SS_EXTEND_PAD;
  1288.         case RepeatReflect:
  1289.                 return SS_EXTEND_REFLECT;
  1290.         default:
  1291.                 return SS_INVALID_EXTEND;
  1292.         }
  1293. }
  1294.  
  1295. /**
  1296.  * Sets up the common fields for a surface state buffer for the given
  1297.  * picture in the given surface state buffer.
  1298.  */
  1299. static int
  1300. gen4_set_picture_surface_state(intel_screen_private *intel,
  1301.                                PicturePtr picture, PixmapPtr pixmap,
  1302.                                Bool is_dst)
  1303. {
  1304.         struct intel_pixmap *priv = pixmap->private;
  1305.         struct brw_surface_state *ss;
  1306.         uint32_t write_domain, read_domains;
  1307.         int offset;
  1308.  
  1309.         if (is_dst) {
  1310.                 write_domain = I915_GEM_DOMAIN_RENDER;
  1311.                 read_domains = I915_GEM_DOMAIN_RENDER;
  1312.         } else {
  1313.                 write_domain = 0;
  1314.                 read_domains = I915_GEM_DOMAIN_SAMPLER;
  1315.         }
  1316.         intel_batch_mark_pixmap_domains(intel, priv,
  1317.                                         read_domains, write_domain);
  1318.         ss = (struct brw_surface_state *)
  1319.                 (intel->surface_data + intel->surface_used);
  1320.  
  1321.         memset(ss, 0, sizeof(*ss));
  1322.         ss->ss0.surface_type = BRW_SURFACE_2D;
  1323.         if (is_dst)
  1324.                 ss->ss0.surface_format = i965_get_dest_format(picture);
  1325.         else
  1326.                 ss->ss0.surface_format = i965_get_card_format(picture);
  1327.  
  1328.         ss->ss0.data_return_format = BRW_SURFACERETURNFORMAT_FLOAT32;
  1329.         ss->ss0.color_blend = 1;
  1330.         ss->ss1.base_addr = priv->bo->offset;
  1331.  
  1332.         ss->ss2.height = pixmap->drawable.height - 1;
  1333.         ss->ss2.width = pixmap->drawable.width - 1;
  1334.         ss->ss3.pitch = intel_pixmap_pitch(pixmap) - 1;
  1335.         ss->ss3.tile_walk = 0;  /* Tiled X */
  1336.         ss->ss3.tiled_surface = intel_pixmap_tiled(pixmap) ? 1 : 0;
  1337.  
  1338.         dri_bo_emit_reloc(intel->surface_bo,
  1339.                           read_domains, write_domain,
  1340.                           0,
  1341.                           intel->surface_used +
  1342.                           offsetof(struct brw_surface_state, ss1),
  1343.                           priv->bo);
  1344.  
  1345.         offset = intel->surface_used;
  1346.         intel->surface_used += SURFACE_STATE_PADDED_SIZE;
  1347.  
  1348.         return offset;
  1349. }
  1350.  
  1351. static int
  1352. gen7_set_picture_surface_state(intel_screen_private *intel,
  1353.                                PicturePtr picture, PixmapPtr pixmap,
  1354.                                Bool is_dst)
  1355. {
  1356.         struct intel_pixmap *priv = pixmap->private;
  1357.         struct gen7_surface_state *ss;
  1358.         uint32_t write_domain, read_domains;
  1359.         int offset;
  1360.  
  1361.         if (is_dst) {
  1362.                 write_domain = I915_GEM_DOMAIN_RENDER;
  1363.                 read_domains = I915_GEM_DOMAIN_RENDER;
  1364.         } else {
  1365.                 write_domain = 0;
  1366.                 read_domains = I915_GEM_DOMAIN_SAMPLER;
  1367.         }
  1368.         intel_batch_mark_pixmap_domains(intel, priv,
  1369.                                         read_domains, write_domain);
  1370.         ss = (struct gen7_surface_state *)
  1371.                 (intel->surface_data + intel->surface_used);
  1372.  
  1373.         memset(ss, 0, sizeof(*ss));
  1374.         ss->ss0.surface_type = BRW_SURFACE_2D;
  1375.         if (is_dst)
  1376.                 ss->ss0.surface_format = i965_get_dest_format(picture);
  1377.         else
  1378.                 ss->ss0.surface_format = i965_get_card_format(picture);
  1379.  
  1380.         ss->ss0.tile_walk = 0;  /* Tiled X */
  1381.         ss->ss0.tiled_surface = intel_pixmap_tiled(pixmap) ? 1 : 0;
  1382.         ss->ss1.base_addr = priv->bo->offset;
  1383.  
  1384.         ss->ss2.height = pixmap->drawable.height - 1;
  1385.         ss->ss2.width = pixmap->drawable.width - 1;
  1386.         ss->ss3.pitch = intel_pixmap_pitch(pixmap) - 1;
  1387.  
  1388.         if (IS_HSW(intel)) {
  1389.                 ss->ss7.shader_chanel_select_r = HSW_SCS_RED;
  1390.                 ss->ss7.shader_chanel_select_g = HSW_SCS_GREEN;
  1391.                 ss->ss7.shader_chanel_select_b = HSW_SCS_BLUE;
  1392.                 ss->ss7.shader_chanel_select_a = HSW_SCS_ALPHA;
  1393.         }
  1394.  
  1395.         dri_bo_emit_reloc(intel->surface_bo,
  1396.                           read_domains, write_domain,
  1397.                           0,
  1398.                           intel->surface_used +
  1399.                           offsetof(struct gen7_surface_state, ss1),
  1400.                           priv->bo);
  1401.  
  1402.         offset = intel->surface_used;
  1403.         intel->surface_used += SURFACE_STATE_PADDED_SIZE;
  1404.  
  1405.         return offset;
  1406. }
  1407.  
  1408. static inline int
  1409. i965_set_picture_surface_state(intel_screen_private *intel,
  1410.                                PicturePtr picture, PixmapPtr pixmap,
  1411.                                Bool is_dst)
  1412. {
  1413.     if (INTEL_INFO(intel)->gen < 070)
  1414.         return gen4_set_picture_surface_state(intel, picture, pixmap, is_dst);
  1415.     return gen7_set_picture_surface_state(intel, picture, pixmap, is_dst);
  1416. }
  1417.  
  1418. static void gen4_composite_vertex_elements(struct intel_screen_private *intel)
  1419. {
  1420.         struct gen4_render_state *render_state = intel->gen4_render_state;
  1421.         gen4_composite_op *composite_op = &render_state->composite_op;
  1422.         Bool has_mask = intel->render_mask != NULL;
  1423.         Bool is_affine = composite_op->is_affine;
  1424.         /*
  1425.          * number of extra parameters per vertex
  1426.          */
  1427.         int nelem = has_mask ? 2 : 1;
  1428.         /*
  1429.          * size of extra parameters:
  1430.          *  3 for homogenous (xyzw)
  1431.          *  2 for cartesian (xy)
  1432.          */
  1433.         int selem = is_affine ? 2 : 3;
  1434.         uint32_t w_component;
  1435.         uint32_t src_format;
  1436.         int id;
  1437.  
  1438.         id = has_mask << 1 | is_affine;
  1439.  
  1440.         if (composite_op->vertex_id == id)
  1441.                 return;
  1442.  
  1443.         composite_op->vertex_id = id;
  1444.  
  1445.         if (is_affine) {
  1446.                 src_format = BRW_SURFACEFORMAT_R32G32_FLOAT;
  1447.                 w_component = BRW_VFCOMPONENT_STORE_1_FLT;
  1448.         } else {
  1449.                 src_format = BRW_SURFACEFORMAT_R32G32B32_FLOAT;
  1450.                 w_component = BRW_VFCOMPONENT_STORE_SRC;
  1451.         }
  1452.  
  1453.         if (IS_GEN5(intel)) {
  1454.                 /*
  1455.                  * The reason to add this extra vertex element in the header is that
  1456.                  * Ironlake has different vertex header definition and origin method to
  1457.                  * set destination element offset doesn't exist anymore, which means
  1458.                  * hardware requires a predefined vertex element layout.
  1459.                  *
  1460.                  * haihao proposed this approach to fill the first vertex element, so
  1461.                  * origin layout for Gen4 doesn't need to change, and origin shader
  1462.                  * programs behavior is also kept.
  1463.                  *
  1464.                  * I think this is not bad. - zhenyu
  1465.                  */
  1466.  
  1467.                 OUT_BATCH(BRW_3DSTATE_VERTEX_ELEMENTS |
  1468.                           ((2 * (2 + nelem)) - 1));
  1469.                 OUT_BATCH((id << VE0_VERTEX_BUFFER_INDEX_SHIFT) | VE0_VALID |
  1470.                           (BRW_SURFACEFORMAT_R32G32_FLOAT << VE0_FORMAT_SHIFT) |
  1471.                           (0 << VE0_OFFSET_SHIFT));
  1472.  
  1473.                 OUT_BATCH((BRW_VFCOMPONENT_STORE_0 << VE1_VFCOMPONENT_0_SHIFT) |
  1474.                           (BRW_VFCOMPONENT_STORE_0 << VE1_VFCOMPONENT_1_SHIFT) |
  1475.                           (BRW_VFCOMPONENT_STORE_0 << VE1_VFCOMPONENT_2_SHIFT) |
  1476.                           (BRW_VFCOMPONENT_STORE_0 << VE1_VFCOMPONENT_3_SHIFT));
  1477.         } else {
  1478.                 /* Set up our vertex elements, sourced from the single vertex buffer.
  1479.                  * that will be set up later.
  1480.                  */
  1481.                 OUT_BATCH(BRW_3DSTATE_VERTEX_ELEMENTS |
  1482.                           ((2 * (1 + nelem)) - 1));
  1483.         }
  1484.  
  1485.         /* x,y */
  1486.         OUT_BATCH((id << VE0_VERTEX_BUFFER_INDEX_SHIFT) | VE0_VALID |
  1487.                   (BRW_SURFACEFORMAT_R32G32_FLOAT << VE0_FORMAT_SHIFT) |
  1488.                   (0 << VE0_OFFSET_SHIFT));
  1489.  
  1490.         if (IS_GEN5(intel))
  1491.                 OUT_BATCH((BRW_VFCOMPONENT_STORE_SRC << VE1_VFCOMPONENT_0_SHIFT) |
  1492.                           (BRW_VFCOMPONENT_STORE_SRC << VE1_VFCOMPONENT_1_SHIFT) |
  1493.                           (BRW_VFCOMPONENT_STORE_1_FLT << VE1_VFCOMPONENT_2_SHIFT) |
  1494.                           (BRW_VFCOMPONENT_STORE_1_FLT << VE1_VFCOMPONENT_3_SHIFT));
  1495.         else
  1496.                 OUT_BATCH((BRW_VFCOMPONENT_STORE_SRC << VE1_VFCOMPONENT_0_SHIFT) |
  1497.                           (BRW_VFCOMPONENT_STORE_SRC << VE1_VFCOMPONENT_1_SHIFT) |
  1498.                           (BRW_VFCOMPONENT_STORE_1_FLT << VE1_VFCOMPONENT_2_SHIFT) |
  1499.                           (BRW_VFCOMPONENT_STORE_1_FLT << VE1_VFCOMPONENT_3_SHIFT) |
  1500.                           (4 << VE1_DESTINATION_ELEMENT_OFFSET_SHIFT));
  1501.         /* u0, v0, w0 */
  1502.         OUT_BATCH((id << VE0_VERTEX_BUFFER_INDEX_SHIFT) | VE0_VALID |
  1503.                   (src_format << VE0_FORMAT_SHIFT) |
  1504.                   ((2 * 4) << VE0_OFFSET_SHIFT));       /* offset vb in bytes */
  1505.  
  1506.         if (IS_GEN5(intel))
  1507.                 OUT_BATCH((BRW_VFCOMPONENT_STORE_SRC << VE1_VFCOMPONENT_0_SHIFT) |
  1508.                           (BRW_VFCOMPONENT_STORE_SRC << VE1_VFCOMPONENT_1_SHIFT) |
  1509.                           (w_component << VE1_VFCOMPONENT_2_SHIFT) |
  1510.                           (BRW_VFCOMPONENT_STORE_1_FLT << VE1_VFCOMPONENT_3_SHIFT));
  1511.         else
  1512.                 OUT_BATCH((BRW_VFCOMPONENT_STORE_SRC << VE1_VFCOMPONENT_0_SHIFT) |
  1513.                           (BRW_VFCOMPONENT_STORE_SRC << VE1_VFCOMPONENT_1_SHIFT) |
  1514.                           (w_component << VE1_VFCOMPONENT_2_SHIFT) |
  1515.                           (BRW_VFCOMPONENT_STORE_1_FLT << VE1_VFCOMPONENT_3_SHIFT) |
  1516.                           ((4 + 4) << VE1_DESTINATION_ELEMENT_OFFSET_SHIFT));   /* VUE offset in dwords */
  1517.         /* u1, v1, w1 */
  1518.         if (has_mask) {
  1519.                 OUT_BATCH((id << VE0_VERTEX_BUFFER_INDEX_SHIFT) | VE0_VALID |
  1520.                           (src_format << VE0_FORMAT_SHIFT) |
  1521.                           (((2 + selem) * 4) << VE0_OFFSET_SHIFT));     /* vb offset in bytes */
  1522.  
  1523.                 if (IS_GEN5(intel))
  1524.                         OUT_BATCH((BRW_VFCOMPONENT_STORE_SRC << VE1_VFCOMPONENT_0_SHIFT) |
  1525.                                   (BRW_VFCOMPONENT_STORE_SRC << VE1_VFCOMPONENT_1_SHIFT) |
  1526.                                   (w_component << VE1_VFCOMPONENT_2_SHIFT) |
  1527.                                   (BRW_VFCOMPONENT_STORE_1_FLT << VE1_VFCOMPONENT_3_SHIFT));
  1528.                 else
  1529.                         OUT_BATCH((BRW_VFCOMPONENT_STORE_SRC << VE1_VFCOMPONENT_0_SHIFT) |
  1530.                                   (BRW_VFCOMPONENT_STORE_SRC << VE1_VFCOMPONENT_1_SHIFT) |
  1531.                                   (w_component << VE1_VFCOMPONENT_2_SHIFT) |
  1532.                                   (BRW_VFCOMPONENT_STORE_1_FLT << VE1_VFCOMPONENT_3_SHIFT) |
  1533.                                   ((4 + 4 + 4) << VE1_DESTINATION_ELEMENT_OFFSET_SHIFT));       /* VUE offset in dwords */
  1534.         }
  1535. }
  1536.  
  1537. static void i965_emit_composite_state(struct intel_screen_private *intel)
  1538. {
  1539.         struct gen4_render_state *render_state = intel->gen4_render_state;
  1540.         gen4_composite_op *composite_op = &render_state->composite_op;
  1541.         int op = composite_op->op;
  1542.         PicturePtr mask_picture = intel->render_mask_picture;
  1543.         PicturePtr dest_picture = intel->render_dest_picture;
  1544.         PixmapPtr mask = intel->render_mask;
  1545.         PixmapPtr dest = intel->render_dest;
  1546.         sampler_state_filter_t src_filter = composite_op->src_filter;
  1547.         sampler_state_filter_t mask_filter = composite_op->mask_filter;
  1548.         sampler_state_extend_t src_extend = composite_op->src_extend;
  1549.         sampler_state_extend_t mask_extend = composite_op->mask_extend;
  1550.         uint32_t src_blend, dst_blend;
  1551.  
  1552.         intel->needs_render_state_emit = FALSE;
  1553.  
  1554.         /* Begin the long sequence of commands needed to set up the 3D
  1555.          * rendering pipe
  1556.          */
  1557.  
  1558.         if (intel->needs_3d_invariant) {
  1559.                 if (IS_GEN5(intel)) {
  1560.                         /* Ironlake errata workaround: Before disabling the clipper,
  1561.                          * you have to MI_FLUSH to get the pipeline idle.
  1562.                          */
  1563.                         OUT_BATCH(MI_FLUSH | MI_INHIBIT_RENDER_CACHE_FLUSH);
  1564.                 }
  1565.  
  1566.                 /* Match Mesa driver setup */
  1567.                 if (INTEL_INFO(intel)->gen >= 045)
  1568.                         OUT_BATCH(NEW_PIPELINE_SELECT | PIPELINE_SELECT_3D);
  1569.                 else
  1570.                         OUT_BATCH(BRW_PIPELINE_SELECT | PIPELINE_SELECT_3D);
  1571.  
  1572.                 /* Set system instruction pointer */
  1573.                 OUT_BATCH(BRW_STATE_SIP | 0);
  1574.                 OUT_BATCH(0);
  1575.  
  1576.                 intel->needs_3d_invariant = FALSE;
  1577.         }
  1578.  
  1579.         if (intel->surface_reloc == 0) {
  1580.                 /* Zero out the two base address registers so all offsets are
  1581.                  * absolute.
  1582.                  */
  1583.                 if (IS_GEN5(intel)) {
  1584.                         OUT_BATCH(BRW_STATE_BASE_ADDRESS | 6);
  1585.                         OUT_BATCH(0 | BASE_ADDRESS_MODIFY);     /* Generate state base address */
  1586.                         intel->surface_reloc = intel->batch_used;
  1587.                         intel_batch_emit_dword(intel,
  1588.                                                intel->surface_bo->offset | BASE_ADDRESS_MODIFY);
  1589.                         OUT_BATCH(0 | BASE_ADDRESS_MODIFY);     /* media base addr, don't care */
  1590.                         OUT_BATCH(0 | BASE_ADDRESS_MODIFY);     /* Instruction base address */
  1591.                         /* general state max addr, disabled */
  1592.                         OUT_BATCH(0 | BASE_ADDRESS_MODIFY);
  1593.                         /* media object state max addr, disabled */
  1594.                         OUT_BATCH(0 | BASE_ADDRESS_MODIFY);
  1595.                         /* Instruction max addr, disabled */
  1596.                         OUT_BATCH(0 | BASE_ADDRESS_MODIFY);
  1597.                 } else {
  1598.                         OUT_BATCH(BRW_STATE_BASE_ADDRESS | 4);
  1599.                         OUT_BATCH(0 | BASE_ADDRESS_MODIFY);     /* Generate state base address */
  1600.                         intel->surface_reloc = intel->batch_used;
  1601.                         intel_batch_emit_dword(intel,
  1602.                                                intel->surface_bo->offset | BASE_ADDRESS_MODIFY);
  1603.                         OUT_BATCH(0 | BASE_ADDRESS_MODIFY);     /* media base addr, don't care */
  1604.                         /* general state max addr, disabled */
  1605.                         OUT_BATCH(0 | BASE_ADDRESS_MODIFY);
  1606.                         /* media object state max addr, disabled */
  1607.                         OUT_BATCH(0 | BASE_ADDRESS_MODIFY);
  1608.                 }
  1609.         }
  1610.  
  1611.         i965_get_blend_cntl(op, mask_picture, dest_picture->format,
  1612.                             &src_blend, &dst_blend);
  1613.  
  1614.         /* Binding table pointers */
  1615.         OUT_BATCH(BRW_3DSTATE_BINDING_TABLE_POINTERS | 4);
  1616.         OUT_BATCH(0);   /* vs */
  1617.         OUT_BATCH(0);   /* gs */
  1618.         OUT_BATCH(0);   /* clip */
  1619.         OUT_BATCH(0);   /* sf */
  1620.         /* Only the PS uses the binding table */
  1621.         OUT_BATCH(intel->surface_table);
  1622.  
  1623.         /* The drawing rectangle clipping is always on.  Set it to values that
  1624.          * shouldn't do any clipping.
  1625.          */
  1626.         OUT_BATCH(BRW_3DSTATE_DRAWING_RECTANGLE | 2);
  1627.         OUT_BATCH(0x00000000);  /* ymin, xmin */
  1628.         OUT_BATCH(DRAW_YMAX(dest->drawable.height - 1) |
  1629.                   DRAW_XMAX(dest->drawable.width - 1)); /* ymax, xmax */
  1630.         OUT_BATCH(0x00000000);  /* yorigin, xorigin */
  1631.  
  1632.         /* skip the depth buffer */
  1633.         /* skip the polygon stipple */
  1634.         /* skip the polygon stipple offset */
  1635.         /* skip the line stipple */
  1636.  
  1637.         /* Set the pointers to the 3d pipeline state */
  1638.         OUT_BATCH(BRW_3DSTATE_PIPELINED_POINTERS | 5);
  1639.         OUT_RELOC(render_state->vs_state_bo,
  1640.                   I915_GEM_DOMAIN_INSTRUCTION, 0, 0);
  1641.         OUT_BATCH(BRW_GS_DISABLE);      /* disable GS, resulting in passthrough */
  1642.         OUT_BATCH(BRW_CLIP_DISABLE);    /* disable CLIP, resulting in passthrough */
  1643.         if (mask) {
  1644.                 OUT_RELOC(render_state->sf_mask_state_bo,
  1645.                           I915_GEM_DOMAIN_INSTRUCTION, 0, 0);
  1646.         } else {
  1647.                 OUT_RELOC(render_state->sf_state_bo,
  1648.                           I915_GEM_DOMAIN_INSTRUCTION, 0, 0);
  1649.         }
  1650.  
  1651.         OUT_RELOC(render_state->wm_state_bo[composite_op->wm_kernel]
  1652.                   [src_filter][src_extend]
  1653.                   [mask_filter][mask_extend],
  1654.                   I915_GEM_DOMAIN_INSTRUCTION, 0, 0);
  1655.  
  1656.         OUT_RELOC(render_state->cc_state_bo,
  1657.                   I915_GEM_DOMAIN_INSTRUCTION, 0,
  1658.                   offsetof(struct gen4_cc_unit_state,
  1659.                            cc_state[src_blend][dst_blend]));
  1660.  
  1661.         {
  1662.                 int urb_vs_start, urb_vs_size;
  1663.                 int urb_gs_start, urb_gs_size;
  1664.                 int urb_clip_start, urb_clip_size;
  1665.                 int urb_sf_start, urb_sf_size;
  1666.                 int urb_cs_start, urb_cs_size;
  1667.  
  1668.                 urb_vs_start = 0;
  1669.                 urb_vs_size = URB_VS_ENTRIES * URB_VS_ENTRY_SIZE;
  1670.                 urb_gs_start = urb_vs_start + urb_vs_size;
  1671.                 urb_gs_size = URB_GS_ENTRIES * URB_GS_ENTRY_SIZE;
  1672.                 urb_clip_start = urb_gs_start + urb_gs_size;
  1673.                 urb_clip_size = URB_CLIP_ENTRIES * URB_CLIP_ENTRY_SIZE;
  1674.                 urb_sf_start = urb_clip_start + urb_clip_size;
  1675.                 urb_sf_size = URB_SF_ENTRIES * URB_SF_ENTRY_SIZE;
  1676.                 urb_cs_start = urb_sf_start + urb_sf_size;
  1677.                 urb_cs_size = URB_CS_ENTRIES * URB_CS_ENTRY_SIZE;
  1678.  
  1679.                 /* Erratum (Vol 1a, p32):
  1680.                  *   URB_FENCE must not cross a cache-line (64 bytes).
  1681.                  */
  1682.                 if ((intel->batch_used & 15) > (16 - 3)) {
  1683.                         int cnt = 16 - (intel->batch_used & 15);
  1684.                         while (cnt--)
  1685.                                 OUT_BATCH(MI_NOOP);
  1686.                 }
  1687.  
  1688.                 OUT_BATCH(BRW_URB_FENCE |
  1689.                           UF0_CS_REALLOC |
  1690.                           UF0_SF_REALLOC |
  1691.                           UF0_CLIP_REALLOC |
  1692.                           UF0_GS_REALLOC |
  1693.                           UF0_VS_REALLOC |
  1694.                           1);
  1695.                 OUT_BATCH(((urb_clip_start + urb_clip_size) << UF1_CLIP_FENCE_SHIFT) |
  1696.                           ((urb_gs_start + urb_gs_size) << UF1_GS_FENCE_SHIFT) |
  1697.                           ((urb_vs_start + urb_vs_size) << UF1_VS_FENCE_SHIFT));
  1698.                 OUT_BATCH(((urb_cs_start + urb_cs_size) << UF2_CS_FENCE_SHIFT) |
  1699.                           ((urb_sf_start + urb_sf_size) << UF2_SF_FENCE_SHIFT));
  1700.  
  1701.                 /* Constant buffer state */
  1702.                 OUT_BATCH(BRW_CS_URB_STATE | 0);
  1703.                 OUT_BATCH(((URB_CS_ENTRY_SIZE - 1) << 4) |
  1704.                           (URB_CS_ENTRIES << 0));
  1705.         }
  1706.  
  1707.         gen4_composite_vertex_elements(intel);
  1708. }
  1709.  
  1710. /**
  1711.  * Returns whether the current set of composite state plus vertex buffer is
  1712.  * expected to fit in the aperture.
  1713.  */
  1714. static Bool i965_composite_check_aperture(intel_screen_private *intel)
  1715. {
  1716.         struct gen4_render_state *render_state = intel->gen4_render_state;
  1717.         gen4_composite_op *composite_op = &render_state->composite_op;
  1718.         drm_intel_bo *bo_table[] = {
  1719.                 intel->batch_bo,
  1720.                 intel->vertex_bo,
  1721.                 intel->surface_bo,
  1722.                 render_state->vs_state_bo,
  1723.                 render_state->sf_state_bo,
  1724.                 render_state->sf_mask_state_bo,
  1725.                 render_state->wm_state_bo[composite_op->wm_kernel]
  1726.                     [composite_op->src_filter]
  1727.                     [composite_op->src_extend]
  1728.                     [composite_op->mask_filter]
  1729.                     [composite_op->mask_extend],
  1730.                 render_state->cc_state_bo,
  1731.         };
  1732.         drm_intel_bo *gen6_bo_table[] = {
  1733.                 intel->batch_bo,
  1734.                 intel->vertex_bo,
  1735.                 intel->surface_bo,
  1736.                 render_state->wm_kernel_bo[composite_op->wm_kernel],
  1737.                 render_state->ps_sampler_state_bo[composite_op->src_filter]
  1738.                     [composite_op->src_extend]
  1739.                     [composite_op->mask_filter]
  1740.                     [composite_op->mask_extend],
  1741.                 render_state->cc_vp_bo,
  1742.                 render_state->cc_state_bo,
  1743.                 render_state->gen6_blend_bo,
  1744.                 render_state->gen6_depth_stencil_bo,
  1745.         };
  1746.  
  1747.         if (INTEL_INFO(intel)->gen >= 060)
  1748.                 return drm_intel_bufmgr_check_aperture_space(gen6_bo_table,
  1749.                                                         ARRAY_SIZE(gen6_bo_table)) == 0;
  1750.         else
  1751.                 return drm_intel_bufmgr_check_aperture_space(bo_table,
  1752.                                                         ARRAY_SIZE(bo_table)) == 0;
  1753. }
  1754.  
  1755. static void i965_surface_flush(struct intel_screen_private *intel)
  1756. {
  1757.         int ret;
  1758.  
  1759.         ret = drm_intel_bo_subdata(intel->surface_bo,
  1760.                                    0, intel->surface_used,
  1761.                                    intel->surface_data);
  1762.         assert(ret == 0);
  1763.         intel->surface_used = 0;
  1764.  
  1765.         assert (intel->surface_reloc != 0);
  1766.         drm_intel_bo_emit_reloc(intel->batch_bo,
  1767.                                 intel->surface_reloc * 4,
  1768.                                 intel->surface_bo, BASE_ADDRESS_MODIFY,
  1769.                                 I915_GEM_DOMAIN_INSTRUCTION, 0);
  1770.         intel->surface_reloc = 0;
  1771.  
  1772.         drm_intel_bo_unreference(intel->surface_bo);
  1773.         intel->surface_bo =
  1774.                 drm_intel_bo_alloc(intel->bufmgr, "surface data",
  1775.                                    sizeof(intel->surface_data), 4096);
  1776.         assert(intel->surface_bo);
  1777.  
  1778.         return;
  1779.         (void)ret;
  1780. }
  1781.  
  1782. static void
  1783. i965_emit_composite_primitive_identity_source(intel_screen_private *intel,
  1784.                                               int srcX, int srcY,
  1785.                                               int maskX, int maskY,
  1786.                                               int dstX, int dstY,
  1787.                                               int w, int h)
  1788. {
  1789.         OUT_VERTEX(dstX + w);
  1790.         OUT_VERTEX(dstY + h);
  1791.         OUT_VERTEX((srcX + w) * intel->scale_units[0][0]);
  1792.         OUT_VERTEX((srcY + h) * intel->scale_units[0][1]);
  1793.  
  1794.         OUT_VERTEX(dstX);
  1795.         OUT_VERTEX(dstY + h);
  1796.         OUT_VERTEX(srcX * intel->scale_units[0][0]);
  1797.         OUT_VERTEX((srcY + h) * intel->scale_units[0][1]);
  1798.  
  1799.         OUT_VERTEX(dstX);
  1800.         OUT_VERTEX(dstY);
  1801.         OUT_VERTEX(srcX * intel->scale_units[0][0]);
  1802.         OUT_VERTEX(srcY * intel->scale_units[0][1]);
  1803. }
  1804.  
  1805. static void
  1806. i965_emit_composite_primitive_affine_source(intel_screen_private *intel,
  1807.                                             int srcX, int srcY,
  1808.                                             int maskX, int maskY,
  1809.                                             int dstX, int dstY,
  1810.                                             int w, int h)
  1811. {
  1812.         float src_x[3], src_y[3];
  1813.  
  1814.         if (!intel_get_transformed_coordinates(srcX, srcY,
  1815.                                               intel->transform[0],
  1816.                                               &src_x[0],
  1817.                                               &src_y[0]))
  1818.                 return;
  1819.  
  1820.         if (!intel_get_transformed_coordinates(srcX, srcY + h,
  1821.                                               intel->transform[0],
  1822.                                               &src_x[1],
  1823.                                               &src_y[1]))
  1824.                 return;
  1825.  
  1826.         if (!intel_get_transformed_coordinates(srcX + w, srcY + h,
  1827.                                               intel->transform[0],
  1828.                                               &src_x[2],
  1829.                                               &src_y[2]))
  1830.                 return;
  1831.  
  1832.         OUT_VERTEX(dstX + w);
  1833.         OUT_VERTEX(dstY + h);
  1834.         OUT_VERTEX(src_x[2] * intel->scale_units[0][0]);
  1835.         OUT_VERTEX(src_y[2] * intel->scale_units[0][1]);
  1836.  
  1837.         OUT_VERTEX(dstX);
  1838.         OUT_VERTEX(dstY + h);
  1839.         OUT_VERTEX(src_x[1] * intel->scale_units[0][0]);
  1840.         OUT_VERTEX(src_y[1] * intel->scale_units[0][1]);
  1841.  
  1842.         OUT_VERTEX(dstX);
  1843.         OUT_VERTEX(dstY);
  1844.         OUT_VERTEX(src_x[0] * intel->scale_units[0][0]);
  1845.         OUT_VERTEX(src_y[0] * intel->scale_units[0][1]);
  1846. }
  1847.  
  1848. static void
  1849. i965_emit_composite_primitive_identity_source_mask(intel_screen_private *intel,
  1850.                                                    int srcX, int srcY,
  1851.                                                    int maskX, int maskY,
  1852.                                                    int dstX, int dstY,
  1853.                                                    int w, int h)
  1854. {
  1855.         OUT_VERTEX(dstX + w);
  1856.         OUT_VERTEX(dstY + h);
  1857.         OUT_VERTEX((srcX + w) * intel->scale_units[0][0]);
  1858.         OUT_VERTEX((srcY + h) * intel->scale_units[0][1]);
  1859.         OUT_VERTEX((maskX + w) * intel->scale_units[1][0]);
  1860.         OUT_VERTEX((maskY + h) * intel->scale_units[1][1]);
  1861.  
  1862.         OUT_VERTEX(dstX);
  1863.         OUT_VERTEX(dstY + h);
  1864.         OUT_VERTEX(srcX * intel->scale_units[0][0]);
  1865.         OUT_VERTEX((srcY + h) * intel->scale_units[0][1]);
  1866.         OUT_VERTEX(maskX * intel->scale_units[1][0]);
  1867.         OUT_VERTEX((maskY + h) * intel->scale_units[1][1]);
  1868.  
  1869.         OUT_VERTEX(dstX);
  1870.         OUT_VERTEX(dstY);
  1871.         OUT_VERTEX(srcX * intel->scale_units[0][0]);
  1872.         OUT_VERTEX(srcY * intel->scale_units[0][1]);
  1873.         OUT_VERTEX(maskX * intel->scale_units[1][0]);
  1874.         OUT_VERTEX(maskY * intel->scale_units[1][1]);
  1875. }
  1876.  
  1877. static void
  1878. i965_emit_composite_primitive(intel_screen_private *intel,
  1879.                               int srcX, int srcY,
  1880.                               int maskX, int maskY,
  1881.                               int dstX, int dstY,
  1882.                               int w, int h)
  1883. {
  1884.         float src_x[3], src_y[3], src_w[3], mask_x[3], mask_y[3], mask_w[3];
  1885.         Bool is_affine = intel->gen4_render_state->composite_op.is_affine;
  1886.  
  1887.         if (is_affine) {
  1888.                 if (!intel_get_transformed_coordinates(srcX, srcY,
  1889.                                                        intel->transform[0],
  1890.                                                        &src_x[0],
  1891.                                                        &src_y[0]))
  1892.                         return;
  1893.  
  1894.                 if (!intel_get_transformed_coordinates(srcX, srcY + h,
  1895.                                                        intel->transform[0],
  1896.                                                        &src_x[1],
  1897.                                                        &src_y[1]))
  1898.                         return;
  1899.  
  1900.                 if (!intel_get_transformed_coordinates(srcX + w, srcY + h,
  1901.                                                        intel->transform[0],
  1902.                                                        &src_x[2],
  1903.                                                        &src_y[2]))
  1904.                         return;
  1905.         } else {
  1906.                 if (!intel_get_transformed_coordinates_3d(srcX, srcY,
  1907.                                                           intel->transform[0],
  1908.                                                           &src_x[0],
  1909.                                                           &src_y[0],
  1910.                                                           &src_w[0]))
  1911.                         return;
  1912.  
  1913.                 if (!intel_get_transformed_coordinates_3d(srcX, srcY + h,
  1914.                                                           intel->transform[0],
  1915.                                                           &src_x[1],
  1916.                                                           &src_y[1],
  1917.                                                           &src_w[1]))
  1918.                         return;
  1919.  
  1920.                 if (!intel_get_transformed_coordinates_3d(srcX + w, srcY + h,
  1921.                                                           intel->transform[0],
  1922.                                                           &src_x[2],
  1923.                                                           &src_y[2],
  1924.                                                           &src_w[2]))
  1925.                         return;
  1926.         }
  1927.  
  1928.         if (intel->render_mask) {
  1929.                 if (is_affine) {
  1930.                         if (!intel_get_transformed_coordinates(maskX, maskY,
  1931.                                                               intel->transform[1],
  1932.                                                               &mask_x[0],
  1933.                                                               &mask_y[0]))
  1934.                                 return;
  1935.  
  1936.                         if (!intel_get_transformed_coordinates(maskX, maskY + h,
  1937.                                                               intel->transform[1],
  1938.                                                               &mask_x[1],
  1939.                                                               &mask_y[1]))
  1940.                                 return;
  1941.  
  1942.                         if (!intel_get_transformed_coordinates(maskX + w, maskY + h,
  1943.                                                               intel->transform[1],
  1944.                                                               &mask_x[2],
  1945.                                                               &mask_y[2]))
  1946.                                 return;
  1947.                 } else {
  1948.                         if (!intel_get_transformed_coordinates_3d(maskX, maskY,
  1949.                                                                  intel->transform[1],
  1950.                                                                  &mask_x[0],
  1951.                                                                  &mask_y[0],
  1952.                                                                  &mask_w[0]))
  1953.                                 return;
  1954.  
  1955.                         if (!intel_get_transformed_coordinates_3d(maskX, maskY + h,
  1956.                                                                  intel->transform[1],
  1957.                                                                  &mask_x[1],
  1958.                                                                  &mask_y[1],
  1959.                                                                  &mask_w[1]))
  1960.                                 return;
  1961.  
  1962.                         if (!intel_get_transformed_coordinates_3d(maskX + w, maskY + h,
  1963.                                                                  intel->transform[1],
  1964.                                                                  &mask_x[2],
  1965.                                                                  &mask_y[2],
  1966.                                                                  &mask_w[2]))
  1967.                                 return;
  1968.                 }
  1969.         }
  1970.  
  1971.         OUT_VERTEX(dstX + w);
  1972.         OUT_VERTEX(dstY + h);
  1973.         OUT_VERTEX(src_x[2] * intel->scale_units[0][0]);
  1974.         OUT_VERTEX(src_y[2] * intel->scale_units[0][1]);
  1975.         if (!is_affine)
  1976.                 OUT_VERTEX(src_w[2]);
  1977.         if (intel->render_mask) {
  1978.                 OUT_VERTEX(mask_x[2] * intel->scale_units[1][0]);
  1979.                 OUT_VERTEX(mask_y[2] * intel->scale_units[1][1]);
  1980.                 if (!is_affine)
  1981.                         OUT_VERTEX(mask_w[2]);
  1982.         }
  1983.  
  1984.         OUT_VERTEX(dstX);
  1985.         OUT_VERTEX(dstY + h);
  1986.         OUT_VERTEX(src_x[1] * intel->scale_units[0][0]);
  1987.         OUT_VERTEX(src_y[1] * intel->scale_units[0][1]);
  1988.         if (!is_affine)
  1989.                 OUT_VERTEX(src_w[1]);
  1990.         if (intel->render_mask) {
  1991.                 OUT_VERTEX(mask_x[1] * intel->scale_units[1][0]);
  1992.                 OUT_VERTEX(mask_y[1] * intel->scale_units[1][1]);
  1993.                 if (!is_affine)
  1994.                         OUT_VERTEX(mask_w[1]);
  1995.         }
  1996.  
  1997.         OUT_VERTEX(dstX);
  1998.         OUT_VERTEX(dstY);
  1999.         OUT_VERTEX(src_x[0] * intel->scale_units[0][0]);
  2000.         OUT_VERTEX(src_y[0] * intel->scale_units[0][1]);
  2001.         if (!is_affine)
  2002.                 OUT_VERTEX(src_w[0]);
  2003.         if (intel->render_mask) {
  2004.                 OUT_VERTEX(mask_x[0] * intel->scale_units[1][0]);
  2005.                 OUT_VERTEX(mask_y[0] * intel->scale_units[1][1]);
  2006.                 if (!is_affine)
  2007.                         OUT_VERTEX(mask_w[0]);
  2008.         }
  2009. }
  2010.  
  2011. Bool
  2012. i965_prepare_composite(int op, PicturePtr source_picture,
  2013.                        PicturePtr mask_picture, PicturePtr dest_picture,
  2014.                        PixmapPtr source, PixmapPtr mask, PixmapPtr dest)
  2015. {
  2016.         intel_screen_private *intel = intel_get_screen_private();
  2017.         struct gen4_render_state *render_state = intel->gen4_render_state;
  2018.         gen4_composite_op *composite_op = &render_state->composite_op;
  2019.  
  2020.         composite_op->src_filter =
  2021.             sampler_state_filter_from_picture(source_picture->filter);
  2022.         if (composite_op->src_filter == SS_INVALID_FILTER) {
  2023.                 intel_debug_fallback("Bad src filter 0x%x\n",
  2024.                                      source_picture->filter);
  2025.                 return FALSE;
  2026.         }
  2027.         composite_op->src_extend =
  2028.             sampler_state_extend_from_picture(source_picture->repeatType);
  2029.         if (composite_op->src_extend == SS_INVALID_EXTEND) {
  2030.                 intel_debug_fallback("Bad src repeat 0x%x\n",
  2031.                                      source_picture->repeatType);
  2032.                 return FALSE;
  2033.         }
  2034.  
  2035.         if (mask_picture) {
  2036.                 if (mask_picture->componentAlpha &&
  2037.                     PICT_FORMAT_RGB(mask_picture->format)) {
  2038.                         /* Check if it's component alpha that relies on a source alpha and on
  2039.                          * the source value.  We can only get one of those into the single
  2040.                          * source value that we get to blend with.
  2041.                          */
  2042.                         if (i965_blend_op[op].src_alpha &&
  2043.                             (i965_blend_op[op].src_blend != BRW_BLENDFACTOR_ZERO)) {
  2044.                                 intel_debug_fallback("Component alpha not supported "
  2045.                                                      "with source alpha and source "
  2046.                                                      "value blending.\n");
  2047.                                 return FALSE;
  2048.                         }
  2049.                 }
  2050.  
  2051.                 composite_op->mask_filter =
  2052.                     sampler_state_filter_from_picture(mask_picture->filter);
  2053.                 if (composite_op->mask_filter == SS_INVALID_FILTER) {
  2054.                         intel_debug_fallback("Bad mask filter 0x%x\n",
  2055.                                              mask_picture->filter);
  2056.                         return FALSE;
  2057.                 }
  2058.                 composite_op->mask_extend =
  2059.                     sampler_state_extend_from_picture(mask_picture->repeatType);
  2060.                 if (composite_op->mask_extend == SS_INVALID_EXTEND) {
  2061.                         intel_debug_fallback("Bad mask repeat 0x%x\n",
  2062.                                              mask_picture->repeatType);
  2063.                         return FALSE;
  2064.                 }
  2065.         } else {
  2066.                 composite_op->mask_filter = SS_FILTER_NEAREST;
  2067.                 composite_op->mask_extend = SS_EXTEND_NONE;
  2068.         }
  2069.  
  2070.         /* Flush any pending writes prior to relocating the textures. */
  2071.         if (intel_pixmap_is_dirty(source) || intel_pixmap_is_dirty(mask))
  2072.                 intel_batch_emit_flush();
  2073.  
  2074.         composite_op->op = op;
  2075.         intel->render_source_picture = source_picture;
  2076.         intel->render_mask_picture = mask_picture;
  2077.         intel->render_dest_picture = dest_picture;
  2078.         intel->render_source = source;
  2079.         intel->render_mask = mask;
  2080.         intel->render_dest = dest;
  2081.  
  2082.         intel->scale_units[0][0] = 1. / source->drawable.width;
  2083.         intel->scale_units[0][1] = 1. / source->drawable.height;
  2084.  
  2085.         intel->transform[0] = source_picture->transform;
  2086.         composite_op->is_affine = intel_transform_is_affine(intel->transform[0]);
  2087.  
  2088.         if (mask_picture == NULL) {
  2089.                 intel->transform[1] = NULL;
  2090.                 intel->scale_units[1][0] = -1;
  2091.                 intel->scale_units[1][1] = -1;
  2092.         } else {
  2093.                 assert(mask != NULL);
  2094.                 intel->transform[1] = mask_picture->transform;
  2095.                 intel->scale_units[1][0] = 1. / mask->drawable.width;
  2096.                 intel->scale_units[1][1] = 1. / mask->drawable.height;
  2097.                 composite_op->is_affine &=
  2098.                     intel_transform_is_affine(intel->transform[1]);
  2099.         }
  2100.  
  2101.         if (mask) {
  2102.                 if (mask_picture->componentAlpha &&
  2103.                     PICT_FORMAT_RGB(mask_picture->format)) {
  2104.                         if (i965_blend_op[op].src_alpha) {
  2105.                                 if (composite_op->is_affine)
  2106.                                         composite_op->wm_kernel =
  2107.                                             WM_KERNEL_MASKCA_SRCALPHA_AFFINE;
  2108.                                 else
  2109.                                         composite_op->wm_kernel =
  2110.                                             WM_KERNEL_MASKCA_SRCALPHA_PROJECTIVE;
  2111.                         } else {
  2112.                                 if (composite_op->is_affine)
  2113.                                         composite_op->wm_kernel =
  2114.                                             WM_KERNEL_MASKCA_AFFINE;
  2115.                                 else
  2116.                                         composite_op->wm_kernel =
  2117.                                             WM_KERNEL_MASKCA_PROJECTIVE;
  2118.                         }
  2119.                 } else {
  2120.                         if (composite_op->is_affine)
  2121.                                 composite_op->wm_kernel =
  2122.                                     WM_KERNEL_MASKNOCA_AFFINE;
  2123.                         else
  2124.                                 composite_op->wm_kernel =
  2125.                                     WM_KERNEL_MASKNOCA_PROJECTIVE;
  2126.                 }
  2127.         } else {
  2128.                 if (composite_op->is_affine)
  2129.                         composite_op->wm_kernel = WM_KERNEL_NOMASK_AFFINE;
  2130.                 else
  2131.                         composite_op->wm_kernel = WM_KERNEL_NOMASK_PROJECTIVE;
  2132.         }
  2133.  
  2134.         intel->prim_emit = i965_emit_composite_primitive;
  2135.         if (!mask) {
  2136.                 if (intel->transform[0] == NULL)
  2137.                         intel->prim_emit = i965_emit_composite_primitive_identity_source;
  2138.                 else if (composite_op->is_affine)
  2139.                         intel->prim_emit = i965_emit_composite_primitive_affine_source;
  2140.         } else {
  2141.                 if (intel->transform[0] == NULL && intel->transform[1] == NULL)
  2142.                         intel->prim_emit = i965_emit_composite_primitive_identity_source_mask;
  2143.         }
  2144.  
  2145.         intel->floats_per_vertex =
  2146.                 2 + (mask ? 2 : 1) * (composite_op->is_affine ? 2: 3);
  2147.  
  2148.         if (!i965_composite_check_aperture(intel)) {
  2149.                 intel_batch_submit();
  2150.                 if (!i965_composite_check_aperture(intel)) {
  2151.                         intel_debug_fallback("Couldn't fit render operation "
  2152.                                              "in aperture\n");
  2153.                         return FALSE;
  2154.                 }
  2155.         }
  2156.  
  2157.         if (sizeof(intel->surface_data) - intel->surface_used <
  2158.             4 * SURFACE_STATE_PADDED_SIZE)
  2159.                 i965_surface_flush(intel);
  2160.  
  2161.         intel->needs_render_state_emit = TRUE;
  2162.  
  2163.         return TRUE;
  2164. }
  2165.  
  2166. static void i965_select_vertex_buffer(struct intel_screen_private *intel)
  2167. {
  2168.         int id = intel->gen4_render_state->composite_op.vertex_id;
  2169.         int modifyenable = 0;
  2170.  
  2171.         if (intel->vertex_id & (1 << id))
  2172.                 return;
  2173.  
  2174.         if (INTEL_INFO(intel)->gen >= 070)
  2175.                 modifyenable = GEN7_VB0_ADDRESS_MODIFYENABLE;
  2176.  
  2177.         /* Set up the pointer to our (single) vertex buffer */
  2178.         OUT_BATCH(BRW_3DSTATE_VERTEX_BUFFERS | 3);
  2179.  
  2180.         /* XXX could use multiple vbo to reduce relocations if
  2181.          * frequently switching between vertex sizes, like rgb10text.
  2182.          */
  2183.         if (INTEL_INFO(intel)->gen >= 060) {
  2184.                 OUT_BATCH((id << GEN6_VB0_BUFFER_INDEX_SHIFT) |
  2185.                           GEN6_VB0_VERTEXDATA |
  2186.                           modifyenable |
  2187.                           (4*intel->floats_per_vertex << VB0_BUFFER_PITCH_SHIFT));
  2188.         } else {
  2189.                 OUT_BATCH((id << VB0_BUFFER_INDEX_SHIFT) |
  2190.                           VB0_VERTEXDATA |
  2191.                           (4*intel->floats_per_vertex << VB0_BUFFER_PITCH_SHIFT));
  2192.         }
  2193.         OUT_RELOC(intel->vertex_bo, I915_GEM_DOMAIN_VERTEX, 0, 0);
  2194.         if (INTEL_INFO(intel)->gen >= 050)
  2195.                 OUT_RELOC(intel->vertex_bo,
  2196.                           I915_GEM_DOMAIN_VERTEX, 0,
  2197.                           sizeof(intel->vertex_ptr) - 1);
  2198.         else
  2199.                 OUT_BATCH(0);
  2200.         OUT_BATCH(0);           // ignore for VERTEXDATA, but still there
  2201.  
  2202.         intel->vertex_id |= 1 << id;
  2203. }
  2204.  
  2205. static void i965_bind_surfaces(struct intel_screen_private *intel)
  2206. {
  2207.         uint32_t *binding_table;
  2208.  
  2209.         assert(intel->surface_used + 4 * SURFACE_STATE_PADDED_SIZE <= sizeof(intel->surface_data));
  2210.  
  2211.         binding_table = (uint32_t*) (intel->surface_data + intel->surface_used);
  2212.         intel->surface_table = intel->surface_used;
  2213.         intel->surface_used += SURFACE_STATE_PADDED_SIZE;
  2214.  
  2215.         binding_table[0] =
  2216.                 i965_set_picture_surface_state(intel,
  2217.                                                intel->render_dest_picture,
  2218.                                                intel->render_dest,
  2219.                                                TRUE);
  2220.         binding_table[1] =
  2221.                 i965_set_picture_surface_state(intel,
  2222.                                                intel->render_source_picture,
  2223.                                                intel->render_source,
  2224.                                                FALSE);
  2225.         if (intel->render_mask) {
  2226.                 binding_table[2] =
  2227.                         i965_set_picture_surface_state(intel,
  2228.                                                        intel->render_mask_picture,
  2229.                                                        intel->render_mask,
  2230.                                                        FALSE);
  2231.         }
  2232. }
  2233.  
  2234. void
  2235. i965_composite(PixmapPtr dest, int srcX, int srcY, int maskX, int maskY,
  2236.                int dstX, int dstY, int w, int h)
  2237. {
  2238.         intel_screen_private *intel = intel_get_screen_private();
  2239.  
  2240.         intel_batch_start_atomic(200);
  2241.         if (intel->needs_render_state_emit) {
  2242.                 i965_bind_surfaces(intel);
  2243.  
  2244.                 if (INTEL_INFO(intel)->gen >= 060)
  2245.                         gen6_emit_composite_state(intel);
  2246.                 else
  2247.                         i965_emit_composite_state(intel);
  2248.         }
  2249.  
  2250.         if (intel->floats_per_vertex != intel->last_floats_per_vertex) {
  2251.                 intel->vertex_index = (intel->vertex_used + intel->floats_per_vertex - 1) / intel->floats_per_vertex;
  2252.                 intel->vertex_used = intel->vertex_index * intel->floats_per_vertex;
  2253.                 intel->last_floats_per_vertex = intel->floats_per_vertex;
  2254.         }
  2255.         if (intel_vertex_space(intel) < 3*4*intel->floats_per_vertex) {
  2256.                 i965_vertex_flush(intel);
  2257.                 intel_next_vertex(intel);
  2258.                 intel->vertex_index = 0;
  2259.         }
  2260.         i965_select_vertex_buffer(intel);
  2261.  
  2262.         if (intel->vertex_offset == 0) {
  2263.                 if (INTEL_INFO(intel)->gen >= 070) {
  2264.                         OUT_BATCH(BRW_3DPRIMITIVE | (7 - 2));
  2265.                         OUT_BATCH(BRW_3DPRIMITIVE_VERTEX_SEQUENTIAL |
  2266.                                   _3DPRIM_RECTLIST);
  2267.                 } else {
  2268.                         OUT_BATCH(BRW_3DPRIMITIVE |
  2269.                                   BRW_3DPRIMITIVE_VERTEX_SEQUENTIAL |
  2270.                                   (_3DPRIM_RECTLIST << BRW_3DPRIMITIVE_TOPOLOGY_SHIFT) |
  2271.                                   (0 << 9) |
  2272.                                   4);
  2273.                 }
  2274.                 intel->vertex_offset = intel->batch_used;
  2275.                 OUT_BATCH(0);   /* vertex count, to be filled in later */
  2276.                 OUT_BATCH(intel->vertex_index);
  2277.                 OUT_BATCH(1);   /* single instance */
  2278.                 OUT_BATCH(0);   /* start instance location */
  2279.                 OUT_BATCH(0);   /* index buffer offset, ignored */
  2280.                 intel->vertex_count = intel->vertex_index;
  2281.         }
  2282.  
  2283.         intel->prim_emit(intel,
  2284.                          srcX, srcY,
  2285.                          maskX, maskY,
  2286.                          dstX, dstY,
  2287.                          w, h);
  2288.         intel->vertex_index += 3;
  2289.  
  2290.         if (INTEL_INFO(intel)->gen < 050) {
  2291.             /* XXX OMG! */
  2292.             i965_vertex_flush(intel);
  2293.             OUT_BATCH(MI_FLUSH | MI_INHIBIT_RENDER_CACHE_FLUSH);
  2294.         }
  2295.  
  2296.         intel_batch_end_atomic();
  2297. }
  2298.  
  2299. void i965_batch_commit_notify(intel_screen_private *intel)
  2300. {
  2301.         intel->needs_render_state_emit = TRUE;
  2302.         intel->needs_3d_invariant = TRUE;
  2303.         intel->last_floats_per_vertex = 0;
  2304.         intel->vertex_index = 0;
  2305.  
  2306.         intel->gen4_render_state->composite_op.vertex_id = -1;
  2307.  
  2308.         intel->gen6_render_state.num_sf_outputs = 0;
  2309.         intel->gen6_render_state.samplers = NULL;
  2310.         intel->gen6_render_state.blend = -1;
  2311.         intel->gen6_render_state.kernel = NULL;
  2312.         intel->gen6_render_state.drawrect = -1;
  2313.  
  2314.         assert(intel->surface_reloc == 0);
  2315. }
  2316.  
  2317. /**
  2318.  * Called at EnterVT so we can set up our offsets into the state buffer.
  2319.  */
  2320. void gen4_render_state_init()
  2321. {
  2322.     ENTER();
  2323.  
  2324.         intel_screen_private *intel = intel_get_screen_private();
  2325.         struct gen4_render_state *render;
  2326.         const struct wm_kernel_info *wm_kernels;
  2327.         sampler_state_filter_t src_filter;
  2328.         sampler_state_extend_t src_extend;
  2329.         sampler_state_filter_t mask_filter;
  2330.         sampler_state_extend_t mask_extend;
  2331.         drm_intel_bo *sf_kernel_bo, *sf_kernel_mask_bo;
  2332.         drm_intel_bo *border_color_bo;
  2333.         int m;
  2334.  
  2335.         intel->needs_3d_invariant = TRUE;
  2336.  
  2337.         intel->surface_bo =
  2338.                 drm_intel_bo_alloc(intel->bufmgr, "surface data",
  2339.                                    sizeof(intel->surface_data), 4096);
  2340.         assert(intel->surface_bo);
  2341.  
  2342.         intel->surface_used = 0;
  2343.  
  2344.         if (intel->gen4_render_state == NULL) {
  2345.                 intel->gen4_render_state = calloc(1, sizeof(*render));
  2346.                 assert(intel->gen4_render_state != NULL);
  2347.         }
  2348.  
  2349.         if (INTEL_INFO(intel)->gen >= 060)
  2350.                 return gen6_render_state_init();
  2351.  
  2352.         render = intel->gen4_render_state;
  2353.         render->composite_op.vertex_id = -1;
  2354.  
  2355.         render->vs_state_bo = gen4_create_vs_unit_state(intel);
  2356.  
  2357.         /* Set up the two SF states (one for blending with a mask, one without) */
  2358.         if (IS_GEN5(intel)) {
  2359.                 sf_kernel_bo = intel_bo_alloc_for_data(intel,
  2360.                                                        sf_kernel_static_gen5,
  2361.                                                        sizeof
  2362.                                                        (sf_kernel_static_gen5),
  2363.                                                        "sf kernel gen5");
  2364.                 sf_kernel_mask_bo =
  2365.                     intel_bo_alloc_for_data(intel, sf_kernel_mask_static_gen5,
  2366.                                             sizeof(sf_kernel_mask_static_gen5),
  2367.                                             "sf mask kernel");
  2368.         } else {
  2369.                 sf_kernel_bo = intel_bo_alloc_for_data(intel,
  2370.                                                        sf_kernel_static,
  2371.                                                        sizeof(sf_kernel_static),
  2372.                                                        "sf kernel");
  2373.                 sf_kernel_mask_bo = intel_bo_alloc_for_data(intel,
  2374.                                                             sf_kernel_mask_static,
  2375.                                                             sizeof
  2376.                                                             (sf_kernel_mask_static),
  2377.                                                             "sf mask kernel");
  2378.         }
  2379.         render->sf_state_bo = gen4_create_sf_state(intel, sf_kernel_bo);
  2380.         render->sf_mask_state_bo = gen4_create_sf_state(intel, sf_kernel_mask_bo);
  2381.         drm_intel_bo_unreference(sf_kernel_bo);
  2382.         drm_intel_bo_unreference(sf_kernel_mask_bo);
  2383.  
  2384.         wm_kernels = IS_GEN5(intel) ? wm_kernels_gen5 : wm_kernels_gen4;
  2385.         for (m = 0; m < KERNEL_COUNT; m++) {
  2386.                 render->wm_kernel_bo[m] =
  2387.                         intel_bo_alloc_for_data(intel,
  2388.                                         wm_kernels[m].data,
  2389.                                         wm_kernels[m].size,
  2390.                                         "WM kernel");
  2391.         }
  2392.  
  2393.         /* Set up the WM states: each filter/extend type for source and mask, per
  2394.          * kernel.
  2395.          */
  2396.         border_color_bo = sampler_border_color_create(intel);
  2397.         for (src_filter = 0; src_filter < FILTER_COUNT; src_filter++) {
  2398.                 for (src_extend = 0; src_extend < EXTEND_COUNT; src_extend++) {
  2399.                         for (mask_filter = 0; mask_filter < FILTER_COUNT; mask_filter++) {
  2400.                                 for (mask_extend = 0; mask_extend < EXTEND_COUNT; mask_extend++) {
  2401.                                         drm_intel_bo *sampler_state_bo;
  2402.  
  2403.                                         sampler_state_bo =
  2404.                                             i965_create_sampler_state(intel,
  2405.                                                                       src_filter, src_extend,
  2406.                                                                       mask_filter, mask_extend,
  2407.                                                                       border_color_bo);
  2408.  
  2409.                                         for (m = 0; m < KERNEL_COUNT; m++) {
  2410.                                                 render->wm_state_bo[m][src_filter][src_extend][mask_filter][mask_extend] =
  2411.                                                         gen4_create_wm_state
  2412.                                                         (intel,
  2413.                                                          wm_kernels[m]. has_mask,
  2414.                                                          render->wm_kernel_bo[m],
  2415.                                                          sampler_state_bo);
  2416.                                         }
  2417.                                         drm_intel_bo_unreference(sampler_state_bo);
  2418.                                 }
  2419.                         }
  2420.                 }
  2421.         }
  2422.         drm_intel_bo_unreference(border_color_bo);
  2423.  
  2424.         render->cc_state_bo = gen4_create_cc_unit_state(intel);
  2425.  
  2426.     LEAVE();
  2427. }
  2428.  
  2429. /**
  2430.  * Called at LeaveVT.
  2431.  */
  2432. void gen4_render_state_cleanup(ScrnInfoPtr scrn)
  2433. {
  2434.         intel_screen_private *intel = intel_get_screen_private(scrn);
  2435.         struct gen4_render_state *render_state = intel->gen4_render_state;
  2436.         int i, j, k, l, m;
  2437.  
  2438.         drm_intel_bo_unreference(intel->surface_bo);
  2439.         drm_intel_bo_unreference(render_state->vs_state_bo);
  2440.         drm_intel_bo_unreference(render_state->sf_state_bo);
  2441.         drm_intel_bo_unreference(render_state->sf_mask_state_bo);
  2442.  
  2443.         for (i = 0; i < KERNEL_COUNT; i++)
  2444.                 drm_intel_bo_unreference(render_state->wm_kernel_bo[i]);
  2445.  
  2446.         for (i = 0; i < FILTER_COUNT; i++)
  2447.                 for (j = 0; j < EXTEND_COUNT; j++)
  2448.                         for (k = 0; k < FILTER_COUNT; k++)
  2449.                                 for (l = 0; l < EXTEND_COUNT; l++)
  2450.                                         for (m = 0; m < KERNEL_COUNT; m++)
  2451.                                                 drm_intel_bo_unreference
  2452.                                                     (render_state->
  2453.                                                      wm_state_bo[m][i][j][k]
  2454.                                                      [l]);
  2455.  
  2456.         for (i = 0; i < FILTER_COUNT; i++)
  2457.                 for (j = 0; j < EXTEND_COUNT; j++)
  2458.                         for (k = 0; k < FILTER_COUNT; k++)
  2459.                                 for (l = 0; l < EXTEND_COUNT; l++)
  2460.                                         drm_intel_bo_unreference(render_state->ps_sampler_state_bo[i][j][k][l]);
  2461.  
  2462.         drm_intel_bo_unreference(render_state->cc_state_bo);
  2463.  
  2464.         drm_intel_bo_unreference(render_state->cc_vp_bo);
  2465.         drm_intel_bo_unreference(render_state->gen6_blend_bo);
  2466.         drm_intel_bo_unreference(render_state->gen6_depth_stencil_bo);
  2467.  
  2468.         free(intel->gen4_render_state);
  2469.         intel->gen4_render_state = NULL;
  2470. }
  2471.  
  2472. /*
  2473.  * for GEN6+
  2474.  */
  2475. #define GEN6_BLEND_STATE_PADDED_SIZE    ALIGN(sizeof(struct gen6_blend_state), 64)
  2476.  
  2477. static drm_intel_bo *
  2478. gen6_composite_create_cc_state(intel_screen_private *intel)
  2479. {
  2480.         struct gen6_color_calc_state *state;
  2481.         drm_intel_bo *cc_bo;
  2482.         int ret;
  2483.  
  2484.         cc_bo = drm_intel_bo_alloc(intel->bufmgr,
  2485.                                 "gen6 CC state",
  2486.                                 sizeof(*state),
  2487.                                 4096);
  2488.         assert(cc_bo);
  2489.  
  2490.         ret = drm_intel_bo_map(cc_bo, TRUE);
  2491.         assert(ret == 0);
  2492.  
  2493.         state = memset(cc_bo->virtual, 0, sizeof(*state));
  2494.         state->constant_r = 1.0;
  2495.         state->constant_g = 0.0;
  2496.         state->constant_b = 1.0;
  2497.         state->constant_a = 1.0;
  2498.         drm_intel_bo_unmap(cc_bo);
  2499.  
  2500.         return cc_bo;
  2501.         (void)ret;
  2502. }
  2503.  
  2504. static drm_intel_bo *
  2505. gen6_composite_create_blend_state(intel_screen_private *intel)
  2506. {
  2507.         drm_intel_bo *blend_bo;
  2508.         int src, dst, ret;
  2509.  
  2510.         blend_bo = drm_intel_bo_alloc(intel->bufmgr,
  2511.                                 "gen6 BLEND state",
  2512.                                 BRW_BLENDFACTOR_COUNT * BRW_BLENDFACTOR_COUNT * GEN6_BLEND_STATE_PADDED_SIZE,
  2513.                                 4096);
  2514.         assert(blend_bo);
  2515.  
  2516.         ret = drm_intel_bo_map(blend_bo, TRUE);
  2517.         assert(ret == 0);
  2518.  
  2519.         memset(blend_bo->virtual, 0, blend_bo->size);
  2520.         for (src = 0; src < BRW_BLENDFACTOR_COUNT; src++) {
  2521.                 for (dst = 0; dst < BRW_BLENDFACTOR_COUNT; dst++) {
  2522.                         uint32_t blend_state_offset = (src * BRW_BLENDFACTOR_COUNT + dst) * GEN6_BLEND_STATE_PADDED_SIZE;
  2523.                         struct gen6_blend_state *blend;
  2524.  
  2525.                         blend = (struct gen6_blend_state *)((char *)blend_bo->virtual + blend_state_offset);
  2526.                         blend->blend0.dest_blend_factor = dst;
  2527.                         blend->blend0.source_blend_factor = src;
  2528.                         blend->blend0.blend_func = BRW_BLENDFUNCTION_ADD;
  2529.                         blend->blend0.blend_enable = 1;
  2530.  
  2531.                         blend->blend1.post_blend_clamp_enable = 1;
  2532.                         blend->blend1.pre_blend_clamp_enable = 1;
  2533.                 }
  2534.         }
  2535.  
  2536.         drm_intel_bo_unmap(blend_bo);
  2537.         return blend_bo;
  2538.         (void)ret;
  2539. }
  2540.  
  2541. static drm_intel_bo *
  2542. gen6_composite_create_depth_stencil_state(intel_screen_private *intel)
  2543. {
  2544.         drm_intel_bo *depth_stencil_bo;
  2545.         int ret;
  2546.  
  2547.         depth_stencil_bo =
  2548.                 drm_intel_bo_alloc(intel->bufmgr,
  2549.                                    "gen6 DEPTH_STENCIL state",
  2550.                                    sizeof(struct gen6_depth_stencil_state),
  2551.                                    4096);
  2552.         assert(depth_stencil_bo);
  2553.  
  2554.         ret = drm_intel_bo_map(depth_stencil_bo, TRUE);
  2555.         assert(ret == 0);
  2556.  
  2557.         memset(depth_stencil_bo->virtual, 0,
  2558.                sizeof(struct gen6_depth_stencil_state));
  2559.         drm_intel_bo_unmap(depth_stencil_bo);
  2560.  
  2561.         return depth_stencil_bo;
  2562.         (void)ret;
  2563. }
  2564.  
  2565. static void
  2566. gen6_composite_state_base_address(intel_screen_private *intel)
  2567. {
  2568.         OUT_BATCH(BRW_STATE_BASE_ADDRESS | (10 - 2));
  2569.         OUT_BATCH(BASE_ADDRESS_MODIFY); /* General state base address */
  2570.         intel->surface_reloc = intel->batch_used;
  2571.         intel_batch_emit_dword(intel,
  2572.                                intel->surface_bo->offset | BASE_ADDRESS_MODIFY);
  2573.         OUT_BATCH(BASE_ADDRESS_MODIFY); /* Dynamic state base address */
  2574.         OUT_BATCH(BASE_ADDRESS_MODIFY); /* Indirect object base address */
  2575.         OUT_BATCH(BASE_ADDRESS_MODIFY); /* Instruction base address */
  2576.         OUT_BATCH(BASE_ADDRESS_MODIFY); /* General state upper bound */
  2577.         OUT_BATCH(BASE_ADDRESS_MODIFY); /* Dynamic state upper bound */
  2578.         OUT_BATCH(BASE_ADDRESS_MODIFY); /* Indirect object upper bound */
  2579.         OUT_BATCH(BASE_ADDRESS_MODIFY); /* Instruction access upper bound */
  2580. }
  2581.  
  2582. static void
  2583. gen6_composite_cc_state_pointers(intel_screen_private *intel,
  2584.                                  uint32_t blend_offset)
  2585. {
  2586.         struct gen4_render_state *render_state = intel->gen4_render_state;
  2587.         drm_intel_bo *cc_bo = NULL;
  2588.         drm_intel_bo *depth_stencil_bo = NULL;
  2589.  
  2590.         if (intel->gen6_render_state.blend == blend_offset)
  2591.                 return;
  2592.  
  2593.         if (intel->gen6_render_state.blend == -1) {
  2594.                 cc_bo = render_state->cc_state_bo;
  2595.                 depth_stencil_bo = render_state->gen6_depth_stencil_bo;
  2596.         }
  2597.         if (INTEL_INFO(intel)->gen >= 070) {
  2598.                 gen7_upload_cc_state_pointers(intel, render_state->gen6_blend_bo, cc_bo, depth_stencil_bo, blend_offset);
  2599.         } else {
  2600.                 gen6_upload_cc_state_pointers(intel, render_state->gen6_blend_bo, cc_bo, depth_stencil_bo, blend_offset);
  2601.         }
  2602.  
  2603.         intel->gen6_render_state.blend = blend_offset;
  2604. }
  2605.  
  2606. static void
  2607. gen6_composite_sampler_state_pointers(intel_screen_private *intel,
  2608.                                       drm_intel_bo *bo)
  2609. {
  2610.         if (intel->gen6_render_state.samplers == bo)
  2611.                 return;
  2612.  
  2613.         intel->gen6_render_state.samplers = bo;
  2614.  
  2615.         if (INTEL_INFO(intel)->gen >= 070)
  2616.                 gen7_upload_sampler_state_pointers(intel, bo);
  2617.         else
  2618.                 gen6_upload_sampler_state_pointers(intel, bo);
  2619. }
  2620.  
  2621. static void
  2622. gen6_composite_wm_constants(intel_screen_private *intel)
  2623. {
  2624.         Bool ivb = INTEL_INFO(intel)->gen >= 070;
  2625.         /* disable WM constant buffer */
  2626.         OUT_BATCH(GEN6_3DSTATE_CONSTANT_PS | ((ivb ? 7 : 5) - 2));
  2627.         OUT_BATCH(0);
  2628.         OUT_BATCH(0);
  2629.         OUT_BATCH(0);
  2630.         OUT_BATCH(0);
  2631.         if (ivb) {
  2632.                 OUT_BATCH(0);
  2633.                 OUT_BATCH(0);
  2634.         }
  2635. }
  2636.  
  2637. static void
  2638. gen6_composite_sf_state(intel_screen_private *intel,
  2639.                         Bool has_mask)
  2640. {
  2641.         int num_sf_outputs = has_mask ? 2 : 1;
  2642.  
  2643.         if (intel->gen6_render_state.num_sf_outputs == num_sf_outputs)
  2644.                 return;
  2645.  
  2646.         intel->gen6_render_state.num_sf_outputs = num_sf_outputs;
  2647.  
  2648.         if (INTEL_INFO(intel)->gen >= 070)
  2649.                 gen7_upload_sf_state(intel, num_sf_outputs, 1);
  2650.         else
  2651.                 gen6_upload_sf_state(intel, num_sf_outputs, 1);
  2652. }
  2653.  
  2654. static void
  2655. gen6_composite_wm_state(intel_screen_private *intel,
  2656.                         Bool has_mask,
  2657.                         drm_intel_bo *bo)
  2658. {
  2659.         int num_surfaces = has_mask ? 3 : 2;
  2660.         int num_sf_outputs = has_mask ? 2 : 1;
  2661.  
  2662.         if (intel->gen6_render_state.kernel == bo)
  2663.                 return;
  2664.  
  2665.         intel->gen6_render_state.kernel = bo;
  2666.  
  2667.         OUT_BATCH(GEN6_3DSTATE_WM | (9 - 2));
  2668.         OUT_RELOC(bo,
  2669.                 I915_GEM_DOMAIN_INSTRUCTION, 0,
  2670.                 0);
  2671.         OUT_BATCH((1 << GEN6_3DSTATE_WM_SAMPLER_COUNT_SHITF) |
  2672.                   (num_surfaces << GEN6_3DSTATE_WM_BINDING_TABLE_ENTRY_COUNT_SHIFT));
  2673.         OUT_BATCH(0);
  2674.         OUT_BATCH((6 << GEN6_3DSTATE_WM_DISPATCH_START_GRF_0_SHIFT)); /* DW4 */
  2675.         OUT_BATCH(((40 - 1) << GEN6_3DSTATE_WM_MAX_THREADS_SHIFT) |
  2676.                   GEN6_3DSTATE_WM_DISPATCH_ENABLE |
  2677.                   GEN6_3DSTATE_WM_16_DISPATCH_ENABLE);
  2678.         OUT_BATCH((num_sf_outputs << GEN6_3DSTATE_WM_NUM_SF_OUTPUTS_SHIFT) |
  2679.                   GEN6_3DSTATE_WM_PERSPECTIVE_PIXEL_BARYCENTRIC);
  2680.         OUT_BATCH(0);
  2681.         OUT_BATCH(0);
  2682. }
  2683.  
  2684. static void
  2685. gen7_composite_wm_state(intel_screen_private *intel,
  2686.                         Bool has_mask,
  2687.                         drm_intel_bo *bo)
  2688. {
  2689.         int num_surfaces = has_mask ? 3 : 2;
  2690.         unsigned int max_threads_shift = GEN7_PS_MAX_THREADS_SHIFT_IVB;
  2691.         unsigned int num_samples = 0;
  2692.  
  2693.         if (IS_HSW(intel)) {
  2694.                 max_threads_shift = GEN7_PS_MAX_THREADS_SHIFT_HSW;
  2695.                 num_samples = 1 << GEN7_PS_SAMPLE_MASK_SHIFT_HSW;
  2696.         }
  2697.  
  2698.         if (intel->gen6_render_state.kernel == bo)
  2699.                 return;
  2700.  
  2701.         intel->gen6_render_state.kernel = bo;
  2702.  
  2703.         OUT_BATCH(GEN6_3DSTATE_WM | (3 - 2));
  2704.         OUT_BATCH(GEN7_WM_DISPATCH_ENABLE |
  2705.                   GEN7_WM_PERSPECTIVE_PIXEL_BARYCENTRIC);
  2706.         OUT_BATCH(0);
  2707.  
  2708.         OUT_BATCH(GEN7_3DSTATE_PS | (8 - 2));
  2709.         OUT_RELOC(bo, I915_GEM_DOMAIN_INSTRUCTION, 0, 0);
  2710.         OUT_BATCH((1 << GEN7_PS_SAMPLER_COUNT_SHIFT) |
  2711.                   (num_surfaces << GEN7_PS_BINDING_TABLE_ENTRY_COUNT_SHIFT));
  2712.         OUT_BATCH(0); /* scratch space base offset */
  2713.         OUT_BATCH(((48 - 1) << max_threads_shift) | num_samples |
  2714.                   GEN7_PS_ATTRIBUTE_ENABLE |
  2715.                   GEN7_PS_16_DISPATCH_ENABLE);
  2716.         OUT_BATCH((6 << GEN7_PS_DISPATCH_START_GRF_SHIFT_0));
  2717.         OUT_BATCH(0); /* kernel 1 pointer */
  2718.         OUT_BATCH(0); /* kernel 2 pointer */
  2719. }
  2720.  
  2721.  
  2722. static void
  2723. gen6_composite_drawing_rectangle(intel_screen_private *intel,
  2724.                                  PixmapPtr dest)
  2725. {
  2726.         uint32_t dw =
  2727.                 DRAW_YMAX(dest->drawable.height - 1) |
  2728.                 DRAW_XMAX(dest->drawable.width - 1);
  2729.  
  2730.         /* XXX cacomposite depends upon the implicit non-pipelined flush */
  2731.         if (0 && intel->gen6_render_state.drawrect == dw)
  2732.                 return;
  2733.         intel->gen6_render_state.drawrect = dw;
  2734.  
  2735.         OUT_BATCH(BRW_3DSTATE_DRAWING_RECTANGLE | (4 - 2));
  2736.         OUT_BATCH(0x00000000);  /* ymin, xmin */
  2737.         OUT_BATCH(dw);  /* ymax, xmax */
  2738.         OUT_BATCH(0x00000000);  /* yorigin, xorigin */
  2739. }
  2740.  
  2741. static void
  2742. gen6_composite_vertex_element_state(intel_screen_private *intel,
  2743.                                     Bool has_mask,
  2744.                                     Bool is_affine)
  2745. {
  2746.         /*
  2747.          * vertex data in vertex buffer
  2748.          *    position: (x, y)
  2749.          *    texture coordinate 0: (u0, v0) if (is_affine is TRUE) else (u0, v0, w0)
  2750.          *    texture coordinate 1 if (has_mask is TRUE): same as above
  2751.          */
  2752.         gen4_composite_op *composite_op = &intel->gen4_render_state->composite_op;
  2753.         int nelem = has_mask ? 2 : 1;
  2754.         int selem = is_affine ? 2 : 3;
  2755.         uint32_t w_component;
  2756.         uint32_t src_format;
  2757.         int id;
  2758.  
  2759.         id = has_mask << 1 | is_affine;
  2760.  
  2761.         if (composite_op->vertex_id == id)
  2762.                 return;
  2763.  
  2764.         composite_op->vertex_id = id;
  2765.  
  2766.         if (is_affine) {
  2767.                 src_format = BRW_SURFACEFORMAT_R32G32_FLOAT;
  2768.                 w_component = BRW_VFCOMPONENT_STORE_1_FLT;
  2769.         } else {
  2770.                 src_format = BRW_SURFACEFORMAT_R32G32B32_FLOAT;
  2771.                 w_component = BRW_VFCOMPONENT_STORE_SRC;
  2772.         }
  2773.  
  2774.         /* The VUE layout
  2775.          *    dword 0-3: pad (0.0, 0.0, 0.0. 0.0)
  2776.          *    dword 4-7: position (x, y, 1.0, 1.0),
  2777.          *    dword 8-11: texture coordinate 0 (u0, v0, w0, 1.0)
  2778.          *    dword 12-15: texture coordinate 1 (u1, v1, w1, 1.0)
  2779.          *
  2780.          * dword 4-15 are fetched from vertex buffer
  2781.          */
  2782.         OUT_BATCH(BRW_3DSTATE_VERTEX_ELEMENTS |
  2783.                 ((2 * (2 + nelem)) + 1 - 2));
  2784.  
  2785.         OUT_BATCH((id << GEN6_VE0_VERTEX_BUFFER_INDEX_SHIFT) | GEN6_VE0_VALID |
  2786.                   (BRW_SURFACEFORMAT_R32G32_FLOAT << VE0_FORMAT_SHIFT) |
  2787.                   (0 << VE0_OFFSET_SHIFT));
  2788.         OUT_BATCH((BRW_VFCOMPONENT_STORE_0 << VE1_VFCOMPONENT_0_SHIFT) |
  2789.                   (BRW_VFCOMPONENT_STORE_0 << VE1_VFCOMPONENT_1_SHIFT) |
  2790.                   (BRW_VFCOMPONENT_STORE_0 << VE1_VFCOMPONENT_2_SHIFT) |
  2791.                   (BRW_VFCOMPONENT_STORE_0 << VE1_VFCOMPONENT_3_SHIFT));
  2792.  
  2793.         /* x,y */
  2794.         OUT_BATCH((id << GEN6_VE0_VERTEX_BUFFER_INDEX_SHIFT) | GEN6_VE0_VALID |
  2795.                   (BRW_SURFACEFORMAT_R32G32_FLOAT << VE0_FORMAT_SHIFT) |
  2796.                   (0 << VE0_OFFSET_SHIFT)); /* offsets vb in bytes */
  2797.         OUT_BATCH((BRW_VFCOMPONENT_STORE_SRC << VE1_VFCOMPONENT_0_SHIFT) |
  2798.                   (BRW_VFCOMPONENT_STORE_SRC << VE1_VFCOMPONENT_1_SHIFT) |
  2799.                   (BRW_VFCOMPONENT_STORE_1_FLT << VE1_VFCOMPONENT_2_SHIFT) |
  2800.                   (BRW_VFCOMPONENT_STORE_1_FLT << VE1_VFCOMPONENT_3_SHIFT));
  2801.  
  2802.         /* u0, v0, w0 */
  2803.         OUT_BATCH((id << GEN6_VE0_VERTEX_BUFFER_INDEX_SHIFT) | GEN6_VE0_VALID |
  2804.                   (src_format << VE0_FORMAT_SHIFT) |
  2805.                   ((2 * 4) << VE0_OFFSET_SHIFT));       /* offset vb in bytes */
  2806.         OUT_BATCH((BRW_VFCOMPONENT_STORE_SRC << VE1_VFCOMPONENT_0_SHIFT) |
  2807.                   (BRW_VFCOMPONENT_STORE_SRC << VE1_VFCOMPONENT_1_SHIFT) |
  2808.                   (w_component << VE1_VFCOMPONENT_2_SHIFT) |
  2809.                   (BRW_VFCOMPONENT_STORE_1_FLT << VE1_VFCOMPONENT_3_SHIFT));
  2810.  
  2811.         /* u1, v1, w1 */
  2812.         if (has_mask) {
  2813.                 OUT_BATCH((id << GEN6_VE0_VERTEX_BUFFER_INDEX_SHIFT) |
  2814.                           GEN6_VE0_VALID |
  2815.                           (src_format << VE0_FORMAT_SHIFT) |
  2816.                           (((2 + selem) * 4) << VE0_OFFSET_SHIFT)); /* vb offset in bytes */
  2817.                 OUT_BATCH((BRW_VFCOMPONENT_STORE_SRC << VE1_VFCOMPONENT_0_SHIFT) |
  2818.                           (BRW_VFCOMPONENT_STORE_SRC << VE1_VFCOMPONENT_1_SHIFT) |
  2819.                           (w_component << VE1_VFCOMPONENT_2_SHIFT) |
  2820.                           (BRW_VFCOMPONENT_STORE_1_FLT << VE1_VFCOMPONENT_3_SHIFT));
  2821.         }
  2822. }
  2823.  
  2824. static void
  2825. gen6_emit_composite_state(struct intel_screen_private *intel)
  2826. {
  2827.         struct gen4_render_state *render = intel->gen4_render_state;
  2828.         gen4_composite_op *composite_op = &render->composite_op;
  2829.         sampler_state_filter_t src_filter = composite_op->src_filter;
  2830.         sampler_state_filter_t mask_filter = composite_op->mask_filter;
  2831.         sampler_state_extend_t src_extend = composite_op->src_extend;
  2832.         sampler_state_extend_t mask_extend = composite_op->mask_extend;
  2833.         Bool is_affine = composite_op->is_affine;
  2834.         Bool has_mask = intel->render_mask != NULL;
  2835.         Bool ivb = INTEL_INFO(intel)->gen >= 070;
  2836.         uint32_t src, dst;
  2837.         drm_intel_bo *ps_sampler_state_bo = render->ps_sampler_state_bo[src_filter][src_extend][mask_filter][mask_extend];
  2838.  
  2839.         intel->needs_render_state_emit = FALSE;
  2840.         if (intel->needs_3d_invariant) {
  2841.                 gen6_upload_invariant_states(intel);
  2842.  
  2843.                 if (ivb) {
  2844.                         gen7_upload_viewport_state_pointers(intel, render->cc_vp_bo);
  2845.                         gen7_upload_urb(intel);
  2846.                         gen7_upload_bypass_states(intel);
  2847.                         gen7_upload_depth_buffer_state(intel);
  2848.                 } else {
  2849.                         gen6_upload_invariant_states(intel);
  2850.                         gen6_upload_viewport_state_pointers(intel, render->cc_vp_bo);
  2851.                         gen6_upload_urb(intel);
  2852.  
  2853.                         gen6_upload_gs_state(intel);
  2854.                         gen6_upload_depth_buffer_state(intel);
  2855.                 }
  2856.                 gen6_composite_wm_constants(intel);
  2857.                 gen6_upload_vs_state(intel);
  2858.                 gen6_upload_clip_state(intel);
  2859.  
  2860.                 intel->needs_3d_invariant = FALSE;
  2861.         }
  2862.  
  2863.         i965_get_blend_cntl(composite_op->op,
  2864.                             intel->render_mask_picture,
  2865.                             intel->render_dest_picture->format,
  2866.                             &src, &dst);
  2867.  
  2868.         if (intel->surface_reloc == 0)
  2869.                 gen6_composite_state_base_address(intel);
  2870.  
  2871.         gen6_composite_cc_state_pointers(intel,
  2872.                                         (src * BRW_BLENDFACTOR_COUNT + dst) * GEN6_BLEND_STATE_PADDED_SIZE);
  2873.         gen6_composite_sampler_state_pointers(intel, ps_sampler_state_bo);
  2874.         gen6_composite_sf_state(intel, has_mask);
  2875.         if (ivb) {
  2876.                 gen7_composite_wm_state(intel, has_mask,
  2877.                                         render->wm_kernel_bo[composite_op->wm_kernel]);
  2878.                 gen7_upload_binding_table(intel, intel->surface_table);
  2879.         } else {
  2880.                 gen6_composite_wm_state(intel, has_mask,
  2881.                                         render->wm_kernel_bo[composite_op->wm_kernel]);
  2882.                 gen6_upload_binding_table(intel, intel->surface_table);
  2883.         }
  2884.         gen6_composite_drawing_rectangle(intel, intel->render_dest);
  2885.         gen6_composite_vertex_element_state(intel, has_mask, is_affine);
  2886. }
  2887.  
  2888. static void
  2889. gen6_render_state_init()
  2890. {
  2891.     ENTER();
  2892.  
  2893.         intel_screen_private *intel = intel_get_screen_private();
  2894.         struct gen4_render_state *render;
  2895.         sampler_state_filter_t src_filter;
  2896.         sampler_state_filter_t mask_filter;
  2897.         sampler_state_extend_t src_extend;
  2898.         sampler_state_extend_t mask_extend;
  2899.         int m;
  2900.         drm_intel_bo *border_color_bo;
  2901.         const struct wm_kernel_info *wm_kernels;
  2902.  
  2903.         render= intel->gen4_render_state;
  2904.         render->composite_op.vertex_id = -1;
  2905.  
  2906.         intel->gen6_render_state.num_sf_outputs = 0;
  2907.         intel->gen6_render_state.samplers = NULL;
  2908.         intel->gen6_render_state.blend = -1;
  2909.         intel->gen6_render_state.kernel = NULL;
  2910.         intel->gen6_render_state.drawrect = -1;
  2911.  
  2912.         wm_kernels = IS_GEN7(intel) ? wm_kernels_gen7 : wm_kernels_gen6;
  2913.         for (m = 0; m < KERNEL_COUNT; m++) {
  2914.                 render->wm_kernel_bo[m] =
  2915.                         intel_bo_alloc_for_data(intel,
  2916.                                         wm_kernels[m].data,
  2917.                                         wm_kernels[m].size,
  2918.                                         "WM kernel gen6/7");
  2919.         }
  2920.  
  2921.         border_color_bo = sampler_border_color_create(intel);
  2922.  
  2923.         for (src_filter = 0; src_filter < FILTER_COUNT; src_filter++) {
  2924.                 for (src_extend = 0; src_extend < EXTEND_COUNT; src_extend++) {
  2925.                         for (mask_filter = 0; mask_filter < FILTER_COUNT; mask_filter++) {
  2926.                                 for (mask_extend = 0; mask_extend < EXTEND_COUNT; mask_extend++) {
  2927.                                         render->ps_sampler_state_bo[src_filter][src_extend][mask_filter][mask_extend] =
  2928.                                                 i965_create_sampler_state(intel,
  2929.                                                                           src_filter, src_extend,
  2930.                                                                           mask_filter, mask_extend,
  2931.                                                                 border_color_bo);
  2932.                                 }
  2933.                         }
  2934.                 }
  2935.         }
  2936.  
  2937.         drm_intel_bo_unreference(border_color_bo);
  2938.         render->cc_vp_bo = gen4_create_cc_viewport(intel);
  2939.         render->cc_state_bo = gen6_composite_create_cc_state(intel);
  2940.         render->gen6_blend_bo = gen6_composite_create_blend_state(intel);
  2941.         render->gen6_depth_stencil_bo = gen6_composite_create_depth_stencil_state(intel);
  2942.  
  2943.     LEAVE();
  2944. }
  2945.  
  2946. void i965_vertex_flush(struct intel_screen_private *intel)
  2947. {
  2948.         if (intel->vertex_offset) {
  2949.                 intel->batch_ptr[intel->vertex_offset] =
  2950.                         intel->vertex_index - intel->vertex_count;
  2951.                 intel->vertex_offset = 0;
  2952.         }
  2953. }
  2954.  
  2955. void i965_batch_flush(struct intel_screen_private *intel)
  2956. {
  2957.         if (intel->surface_used)
  2958.                 i965_surface_flush(intel);
  2959. }
  2960.  
  2961.  
  2962. #if HAS_DEVPRIVATEKEYREC
  2963. DevPrivateKeyRec uxa_pixmap_index;
  2964. #else
  2965. int uxa_pixmap_index;
  2966. #endif
  2967.  
  2968. #define xFixedToFloat(val) \
  2969.         ((float)xFixedToInt(val) + ((float)xFixedFrac(val) / 65536.0))
  2970.  
  2971. static Bool
  2972. _intel_transform_point(PictTransformPtr transform,
  2973.                        float x, float y, float result[3])
  2974. {
  2975.         int j;
  2976.  
  2977.         for (j = 0; j < 3; j++) {
  2978.                 result[j] = (xFixedToFloat(transform->matrix[j][0]) * x +
  2979.                              xFixedToFloat(transform->matrix[j][1]) * y +
  2980.                              xFixedToFloat(transform->matrix[j][2]));
  2981.         }
  2982.         if (!result[2])
  2983.                 return FALSE;
  2984.         return TRUE;
  2985. }
  2986.  
  2987. /**
  2988.  * Returns the floating-point coordinates transformed by the given transform.
  2989.  *
  2990.  * transform may be null.
  2991.  */
  2992. Bool
  2993. intel_get_transformed_coordinates(int x, int y, PictTransformPtr transform,
  2994.                                   float *x_out, float *y_out)
  2995. {
  2996.         if (transform == NULL) {
  2997.                 *x_out = x;
  2998.                 *y_out = y;
  2999.         } else {
  3000.                 float result[3];
  3001.  
  3002.                 if (!_intel_transform_point(transform,
  3003.                                             x, y,
  3004.                                             result))
  3005.                         return FALSE;
  3006.                 *x_out = result[0] / result[2];
  3007.                 *y_out = result[1] / result[2];
  3008.         }
  3009.         return TRUE;
  3010. }
  3011.  
  3012. /**
  3013.  * Returns the un-normalized floating-point coordinates transformed by the given transform.
  3014.  *
  3015.  * transform may be null.
  3016.  */
  3017. Bool
  3018. intel_get_transformed_coordinates_3d(int x, int y, PictTransformPtr transform,
  3019.                                      float *x_out, float *y_out, float *w_out)
  3020. {
  3021.         if (transform == NULL) {
  3022.                 *x_out = x;
  3023.                 *y_out = y;
  3024.                 *w_out = 1;
  3025.         } else {
  3026.                 float result[3];
  3027.  
  3028.                 if (!_intel_transform_point(transform,
  3029.                                             x, y,
  3030.                                             result))
  3031.                         return FALSE;
  3032.                 *x_out = result[0];
  3033.                 *y_out = result[1];
  3034.                 *w_out = result[2];
  3035.         }
  3036.         return TRUE;
  3037. }
  3038.  
  3039. /**
  3040.  * Returns whether the provided transform is affine.
  3041.  *
  3042.  * transform may be null.
  3043.  */
  3044. Bool intel_transform_is_affine(PictTransformPtr t)
  3045. {
  3046.         if (t == NULL)
  3047.                 return TRUE;
  3048.         return t->matrix[2][0] == 0 && t->matrix[2][1] == 0;
  3049. }
  3050.