← Back to branch summary

~ubuntu-branches/ubuntu/natty/mesa/natty-proposed

« back to all changes in this revision

Viewing changes to src/gallium/drivers/r300/r300_cs.h

  • Committer: Bazaar Package Importer
  • Author(s): Robert Hooker, Robert Hooker, Christopher James Halse Rogers
  • Date: 2010-09-14 08:55:40 UTC
  • mfrom: (1.2.28 upstream)
  • Revision ID: james.westby@ubuntu.com-20100914085540-m4fpl0hdjlfd4jgz
Tags: 7.9~git20100909-0ubuntu1
https://launchpad.net/bugs/631413
https://launchpad.net/bugs/628930
https://launchpad.net/bugs/628727
https://launchpad.net/bugs/596292
https://launchpad.net/bugs/599741
https://launchpad.net/bugs/630315
https://launchpad.net/bugs/613694
https://launchpad.net/bugs/599741
https://launchpad.net/bugs/578619
https://launchpad.net/bugs/626943
https://launchpad.net/bugs/610541
https://launchpad.net/bugs/601052
[ Robert Hooker ]
* New upstream git snapshot up to commit 94118fe2d4b1e5 (LP: #631413)
* New features include ATI HD5xxx series support in r600, and a vastly
  improved glsl compiler.
* Remove pre-generated .pc's, use the ones generated at build time
  instead.
* Remove all references to mesa-utils now that its no longer shipped
  with the mesa source.
* Disable the experimental ARB_fragment_shader option by default on
  i915, it exposes incomplete functionality that breaks KDE compositing
  among other things. It can be enabled via driconf still. (LP: #628930).

[ Christopher James Halse Rogers ]
* debian/patches/04_osmesa_version.diff:
  - Refresh for new upstream
* Bugs fixed in this release:
  - Fixes severe rendering corruption in Unity on radeon (LP: #628727,
    LP: #596292, LP: #599741, LP: #630315, LP: #613694, LP: #599741).
  - Also fixes rendering in gnome-shell (LP: #578619).
  - Flickering in OpenGL apps on radeon (LP: #626943, LP: #610541).
  - Provides preliminary support for new intel chips (LP: #601052).
* debian/rules:
  - Update configure flags to match upstream reshuffling.
  - Explicitly remove gallium DRI drivers that we don't want to ship.
* Update debian/gbp.conf for this Maverick-specific packaging
* libegl1-mesa-dri-x11,kms: There are no longer separate kms or x11 drivers
  for EGL, libegl1-mesa-drivers now contains a single driver that provides
  both backends.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gallium/drivers/r300/r300_cs.h
20
20
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
21
21
 * USE OR OTHER DEALINGS IN THE SOFTWARE. */
22
22
 
 
23
/**
 
24
 * This file contains macros for immediate command submission.
 
25
 */
 
26
 
23
27
#ifndef R300_CS_H
24
28
#define R300_CS_H
25
29
 
26
 
#include "util/u_math.h"
27
 
 
28
30
#include "r300_reg.h"
29
 
 
30
 
#include "radeon_winsys.h"
 
31
#include "r300_context.h"
 
32
#include "r300_winsys.h"
31
33
 
32
34
/* Yes, I know macros are ugly. However, they are much prettier than the code
33
35
 * that they neatly hide away, and don't have the cost of function setup,so
34
36
 * we're going to use them. */
35
37
 
36
 
#define MAX_CS_SIZE 64 * 1024 / 4
37
 
 
38
 
#define VERY_VERBOSE_CS 1
39
 
#define VERY_VERBOSE_REGISTERS 1
40
 
 
41
 
/* XXX stolen from radeon_drm.h */
42
 
#define RADEON_GEM_DOMAIN_CPU  0x1
43
 
#define RADEON_GEM_DOMAIN_GTT  0x2
44
 
#define RADEON_GEM_DOMAIN_VRAM 0x4
45
 
 
46
 
/* XXX stolen from radeon_reg.h */
47
 
#define RADEON_CP_PACKET0 0x0
48
 
 
49
 
#define CP_PACKET0(register, count) \
50
 
    (RADEON_CP_PACKET0 | ((count) << 16) | ((register) >> 2))
 
38
#ifdef DEBUG
 
39
#define CS_DEBUG(x) x
 
40
#else
 
41
#define CS_DEBUG(x)
 
42
#endif
 
43
 
 
44
/**
 
45
 * Command submission setup.
 
46
 */
51
47
 
52
48
#define CS_LOCALS(context) \
53
 
    struct r300_context* const cs_context_copy = (context); \
54
 
    struct radeon_winsys* cs_winsys = cs_context_copy->winsys; \
55
 
    int cs_count = 0; (void) cs_count;
56
 
 
57
 
#define CHECK_CS(size) \
58
 
    assert(cs_winsys->check_cs(cs_winsys, (size)))
 
49
    struct r300_winsys_cs *cs_copy = (context)->cs; \
 
50
    struct r300_winsys_screen *cs_winsys = (context)->rws; \
 
51
    int cs_count = 0; (void) cs_count; (void) cs_winsys;
59
52
 
60
53
#define BEGIN_CS(size) do { \
61
 
    CHECK_CS(size); \
62
 
    if (VERY_VERBOSE_CS) { \
63
 
        DBG(cs_context_copy, DBG_CS, "r300: BEGIN_CS, count %d, in %s (%s:%d)\n", \
64
 
                size, __FUNCTION__, __FILE__, __LINE__); \
65
 
    } \
66
 
    cs_winsys->begin_cs(cs_winsys, (size), \
67
 
            __FILE__, __FUNCTION__, __LINE__); \
68
 
    cs_count = size; \
69
 
} while (0)
 
54
    assert(size <= (cs_copy->ndw - cs_copy->cdw)); \
 
55
    CS_DEBUG(cs_count = size;) \
 
56
} while (0)
 
57
 
 
58
#ifdef DEBUG
 
59
#define END_CS do { \
 
60
    if (cs_count != 0) \
 
61
        debug_printf("r300: Warning: cs_count off by %d at (%s, %s:%i)\n", \
 
62
                     cs_count, __FUNCTION__, __FILE__, __LINE__); \
 
63
    cs_count = 0; \
 
64
} while (0)
 
65
#else
 
66
#define END_CS
 
67
#endif
 
68
 
 
69
 
 
70
/**
 
71
 * Writing pure DWORDs.
 
72
 */
70
73
 
71
74
#define OUT_CS(value) do { \
72
 
    if (VERY_VERBOSE_CS || VERY_VERBOSE_REGISTERS) { \
73
 
        DBG(cs_context_copy, DBG_CS, "r300: writing %08x\n", value); \
74
 
    } \
75
 
    cs_winsys->write_cs_dword(cs_winsys, (value)); \
76
 
    cs_count--; \
 
75
    cs_copy->ptr[cs_copy->cdw++] = (value); \
 
76
    CS_DEBUG(cs_count--;) \
77
77
} while (0)
78
78
 
79
 
#define OUT_CS_32F(value) do { \
80
 
    if (VERY_VERBOSE_CS || VERY_VERBOSE_REGISTERS) { \
81
 
        DBG(cs_context_copy, DBG_CS, "r300: writing %f\n", value); \
82
 
    } \
83
 
    cs_winsys->write_cs_dword(cs_winsys, fui(value)); \
84
 
    cs_count--; \
85
 
} while (0)
 
79
#define OUT_CS_32F(value) \
 
80
    OUT_CS(fui(value))
86
81
 
87
82
#define OUT_CS_REG(register, value) do { \
88
 
    if (VERY_VERBOSE_REGISTERS) \
89
 
        DBG(cs_context_copy, DBG_CS, "r300: writing 0x%08X to register 0x%04X\n", \
90
 
            value, register); \
91
 
    assert(register); \
92
 
    cs_winsys->write_cs_dword(cs_winsys, CP_PACKET0(register, 0)); \
93
 
    cs_winsys->write_cs_dword(cs_winsys, value); \
94
 
    cs_count -= 2; \
 
83
    OUT_CS(CP_PACKET0(register, 0)); \
 
84
    OUT_CS(value); \
95
85
} while (0)
96
86
 
