r300_screen.c revision e1b04da9b35aad1f474f7396f206a7c124c6859b 
1/*
2 * Copyright 2008 Corbin Simpson <MostAwesomeDude@gmail.com>
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * on the rights to use, copy, modify, merge, publish, distribute, sub
8 * license, and/or sell copies of the Software, and to permit persons to whom
9 * the Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
19 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
20 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
21 * USE OR OTHER DEALINGS IN THE SOFTWARE. */
22
23#include "r300_screen.h"
24
25/* Return the identifier behind whom the brave coders responsible for this
26 * amalgamation of code, sweat, and duct tape, routinely obscure their names.
27 *
28 * ...I should have just put "Corbin Simpson", but I'm not that cool.
29 *
30 * (Or egotistical. Yet.) */
31static const char* r300_get_vendor(struct pipe_screen* pscreen)
32{
33    return "X.Org R300 Project";
34}
35
36static const char* chip_families[] = {
37    "R300",
38    "R350",
39    "R360",
40    "RV350",
41    "RV370",
42    "RV380",
43    "R420",
44    "R423",
45    "R430",
46    "R480",
47    "R481",
48    "RV410",
49    "RS400",
50    "RC410",
51    "RS480",
52    "RS482",
53    "RS690",
54    "RS740",
55    "RV515",
56    "R520",
57    "RV530",
58    "R580",
59    "RV560",
60    "RV570"
61};
62
63static const char* r300_get_name(struct pipe_screen* pscreen)
64{
65    struct r300_screen* r300screen = r300_screen(pscreen);
66
67    return chip_families[r300screen->caps->family];
68}
69
70static int r300_get_param(struct pipe_screen* pscreen, int param)
71{
72    struct r300_screen* r300screen = r300_screen(pscreen);
73
74    switch (param) {
75        /* XXX cases marked "IN THEORY" are possible on the hardware,
76         * but haven't been implemented yet. */
77        case PIPE_CAP_MAX_TEXTURE_IMAGE_UNITS:
78            /* XXX I'm told this goes up to 16 */
79            return 8;
80        case PIPE_CAP_NPOT_TEXTURES:
81            /* IN THEORY */
82            return 0;
83        case PIPE_CAP_TWO_SIDED_STENCIL:
84            if (r300screen->caps->is_r500) {
85                return 1;
86            } else {
87                return 0;
88            }
89            return 0;
90        case PIPE_CAP_GLSL:
91            /* IN THEORY */
92            return 0;
93        case PIPE_CAP_S3TC:
94            /* IN THEORY */
95            return 0;
96        case PIPE_CAP_ANISOTROPIC_FILTER:
97            /* IN THEORY */
98            return 0;
99        case PIPE_CAP_POINT_SPRITE:
100            /* IN THEORY */
101            return 0;
102        case PIPE_CAP_MAX_RENDER_TARGETS:
103            /* XXX 4 eventually */
104            return 1;
105        case PIPE_CAP_OCCLUSION_QUERY:
106            /* IN THEORY */
107            return 0;
108        case PIPE_CAP_TEXTURE_SHADOW_MAP:
109            /* IN THEORY */
110            return 0;
111        case PIPE_CAP_MAX_TEXTURE_2D_LEVELS:
112            if (r300screen->caps->is_r500) {
113                /* 13 == 4096x4096 */
114                return 13;
115            } else {
116                /* 12 == 2048x2048 */
117                return 12;
118            }
119        case PIPE_CAP_MAX_TEXTURE_3D_LEVELS:
120            /* So, technically, the limit is the same as above, but some math
121             * shows why this is silly. Assuming RGBA, 4cpp, we can see that
122             * 4096*4096*4096 = 64.0 GiB exactly, so it's not exactly
123             * practical. However, if at some point a game really wants this,
124             * then we can remove this limit. */
125            if (r300screen->caps->is_r500) {
126                /* 9 == 256x256x256 */
127                return 9;
128            } else {
129                /* 8 == 128*128*128 */
130                return 8;
131            }
132        case PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS:
133            if (r300screen->caps->is_r500) {
134                /* 13 == 4096x4096 */
135                return 13;
136            } else {
137                /* 12 == 2048x2048 */
138                return 12;
139            }
140        case PIPE_CAP_TEXTURE_MIRROR_CLAMP:
141            return 1;
142        case PIPE_CAP_TEXTURE_MIRROR_REPEAT:
143            return 1;
144        case PIPE_CAP_MAX_VERTEX_TEXTURE_UNITS:
145            /* XXX guessing */
146            return 2;
147        default:
148            debug_printf("r300: Implementation error: Bad param %d\n",
149                param);
150            return 0;
151    }
152}
153
154static float r300_get_paramf(struct pipe_screen* pscreen, int param)
155{
156    switch (param) {
157        case PIPE_CAP_MAX_LINE_WIDTH:
158        case PIPE_CAP_MAX_LINE_WIDTH_AA:
159            /* XXX this is the biggest thing that will fit in that register.
160            * Perhaps the actual rendering limits are less? */
161            return 10922.0f;
162        case PIPE_CAP_MAX_POINT_WIDTH:
163        case PIPE_CAP_MAX_POINT_WIDTH_AA:
164            /* XXX this is the biggest thing that will fit in that register.
165             * Perhaps the actual rendering limits are less? */
166            return 10922.0f;
167        case PIPE_CAP_MAX_TEXTURE_ANISOTROPY:
168            return 16.0f;
169        case PIPE_CAP_MAX_TEXTURE_LOD_BIAS:
170            return 16.0f;
171        default:
172            debug_printf("r300: Implementation error: Bad paramf %d\n",
173                param);
174            return 0.0f;
175    }
176}
177
178/* XXX moar formats */
179static boolean check_tex_2d_format(enum pipe_format format)
180{
181    switch (format) {
182        case PIPE_FORMAT_A8R8G8B8_UNORM:
183        case PIPE_FORMAT_I8_UNORM:
184            return TRUE;
185        default:
186            debug_printf("r300: Warning: Got unknown format: %s, in %s\n",
187                pf_name(format), __FUNCTION__);
188            break;
189    }
190
191    return FALSE;
192}
193
194/* XXX moar targets */
195static boolean r300_is_format_supported(struct pipe_screen* pscreen,
196                                        enum pipe_format format,
197                                        enum pipe_texture_target target,
198                                        unsigned tex_usage,
199                                        unsigned geom_flags)
200{
201    switch (target) {
202        case PIPE_TEXTURE_2D:
203            return check_tex_2d_format(format);
204        default:
205            debug_printf("r300: Warning: Got unknown format target: %d\n",
206                format);
207            break;
208    }
209
210    return FALSE;
211}
212
213static void* r300_surface_map(struct pipe_screen* screen,
214                              struct pipe_surface* surface,
215                              unsigned flags)
216{
217    char* map = pipe_buffer_map(screen, surface->buffer, flags);
218
219    if (!map) {
220        return NULL;
221    }
222
223    return map + surface->offset;
224}
225
226static void r300_surface_unmap(struct pipe_screen* screen,
227                               struct pipe_surface* surface)
228{
229    pipe_buffer_unmap(screen, surface->buffer);
230}
231
232static void r300_destroy_screen(struct pipe_screen* pscreen)
233{
234    struct r300_screen* r300screen = r300_screen(pscreen);
235
236    FREE(r300screen->caps);
237    FREE(r300screen);
238}
239
240struct pipe_screen* r300_create_screen(struct pipe_winsys* winsys,
241                                       struct r300_winsys* r300_winsys)
242{
243    struct r300_screen* r300screen = CALLOC_STRUCT(r300_screen);
244    struct r300_capabilities* caps = CALLOC_STRUCT(r300_capabilities);
245
246    if (!r300screen || !caps)
247        return NULL;
248
249    caps->pci_id = r300_winsys->pci_id;
250    caps->num_frag_pipes = r300_winsys->gb_pipes;
251
252    r300_parse_chipset(caps);
253
254    r300screen->caps = caps;
255    r300screen->screen.winsys = winsys;
256    r300screen->screen.destroy = r300_destroy_screen;
257    r300screen->screen.get_name = r300_get_name;
258    r300screen->screen.get_vendor = r300_get_vendor;
259    r300screen->screen.get_param = r300_get_param;
260    r300screen->screen.get_paramf = r300_get_paramf;
261    r300screen->screen.is_format_supported = r300_is_format_supported;
262    r300screen->screen.surface_map = r300_surface_map;
263    r300screen->screen.surface_unmap = r300_surface_unmap;
264
265    r300_init_screen_texture_functions(&r300screen->screen);
266    u_simple_screen_init(&r300screen->screen);
267
268    return &r300screen->screen;
269}
270