← Back to branch summary

~ubuntu-branches/ubuntu/precise/mesa/precise-updates

« back to all changes in this revision

Viewing changes to src/gallium/drivers/i965/brw_clip_state.c

  • Committer: Package Import Robot
  • Author(s): Robert Hooker
  • Date: 2012-02-02 12:05:48 UTC
  • mfrom: (1.7.1) (3.3.27 sid)
  • Revision ID: package-import@ubuntu.com-20120202120548-nvkma85jq0h4coix
Tags: 8.0~rc2-0ubuntu4
Drop drisearchdir handling, it is no longer needed with multiarch
and dri-alternates being removed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gallium/drivers/i965/brw_clip_state.c
1
 
/*
2
 
 Copyright (C) Intel Corp.  2006.  All Rights Reserved.
3
 
 Intel funded Tungsten Graphics (http://www.tungstengraphics.com) to
4
 
 develop this 3D driver.
5
 
 
6
 
 Permission is hereby granted, free of charge, to any person obtaining
7
 
 a copy of this software and associated documentation files (the
8
 
 "Software"), to deal in the Software without restriction, including
9
 
 without limitation the rights to use, copy, modify, merge, publish,
10
 
 distribute, sublicense, and/or sell copies of the Software, and to
11
 
 permit persons to whom the Software is furnished to do so, subject to
12
 
 the following conditions:
13
 
 
14
 
 The above copyright notice and this permission notice (including the
15
 
 next paragraph) shall be included in all copies or substantial
16
 
 portions of the Software.
17
 
 
18
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
19
 
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20
 
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
21
 
 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
22
 
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
23
 
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
24
 
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25
 
 
26
 
 **********************************************************************/
27
 
 /*
28
 
  * Authors:
29
 
  *   Keith Whitwell <keith@tungstengraphics.com>
30
 
  */
31
 
 
32
 
#include "util/u_math.h"
33
 
 
34
 
#include "brw_context.h"
35
 
#include "brw_clip.h"
36
 
#include "brw_state.h"
37
 
#include "brw_defines.h"
38
 
#include "brw_debug.h"
39
 
 
40
 
struct brw_clip_unit_key {
41
 
   unsigned int total_grf;
42
 
   unsigned int urb_entry_read_length;
43
 
   unsigned int curb_entry_read_length;
44
 
   unsigned int clip_mode;
45
 
 
46
 
   unsigned int curbe_offset;
47
 
 
48
 
   unsigned int nr_urb_entries, urb_size;
49
 
 
50
 
   GLboolean depth_clamp;
51
 
};
52
 
 
53
 
static void
54
 
clip_unit_populate_key(struct brw_context *brw, struct brw_clip_unit_key *key)
55
 
{
56
 
   memset(key, 0, sizeof(*key));
57
 
 
58
 
   /* CACHE_NEW_CLIP_PROG */
59
 
   key->total_grf = brw->clip.prog_data->total_grf;
60
 
   key->urb_entry_read_length = brw->clip.prog_data->urb_read_length;
61
 
   key->curb_entry_read_length = brw->clip.prog_data->curb_read_length;
62
 
   key->clip_mode = brw->clip.prog_data->clip_mode;
63
 
 
64
 
   /* BRW_NEW_CURBE_OFFSETS */
65
 
   key->curbe_offset = brw->curbe.clip_start;
66
 
 
67
 
   /* BRW_NEW_URB_FENCE */
68
 
   key->nr_urb_entries = brw->urb.nr_clip_entries;
69
 
   key->urb_size = brw->urb.vsize;
70
 
 
71
 
   /*  */
72
 
   key->depth_clamp = 0; /* XXX: add this to gallium: ctx->Transform.DepthClamp; */
73
 
}
74
 
 
75
 
static enum pipe_error
76
 
clip_unit_create_from_key(struct brw_context *brw,
77
 
                          struct brw_clip_unit_key *key,
78
 
                          struct brw_winsys_reloc *reloc,
79
 
                          struct brw_winsys_buffer **bo_out)
80
 
