← Back to branch summary

~ubuntu-branches/ubuntu/quantal/mesa-glw/quantal

« back to all changes in this revision

Viewing changes to src/mesa/drivers/dri/gamma/gamma_macros.h

  • Committer: Bazaar Package Importer
  • Author(s): Morten Kjeldgaard
  • Date: 2008-05-06 16:19:15 UTC
  • Revision ID: james.westby@ubuntu.com-20080506161915-uynz7nftmfixu6bq
Tags: upstream-7.0.3
Import upstream version 7.0.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mesa/drivers/dri/gamma/gamma_macros.h
 
1
/* $XFree86: xc/lib/GL/mesa/src/drv/gamma/gamma_macros.h,v 1.5 2002/02/22 21:33:02 dawes Exp $ */
 
2
/**************************************************************************
 
3
 
 
4
Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
 
5
All Rights Reserved.
 
6
 
 
7
Permission is hereby granted, free of charge, to any person obtaining a
 
8
copy of this software and associated documentation files (the
 
9
"Software"), to deal in the Software without restriction, including
 
10
without limitation the rights to use, copy, modify, merge, publish,
 
11
distribute, sub license, and/or sell copies of the Software, and to
 
12
permit persons to whom the Software is furnished to do so, subject to
 
13
the following conditions:
 
14
 
 
15
The above copyright notice and this permission notice (including the
 
16
next paragraph) shall be included in all copies or substantial portions
 
17
of the Software.
 
18
 
 
19
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 
20
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 
21
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
 
22
IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
 
23
ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 
24
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 
25
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
26
 
 
27
**************************************************************************/
 
28
 
 
29
/*
 
30
 * Authors:
 
31
 *   Kevin E. Martin <kevin@precisioninsight.com>
 
32
 *
 
33
 */
 
34
 
 
35
#ifndef _GAMMA_MACROS_H_
 
36
#define _GAMMA_MACROS_H_
 
37
 
 
38
#define DEBUG_DRMDMA
 
39
#define DEBUG_ERRORS
 
40
#define DEBUG_COMMANDS_NOT
 
41
#define DEBUG_VERBOSE_NOT
 
42
#define DEBUG_VERBOSE_EXTRA_NOT
 
43
 
 
44
#define RANDOMIZE_COLORS_NOT
 
45
#define TURN_OFF_CLEARS_NOT
 
46
#define CULL_ALL_PRIMS_NOT
 
47
#define TURN_OFF_DEPTH_NOT
 
48
#define TURN_OFF_BLEND_NOT
 
49
#define FAST_CLEAR_4_NOT
 
50
#define FORCE_DEPTH32_NOT
 
51
#define DONT_SEND_DMA_NOT
 
52
#define TURN_OFF_FCP_NOT
 
53
#define TURN_OFF_TEXTURES_NOT
 
54
#define DO_VALIDATE
 
55
 
 
56
#define GAMMA_DMA_BUFFER_SIZE 4096
 
57
 
 
58
#if 0
 
59
#define GAMMA_DMA_SEND_FLAGS    DRM_DMA_PRIORITY
 
60
#define GAMMA_DMA_SEND_FLAGS    DRM_DMA_BLOCK
 
61
#else
 
62
/* MUST use non-blocking dma flags for drawable lock routines */
 
63
#define GAMMA_DMA_SEND_FLAGS    0
 
64
#endif
 
65
 
 
66
#if 0
 
67
#define GAMMA_DMA_GET_FLAGS     \
 
68
    (DRM_DMA_SMALLER_OK | DRM_DMA_LARGER_OK | DRM_DMA_WAIT)
 
69
#else
 
70
#define GAMMA_DMA_GET_FLAGS     DRM_DMA_WAIT
 
71
#endif
 
72
 
 
73
#if defined(DEBUG_DRMDMA) || defined(DEBUG_COMMANDS) || defined(DEBUG_VERBOSE)
 
74
#include <stdio.h>
 
75
#endif
 
76
 
 
77
/* Note: The argument to DEBUG_GLCMDS() _must_ be enclosed in parenthesis */
 
78
#ifdef DEBUG_VERBOSE
 
79
#define DEBUG_GLCMDS(s) printf s
 
80
#else
 
81
#define DEBUG_GLCMDS(s)
 
82
#endif
 
83
 
 
84
/* Note: The argument to DEBUG_DMACMDS() _must_ be enclosed in parenthesis */
 