97
87
/* Note: This expects count to be the number of registers,
98
88
 * not the actual packet0 count! */
99
 
#define OUT_CS_REG_SEQ(register, count) do { \
100
 
    if (VERY_VERBOSE_REGISTERS) \
101
 
        DBG(cs_context_copy, DBG_CS, "r300: writing register sequence of %d to 0x%04X\n", \
102
 
            count, register); \
103
 
    assert(register); \
104
 
    cs_winsys->write_cs_dword(cs_winsys, CP_PACKET0((register), ((count) - 1))); \
105
 
    cs_count--; \
106
 
} while (0)
107
 
 
108
 
#define OUT_CS_RELOC(bo, offset, rd, wd, flags) do { \
109
 
    DBG(cs_context_copy, DBG_CS, "r300: writing relocation for buffer %p, offset %d, " \
110
 
            "domains (%d, %d, %d)\n", \
111
 
        bo, offset, rd, wd, flags); \
112
 
    assert(bo); \
113
 
    cs_winsys->write_cs_dword(cs_winsys, offset); \
114
 
    cs_winsys->write_cs_reloc(cs_winsys, bo, rd, wd, flags); \
115
 
    cs_count -= 3; \
116
 
} while (0)
117
 
 
118
 
#define OUT_CS_RELOC_NO_OFFSET(bo, rd, wd, flags) do { \
119
 
    DBG(cs_context_copy, DBG_CS, "r300: writing relocation for buffer %p, " \
120
 
            "domains (%d, %d, %d)\n", \
121
 
        bo, rd, wd, flags); \
122
 
    assert(bo); \
123
 
    cs_winsys->write_cs_reloc(cs_winsys, bo, rd, wd, flags); \
124
 
    cs_count -= 2; \
125
 
} while (0)
126
 
 
127
 
#define END_CS do { \
128
 
    if (VERY_VERBOSE_CS) { \
129
 
        DBG(cs_context_copy, DBG_CS, "r300: END_CS in %s (%s:%d)\n", __FUNCTION__, \
130
 
                __FILE__, __LINE__); \
131
 
    } \