{
81
 
   struct brw_clip_unit_state clip;
82
 
   enum pipe_error ret;
83
 
 
84
 
   memset(&clip, 0, sizeof(clip));
85
 
 
86
 
   clip.thread0.grf_reg_count = align(key->total_grf, 16) / 16 - 1;
87
 
   /* reloc */
88
 
   clip.thread0.kernel_start_pointer = 0;
89
 
 
90
 
   clip.thread1.floating_point_mode = BRW_FLOATING_POINT_NON_IEEE_754;
91
 
   clip.thread1.single_program_flow = 1;
92
 
 
93
 
   clip.thread3.urb_entry_read_length = key->urb_entry_read_length;
94
 
   clip.thread3.const_urb_entry_read_length = key->curb_entry_read_length;
95
 
   clip.thread3.const_urb_entry_read_offset = key->curbe_offset * 2;
96
 
   clip.thread3.dispatch_grf_start_reg = 1;
97
 
   clip.thread3.urb_entry_read_offset = 0;
98
 
 
99
 
   clip.thread4.nr_urb_entries = key->nr_urb_entries;
100
 
   clip.thread4.urb_entry_allocation_size = key->urb_size - 1;
101
 
   /* If we have enough clip URB entries to run two threads, do so.
102
 
    */
103
 
   if (key->nr_urb_entries >= 10) {
104
 
      /* Half of the URB entries go to each thread, and it has to be an
105
 
       * even number.
106
 
       */
107
 
      assert(key->nr_urb_entries % 2 == 0);
108
 
      
109
 
      /* Although up to 16 concurrent Clip threads are allowed on IGDNG, 
110
 
       * only 2 threads can output VUEs at a time.
111
 
       */
112
 
      if (brw->gen == 5)
113
 
         clip.thread4.max_threads = 16 - 1;        
114
 
      else
115
 
         clip.thread4.max_threads = 2 - 1;
116
 
   } else {
117
 
      assert(key->nr_urb_entries >= 5);
118
 
      clip.thread4.max_threads = 1 - 1;
119
 
   }
120
 
 
121
 
   if (BRW_DEBUG & DEBUG_SINGLE_THREAD)
122
 
      clip.thread4.max_threads = 0;
123
 
 
124
 
   if (BRW_DEBUG & DEBUG_STATS)
125
 
      clip.thread4.stats_enable = 1;
126
 
 
127
 
   clip.clip5.userclip_enable_flags = 0x7f;
128
 
   clip.clip5.userclip_must_clip = 1;
129
 
   clip.clip5.guard_band_enable = 0;
130
 
   if (!key->depth_clamp)
131
 
      clip.clip5.viewport_z_clip_enable = 1;
132
 
   clip.clip5.viewport_xy_clip_enable = 1;
133
 
   clip.clip5.vertex_position_space = BRW_CLIP_NDCSPACE;
134
 
   clip.clip5.api_mode = BRW_CLIP_API_OGL;
135
 
   clip.clip5.clip_mode = key->clip_mode;
136
 
 
137
 
   if (brw->is_g4x)
138
 
      clip.clip5.negative_w_clip_test = 1;
139
 
 
140
 
   clip.clip6.clipper_viewport_state_ptr = 0;
141
 
   clip.viewport_xmin = -1;
142
 
   clip.viewport_xmax = 1;
143
 
   clip.viewport_ymin = -1;
144
 
   clip.viewport_ymax = 1;
145
 
 
146
 
   ret = brw_upload_cache(&brw->cache, BRW_CLIP_UNIT,
147
 
                          key, sizeof(*key),
148
 
                          reloc, 1,
149
 
                          &clip, sizeof(clip),
150
 
                          NULL, NULL,
151
 
                          bo_out);
152
 
   if (ret)
153
 
      return ret;
154
 
 
155
 
   return PIPE_OK;
156
 
}
157
 
 
158
 
static int upload_clip_unit( struct brw_context *brw )
159
 
{
160
 
   struct brw_clip_unit_key key;
161
 
   struct brw_winsys_reloc reloc[1];
162
 
   unsigned grf_reg_count;
163
 
   enum pipe_error ret;
164
 
 
165
 
   clip_unit_populate_key(brw, &key);
166
 
 
167
 
   grf_reg_count = align(key.total_grf, 16) / 16 - 1;
168
 
 
169
 
   /* clip program relocation
170
 
    *
171
 
    * XXX: these reloc structs are long lived and only need to be
172
 
    * updated when the bound BO changes.  Hopefully the stuff mixed in
173
 
    * in the delta's is non-orthogonal.
174
 
    */
175
 
   assert(brw->clip.prog_bo);
176
 
   make_reloc(&reloc[0],
177
 
              BRW_USAGE_STATE,
178
 
              grf_reg_count << 1,
179
 
              offsetof(struct brw_clip_unit_state, thread0),
180
 
              brw->clip.prog_bo);
181
 
 
182
 
 
183
 
   if (brw_search_cache(&brw->cache, BRW_CLIP_UNIT,
184
 
                        &key, sizeof(key),
185
 
                        reloc, 1,
186
 
                        NULL,
187
 
                        &brw->clip.state_bo))
188
 
      return PIPE_OK;
189
 
      
190
 
   /* Create new:
191
 
    */
192
 
   ret = clip_unit_create_from_key(brw, &key, 
193
 
                                   reloc,
194
 
                                   &brw->clip.state_bo);
195
 
   if (ret)
196
 
      return ret;
197
 
   
198
 
   return PIPE_OK;
199
 
}
200
 
 
201
 
const struct brw_tracked_state brw_clip_unit = {
202
 
   .dirty = {
203
 
      .mesa  = 0,
204
 
      .brw   = (BRW_NEW_CURBE_OFFSETS |
205
 
                BRW_NEW_URB_FENCE),
206
 
      .cache = CACHE_NEW_CLIP_PROG
207
 
   },
208
 
   .prepare = upload_clip_unit,
209
 
};