85
#ifdef DEBUG_DRMDMA
 
86
#define DEBUG_DMACMDS(s) printf s
 
87
#else
 
88
#define DEBUG_DMACMDS(s)
 
89
#endif
 
90
 
 
91
/* Note: The argument to DEBUG_WRITE() _must_ be enclosed in parenthesis */
 
92
#ifdef DEBUG_COMMANDS
 
93
#define DEBUG_WRITE(s) printf s
 
94
#else
 
95
#define DEBUG_WRITE(s)
 
96
#endif
 
97
 
 
98
/* Note: The argument to DEBUG_ERROR() _must_ be enclosed in parenthesis */
 
99
#ifdef DEBUG_ERRORS
 
100
#define DEBUG_ERROR(s) printf s
 
101
#else
 
102
#define DEBUG_ERROR(s)
 
103
#endif
 
104
 
 
105
#define WRITEV(buf,val1,val2,val3,val4)                               \
 
106
do {                                                                  \
 
107
    buf++->i = 0x9C008300;                        \
 
108
    buf++->f = val1;                                                   \
 
109
    buf++->f = val2;                                                   \
 
110
    buf++->f = val3;                                                   \
 
111
    buf++->f = val4;                                                   \
 
112
} while (0)
 
113
 
 
114
#define WRITE(buf,reg,val)                                            \
 