132
 
    if (cs_count != 0) \
133
 
        debug_printf("r300: Warning: cs_count off by %d\n", cs_count); \
134
 
    cs_winsys->end_cs(cs_winsys, __FILE__, __FUNCTION__, __LINE__); \
135
 
} while (0)
136
 
 
137
 
#define FLUSH_CS do { \
138
 
    if (VERY_VERBOSE_CS) { \
139
 
        DBG(cs_context_copy, DBG_CS, "r300: FLUSH_CS in %s (%s:%d)\n\n", __FUNCTION__, \
140
 
                __FILE__, __LINE__); \
141
 
    } \
142
 
    cs_winsys->flush_cs(cs_winsys); \
143
 
} while (0)
144
 
 
145
 
#define RADEON_ONE_REG_WR        (1 << 15)
146
 
 
147
 
#define OUT_CS_ONE_REG(register, count) do { \
148
 
    if (VERY_VERBOSE_REGISTERS) \
149
 
        DBG(cs_context_copy, DBG_CS, "r300: writing data sequence of %d to 0x%04X\n", \
150
 
            count, register); \
151
 
    assert(register); \
152
 
    cs_winsys->write_cs_dword(cs_winsys, CP_PACKET0((register), ((count) - 1)) | RADEON_ONE_REG_WR); \
153
 
    cs_count--; \
154
 
} while (0)
155
 
 
156
 
#define CP_PACKET3(op, count) \
157
 
    (RADEON_CP_PACKET3 | (op) | ((count) << 16))
158
 
 
159
 
#define OUT_CS_PKT3(op, count) do { \
160
 
    cs_winsys->write_cs_dword(cs_winsys, CP_PACKET3(op, count)); \
161
 
    cs_count--; \
162
 
} while (0)
163
 
 
164
 
#define OUT_CS_INDEX_RELOC(bo, offset, count, rd, wd, flags) do { \
165
 
    DBG(cs_context_copy, DBG_CS, "r300: writing relocation for index buffer %p," \
166
 
            "offset %d\n", bo, offset); \
167
 
    assert(bo); \
168
 
    cs_winsys->write_cs_dword(cs_winsys, offset); \
169
 
    cs_winsys->write_cs_dword(cs_winsys, count); \
170
 
    cs_winsys->write_cs_reloc(cs_winsys, bo, rd, wd, flags); \
171
 
    cs_count -= 4; \
 
89
#define OUT_CS_REG_SEQ(register, count) \
 
90
    OUT_CS(CP_PACKET0((register), ((count) - 1)))
 
91
 
 
92
#define OUT_CS_ONE_REG(register, count) \
 
93
    OUT_CS(CP_PACKET0((register), ((count) - 1)) | RADEON_ONE_REG_WR)
 
94
 
 
95
#define OUT_CS_PKT3(op, count) \
 
96
    OUT_CS(CP_PACKET3(op, count))
 
97
 
 
98
#define OUT_CS_TABLE(values, count) do { \
 
99
    memcpy(cs_copy->ptr + cs_copy->cdw, values, count * 4); \
 
100
    cs_copy->cdw += count; \
 
101
    CS_DEBUG(cs_count -= count;) \
 
102
} while (0)
 
103
 
 
104
 
 
105
/**
 
106
 * Writing relocations.
 
107
 */
 
108
 
 
109
#define OUT_CS_RELOC(bo, offset, rd, wd) do { \
 
110
    assert(bo); \
 
111
    OUT_CS(offset); \
 
112
    cs_winsys->cs_write_reloc(cs_copy, bo, rd, wd); \
 
113
    CS_DEBUG(cs_count -= 2;) \
 
114
} while (0)
 
115
 
 
116
#define OUT_CS_BUF_RELOC(bo, offset, rd, wd) do { \
 
117
    assert(bo); \
 
118
    OUT_CS_RELOC(r300_buffer(bo)->buf, offset, rd, wd); \
 
119
} while (0)
 
120
 
 
121
#define OUT_CS_TEX_RELOC(tex, offset, rd, wd) do { \
 
122
    assert(tex); \
 
123
    OUT_CS_RELOC(tex->buffer, offset, rd, wd); \
 
124
} while (0)
 
125
 
 
126
#define OUT_CS_BUF_RELOC_NO_OFFSET(bo, rd, wd) do { \
 
127
    assert(bo); \
 
128
    cs_winsys->cs_write_reloc(cs_copy, r300_buffer(bo)->buf, rd, wd); \
 
129
    CS_DEBUG(cs_count -= 2;) \
 
130
} while (0)
 
131
 
 
132
 
 
133
/**
 
134
 * Command buffer emission.
 
135
 */
 
136
 
 
137
#define WRITE_CS_TABLE(values, count) do { \
 
138
    CS_DEBUG(assert(cs_count == 0);) \
 
139
    memcpy(cs_copy->ptr + cs_copy->cdw, (values), (count) * 4); \
 
140
    cs_copy->cdw += (count); \
172
141
} while (0)
173
142
 
174
143
#endif /* R300_CS_H */