115
do {                                                                  \
 
116
    buf++->i = Glint##reg##Tag;                                       \
 
117
    buf++->i = val;                                                   \
 
118
    DEBUG_WRITE(("WRITE(buf, %s, 0x%08x);\n", #reg, (int)val));       \
 
119
} while (0)
 
120
 
 
121
#define WRITEF(buf,reg,val)                                           \
 
122
do {                                                                  \
 
123
    buf++->i = Glint##reg##Tag;                                       \
 
124
    buf++->f = val;                                                   \
 
125
    DEBUG_WRITE(("WRITEF(buf, %s, %f);\n", #reg, (float)val));        \
 
126
} while (0)
 
127
 
 
128
#define CHECK_WC_DMA_BUFFER(gcp,n)                                    \
 
129
do {                                                                  \
 
130
    (gcp)->WCbufCount += (n<<1);                                      \
 
131
} while (0)
 
132
 
 
133
#define CHECK_DMA_BUFFER(gcp,n)                                   \
 
134
do {                                                                  \
 
135
    if ((gcp)->bufCount+(n<<1) >= (gcp)->bufSize)                     \
 
136
        PROCESS_DMA_BUFFER(gcp);                                  \
 
137
    (gcp)->bufCount += (n<<1);                                        \
 
138
} while (0)
 
139
 
 
140
#define CHECK_DMA_BUFFER2(gcp,n)                                   \
 
141
do {                                                                  \
 
142
    if ((gcp)->bufCount+n >= (gcp)->bufSize)                     \
 
143
        PROCESS_DMA_BUFFER(gcp);                                  \
 
144
    (gcp)->bufCount += n;                                        \
 
145
} while (0)
 
146
 
 
147
#define FLUSH_DMA_BUFFER(gcp)                                     \
 
148
do {                                                                  \
 
149
   if (gcp->bufCount)                                                \
 
150
        PROCESS_DMA_BUFFER(gcp);                                  \
 
151
} while (0)
 
152
 
 
153
#ifdef DONT_SEND_DMA
 
154
#define GET_DMA(fd, hHWCtx, n, idx, size)
 
155
#define SEND_DMA(fd, hHWCtx,n, idx, cnt)
 
156
#else
 
157
#define GET_DMA(fd, hHWCtx, n, idx, size)                                  \
 
158
do {                                                                       \
 
159
    drmDMAReq dma;                                                         \
 
160
    int retcode, i;                                                        \
 
161
                                                                           \
 
162
    dma.context       = (hHWCtx);                                          \
 
163
    dma.send_count    = 0;                                                 \
 
164
    dma.send_list     = NULL;                                              \
 
165
    dma.send_sizes    = NULL;                                              \
 
166
    dma.flags         = GAMMA_DMA_GET_FLAGS;                               \
 
167
    dma.request_count = (n);                                               \
 
168
    dma.request_size  = GAMMA_DMA_BUFFER_SIZE;                             \
 
169
    dma.request_list  = (idx);                                             \
 
170
    dma.request_sizes = (size);                                            \
 
171
                                                                           \
 
172
    do {                                                                   \
 
173
        if ((retcode = drmDMA((fd), &dma))) {                              \
 
174
            DEBUG_DMACMDS(("drmDMA returned %d\n", retcode));              \
 
175
        }                                                                  \
 
176
    } while (!(dma).granted_count);                                        \
 
177
                                                                           \
 
178
    for (i = 0; i < (n); i++) {                                            \
 
179
        (size)[i] >>= 2; /* Convert from bytes to words */                 \
 
180
    }                                                                      \
 
181
} while (0)
 
182
 
 
183
#define SEND_DMA(fd, hHWCtx, n, idx, cnt)                                  \
 
184
do {                                                                       \
 
185
    drmDMAReq dma;                                                         \
 
186
    int retcode, i;                                                        \
 
187
                                                                           \
 
188
    for (i = 0; i < (n); i++) {                                            \
 
189
        (cnt)[i] <<= 2; /* Convert from words to bytes */                  \
 
190
    }                                                                      \
 
191
                                                                           \
 
192
    dma.context       = (hHWCtx);                                          \
 
193
    dma.send_count    = 1;                                                 \
 
194
    dma.send_list     = (idx);                                             \
 
195
    dma.send_sizes    = (cnt);                                             \
 
196
    dma.flags         = GAMMA_DMA_SEND_FLAGS;                              \
 
197
    dma.request_count = 0;                                                 \
 
198
    dma.request_size  = 0;                                                 \
 
199
    dma.request_list  = NULL;                                              \
 
200
    dma.request_sizes = NULL;                                              \
 
201
                                                                           \
 
202
    if ((retcode = drmDMA((fd), &dma))) {                                  \
 
203
        DEBUG_DMACMDS(("drmDMA returned %d\n", retcode));                  \
 
204
    }                                                                      \
 
205
                                                                           \
 
206
    for (i = 0; i < (n); i++) {                                            \
 
207
        (cnt)[i] = 0;                                                      \
 
208
    }                                                                      \
 
209
} while (0)
 
210
#endif
 
211
 
 
212
#define GET_FIRST_DMA(fd, hHWCtx, n, idx, size, buf, cnt, gPriv)           \
 
213
do {                                                                       \
 
214
    int i;                                                                 \
 
215
                                                                           \
 
216
    GET_DMA(fd, hHWCtx, n, idx, size);                                     \
 
217
                                                                           \
 
218
    for (i = 0; i < (n); i++) {                                            \
 
219
        (buf)[i] = (dmaBuf)(gPriv)->bufs->list[(idx)[i]].address;          \
 
220
        (cnt)[i] = 0;                                                      \
 
221
    }                                                                      \
 
222
} while (0)
 
223
 
 
224
#define PROCESS_DMA_BUFFER_TOP_HALF(gcp)                                   \
 
225
do {                                                                       \
 
226
    SEND_DMA((gcp)->driFd,                        \
 
227
             (gcp)->hHWContext, 1, &(gcp)->bufIndex, &(gcp)->bufCount);    \
 
228
} while (0)
 
229
 
 
230
#define PROCESS_DMA_BUFFER_BOTTOM_HALF(gcp)                                \
 
231
do {                                                                       \
 
232
    GET_DMA((gcp)->driFd,                         \
 
233
            (gcp)->hHWContext, 1, &(gcp)->bufIndex, &(gcp)->bufSize);      \
 
234
                                                                           \
 
235
    (gcp)->buf =                                                           \
 
236
        (dmaBuf)(gcp)->gammaScreen->bufs->list[(gcp)->bufIndex].address; \
 
237
} while (0)
 
238
 
 
239
#define PROCESS_DMA_BUFFER(gcp)                                        \
 
240
do {                                                                       \
 
241
    VALIDATE_DRAWABLE_INFO(gcp);                             \
 
242
    PROCESS_DMA_BUFFER_TOP_HALF(gcp);                                      \
 
243
    PROCESS_DMA_BUFFER_BOTTOM_HALF(gcp);                                   \
 
244
} while (0)
 
245
 
 
246
#ifdef DO_VALIDATE
 
247
#define VALIDATE_DRAWABLE_INFO_NO_LOCK(gcp)                                \
 
248
do {                                                                       \
 
249
    /*__DRIscreenPrivate *psp = gcp->driScreen;*/                          \
 
250
    __DRIdrawablePrivate *pdp = gcp->driDrawable;                          \
 
251
                                                                           \
 
252
    if (*(pdp->pStamp) != pdp->lastStamp) {                                \
 
253
        int old_index = pdp->index;                                        \
 
254
        while (*(pdp->pStamp) != pdp->lastStamp) {                         \
 
255
            DRI_VALIDATE_DRAWABLE_INFO_ONCE(pdp);                          \
 
256
        }                                                                  \
 
257
        if (pdp->index != old_index) {                                     \
 
258
            gcp->Window &= ~W_GIDMask;                                     \
 
259
            gcp->Window |= (pdp->index << 5);                              \
 
260
            CHECK_WC_DMA_BUFFER(gcp, 1);                                   \
 
261
            WRITE(gcp->WCbuf, GLINTWindow, gcp->Window|(gcp->FrameCount<<9));\
 
262
        }                                                                  \
 
263
                                                                           \
 
264
        gammaUpdateViewportOffset( gcp->glCtx);                            \
 
265
                                                                           \
 
266
        if (pdp->numClipRects == 1 &&                                      \
 
267
            pdp->pClipRects->x1 ==  pdp->x &&                              \
 
268
            pdp->pClipRects->x2 == (pdp->x+pdp->w) &&                      \
 
269
            pdp->pClipRects->y1 ==  pdp->y &&                              \
 
270
            pdp->pClipRects->y2 == (pdp->y+pdp->h)) {                      \
 
271
            CHECK_WC_DMA_BUFFER(gcp, 1);                                   \
 
272
            WRITE(gcp->WCbuf, Rectangle2DControl, 0);                     \
 
273
            gcp->NotClipped = GL_TRUE;                                     \
 
274
        } else {                                                           \
 
275
            CHECK_WC_DMA_BUFFER(gcp, 1);                                   \
 
276
            WRITE(gcp->WCbuf, Rectangle2DControl, 1);                     \
 
277
            gcp->NotClipped = GL_FALSE;                                    \
 
278
        }                                                                  \
 
279
        gcp->WindowChanged = GL_TRUE;                                      \
 
280
                                                                           \
 
281
        if (gcp->WCbufCount) {                                             \
 
282
            SEND_DMA((gcp)->gammaScreen->driScreen->fd,                \
 
283
                     (gcp)->hHWContext, 1, &(gcp)->WCbufIndex,             \
 
284
                     &(gcp)->WCbufCount);                                  \
 
285
            (gcp)->WCbufIndex = -1;                                        \
 
286
        }                                                                  \
 
287
    }                                                                      \
 
288
} while (0)
 
289
 
 
290
#define VALIDATE_DRAWABLE_INFO_NO_LOCK_POST(gcp)                       \
 
291
do {                                                                       \
 
292
    if ((gcp)->WCbufIndex < 0) {                                           \
 
293
        GET_DMA((gcp)->gammaScreen->driScreen->fd,                     \
 
294
                (gcp)->hHWContext, 1, &(gcp)->WCbufIndex,                  \
 
295
                &(gcp)->WCbufSize);                                        \
 
296
                                                                           \
 
297
        (gcp)->WCbuf =                                                     \
 
298
            (dmaBuf)(gcp)->gammaScreen->bufs->                           \
 
299
                list[(gcp)->WCbufIndex].address;                           \
 
300
    }                                                                      \
 
301
} while (0)
 
302
 
 
303
#define VALIDATE_DRAWABLE_INFO(gcp)                                    \
 
304
do {                                                                       \
 
305
    __DRIscreenPrivate *psp = gcp->driScreen;                          \
 
306
if (gcp->driDrawable) { \
 
307
    DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);            \
 
308
    VALIDATE_DRAWABLE_INFO_NO_LOCK(gcp);                               \
 
309
    DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);          \
 
310
    VALIDATE_DRAWABLE_INFO_NO_LOCK_POST(gcp);                          \
 
311
} \
 
312
} while (0)
 
313
#else
 
314
#define VALIDATE_DRAWABLE_INFO(gcp)
 
315
#endif
 
316
 
 
317
#define CALC_LOG2(l2,s)                       \
 
318
do {                                          \
 
319
    int __s = s;                              \
 
320
    l2 = 0;                                   \
 
321
    while (__s > 1) { ++l2; __s >>= 1; }      \
 
322
} while (0)
 
323
 
 
324
#endif /* _GAMMA_MACROS_H_ */