1 /*
2 (c) Copyright 2001-2009 The world wide DirectFB Open Source Community (directfb.org)
3 (c) Copyright 2000-2004 Convergence (integrated media) GmbH
4
5 All rights reserved.
6
7 Written by Denis Oliver Kropp <dok@directfb.org>,
8 Andreas Hundt <andi@fischlustig.de>,
9 Sven Neumann <neo@directfb.org>,
10 Ville Syrjälä <syrjala@sci.fi> and
11 Claudio Ciccani <klan@users.sf.net>.
12
13 This library is free software; you can redistribute it and/or
14 modify it under the terms of the GNU Lesser General Public
15 License as published by the Free Software Foundation; either
16 version 2 of the License, or (at your option) any later version.
17
18 This library is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 Lesser General Public License for more details.
22
23 You should have received a copy of the GNU Lesser General Public
24 License along with this library; if not, write to the
25 Free Software Foundation, Inc., 59 Temple Place - Suite 330,
26 Boston, MA 02111-1307, USA.
27 */
28
29 #include <config.h>
30
31 #include <directfb.h>
32
33 #include <direct/messages.h>
34
35 #include <core/coredefs.h>
36 #include <core/coretypes.h>
37
38 #include <core/state.h>
39 #include <core/gfxcard.h>
40 #include <core/surface.h>
41
42 #include <gfx/convert.h>
43
44 #include "regs.h"
45 #include "mmio.h"
46 #include "ati128.h"
47
48 #include "ati128_state.h"
49
50
51 static u32 ati128SourceBlend[] = {
52 SCALE_3D_CNTL_ALPHA_BLEND_SRC_ZERO, /* DSBF_ZERO */
53 SCALE_3D_CNTL_ALPHA_BLEND_SRC_ONE, /* DSBF_ONE */
54 SCALE_3D_CNTL_ALPHA_BLEND_SRC_SRCCOLOR, /* DSBF_SRCCOLOR */
55 SCALE_3D_CNTL_ALPHA_BLEND_SRC_INVSRCCOLOR, /* DSBF_INVSRCCOLOR */
56 SCALE_3D_CNTL_ALPHA_BLEND_SRC_SRCALPHA, /* DSBF_SRCALPHA */
57 SCALE_3D_CNTL_ALPHA_BLEND_SRC_INVSRCALPHA, /* DSBF_INVSRCALPHA */
58 SCALE_3D_CNTL_ALPHA_BLEND_SRC_DSTALPHA, /* DSBF_DESTALPHA */
59 SCALE_3D_CNTL_ALPHA_BLEND_SRC_INVDSTALPHA, /* DSBF_INVDESTALPHA */
60 SCALE_3D_CNTL_ALPHA_BLEND_SRC_DSTCOLOR, /* DSBF_DESTCOLOR */
61 SCALE_3D_CNTL_ALPHA_BLEND_SRC_INVDSTCOLOR, /* DSBF_INVDESTCOLOR */
62 SCALE_3D_CNTL_ALPHA_BLEND_SRC_SAT /* DSBF_SRCALPHASAT */
63 };
64
65 static u32 ati128DestBlend[] = {
66 SCALE_3D_CNTL_ALPHA_BLEND_DST_ZERO, /* DSBF_ZERO */
67 SCALE_3D_CNTL_ALPHA_BLEND_DST_ONE, /* DSBF_ONE */
68 SCALE_3D_CNTL_ALPHA_BLEND_DST_SRCCOLOR, /* DSBF_SRCCOLOR */
69 SCALE_3D_CNTL_ALPHA_BLEND_DST_INVSRCCOLOR, /* DSBF_INVSRCCOLOR */
70 SCALE_3D_CNTL_ALPHA_BLEND_DST_SRCALPHA, /* DSBF_SRCALPHA */
71 SCALE_3D_CNTL_ALPHA_BLEND_DST_INVSRCALPHA, /* DSBF_INVSRCALPHA */
72 SCALE_3D_CNTL_ALPHA_BLEND_DST_DSTALPHA, /* DSBF_DESTALPHA */
73 SCALE_3D_CNTL_ALPHA_BLEND_DST_INVDSTALPHA, /* DSBF_INVDESTALPHA */
74 SCALE_3D_CNTL_ALPHA_BLEND_DST_DSTCOLOR, /* DSBF_DESTCOLOR */
75 SCALE_3D_CNTL_ALPHA_BLEND_DST_INVDSTCOLOR, /* DSBF_INVDESTCOLOR */
76 0 /* DSBF_SRCALPHASAT */
77 };
78
ati128_set_destination(ATI128DriverData * adrv,ATI128DeviceData * adev,CardState * state)79 void ati128_set_destination( ATI128DriverData *adrv,
80 ATI128DeviceData *adev,
81 CardState *state )
82 {
83 CoreSurface *destination = state->destination;
84
85 if (adev->v_destination)
86 return;
87
88 ati128_waitfifo( adrv, adev, 1 );
89
90 switch (destination->config.format) {
91 case DSPF_RGB332:
92 ati128_out32( adrv->mmio_base, DST_PITCH_OFFSET,
93 ((state->dst.pitch >> 3) << 21) |
94 (state->dst.offset >> 5));
95
96 adev->ATI_dst_bpp = DST_8BPP_RGB332;
97 break;
98 case DSPF_ARGB1555:
99 ati128_out32( adrv->mmio_base, DST_PITCH_OFFSET,
100 ((state->dst.pitch >> 4) << 21) |
101 (state->dst.offset >> 5));
102
103 adev->ATI_dst_bpp = DST_15BPP;
104 break;
105 case DSPF_RGB16:
106 ati128_out32( adrv->mmio_base, DST_PITCH_OFFSET,
107 ((state->dst.pitch >> 4) << 21) |
108 (state->dst.offset >> 5));
109
110 adev->ATI_dst_bpp = DST_16BPP;
111 break;
112 case DSPF_RGB24:
113 ati128_out32( adrv->mmio_base, DST_PITCH_OFFSET,
114 ((state->dst.pitch >> 3) << 21) |
115 (state->dst.offset >> 5));
116
117 adev->ATI_dst_bpp = DST_24BPP;
118 break;
119 case DSPF_RGB32:
120 case DSPF_ARGB:
121 ati128_out32( adrv->mmio_base, DST_PITCH_OFFSET,
122 ((state->dst.pitch >> 5) << 21) |
123 (state->dst.offset >> 5));
124
125 adev->ATI_dst_bpp = DST_32BPP;
126 break;
127 default:
128 D_BUG( "unexpected pixelformat!" );
129 break;
130 }
131 adev->destination = destination;
132
133 adev->v_destination = 1;
134 }
135
ati128_set_source(ATI128DriverData * adrv,ATI128DeviceData * adev,CardState * state)136 void ati128_set_source( ATI128DriverData *adrv,
137 ATI128DeviceData *adev,
138 CardState *state )
139 {
140
141 if (adev->v_source)
142 return;
143
144 ati128_waitfifo( adrv, adev, 3 );
145
146 switch (state->source->config.format) {
147 case DSPF_RGB332:
148 ati128_out32( adrv->mmio_base, SRC_PITCH,
149 state->src.pitch >> 3);
150
151 ati128_out32( adrv->mmio_base, CLR_CMP_MASK, 0x000000FF );
152 break;
153 case DSPF_ARGB1555:
154 ati128_out32( adrv->mmio_base, SRC_PITCH,
155 state->src.pitch >> 4);
156
157 ati128_out32( adrv->mmio_base, CLR_CMP_MASK, 0x00007FFF );
158 break;
159 case DSPF_RGB16:
160 ati128_out32( adrv->mmio_base, SRC_PITCH,
161 state->src.pitch >> 4);
162
163 ati128_out32( adrv->mmio_base, CLR_CMP_MASK, 0x0000FFFF );
164 break;
165 case DSPF_RGB24:
166 ati128_out32( adrv->mmio_base, SRC_PITCH,
167 state->src.pitch >> 3);
168
169 ati128_out32( adrv->mmio_base, CLR_CMP_MASK, 0x00FFFFFF );
170 break;
171 case DSPF_RGB32:
172 case DSPF_ARGB:
173 ati128_out32( adrv->mmio_base, SRC_PITCH,
174 state->src.pitch >> 5);
175
176 ati128_out32( adrv->mmio_base, CLR_CMP_MASK, 0x00FFFFFF );
177 break;
178 default:
179 D_BUG( "unexpected pixelformat!" );
180 break;
181 }
182
183 ati128_out32( adrv->mmio_base, SRC_OFFSET,
184 state->src.offset );
185
186 adev->source = state->source;
187 adev->src = &state->src;
188 adev->v_source = 1;
189 }
190
ati128_set_clip(ATI128DriverData * adrv,ATI128DeviceData * adev,CardState * state)191 void ati128_set_clip( ATI128DriverData *adrv,
192 ATI128DeviceData *adev,
193 CardState *state )
194 {
195
196 ati128_waitfifo( adrv, adev, 2 );
197
198 /* 24bpp needs special treatment */
199 if (state->destination->config.format == DSPF_RGB24) {
200 ati128_out32( adrv->mmio_base, SC_TOP_LEFT,
201 (state->clip.y1 << 16) | (state->clip.x1*3) );
202
203 ati128_out32( adrv->mmio_base, SC_BOTTOM_RIGHT,
204 (state->clip.y2 << 16) | ((state->clip.x2*3) + 3));
205 }
206 else {
207 ati128_out32( adrv->mmio_base, SC_TOP_LEFT,
208 (state->clip.y1 << 16) | state->clip.x1 );
209
210 ati128_out32( adrv->mmio_base, SC_BOTTOM_RIGHT,
211 (state->clip.y2 << 16) | state->clip.x2 );
212 }
213 }
214
ati128_set_color(ATI128DriverData * adrv,ATI128DeviceData * adev,CardState * state)215 void ati128_set_color( ATI128DriverData *adrv,
216 ATI128DeviceData *adev,
217 CardState *state )
218 {
219 u32 fill_color = 0;
220
221 if (adev->v_color)
222 return;
223
224 switch (state->destination->config.format) {
225 case DSPF_RGB332:
226 fill_color = PIXEL_RGB332( state->color.r,
227 state->color.g,
228 state->color.b );
229 break;
230 case DSPF_ARGB1555:
231 fill_color = PIXEL_ARGB1555( state->color.a,
232 state->color.r,
233 state->color.g,
234 state->color.b );
235 break;
236 case DSPF_RGB16:
237 fill_color = PIXEL_RGB16( state->color.r,
238 state->color.g,
239 state->color.b );
240 break;
241 case DSPF_RGB24:
242 case DSPF_RGB32:
243 fill_color = PIXEL_RGB32( state->color.r,
244 state->color.g,
245 state->color.b );
246 break;
247 case DSPF_ARGB:
248 fill_color = PIXEL_ARGB( state->color.a,
249 state->color.r,
250 state->color.g,
251 state->color.b );
252 break;
253 default:
254 D_BUG( "unexpected pixelformat!" );
255 break;
256 }
257
258 ati128_waitfifo( adrv, adev, 1 );
259 ati128_out32( adrv->mmio_base, DP_BRUSH_FRGD_CLR, fill_color);
260
261
262 adev->fake_texture_color = PIXEL_ARGB( state->color.a,
263 state->color.r,
264 state->color.g,
265 state->color.b );
266
267 adev->v_color = 1;
268 }
269
ati128_set_src_colorkey(ATI128DriverData * adrv,ATI128DeviceData * adev,CardState * state)270 void ati128_set_src_colorkey( ATI128DriverData *adrv,
271 ATI128DeviceData *adev,
272 CardState *state )
273 {
274 if (adev->v_src_colorkey)
275 return;
276
277 ati128_waitfifo( adrv, adev, 1 );
278 ati128_out32( adrv->mmio_base, CLR_CMP_CLR_SRC, state->src_colorkey );
279
280 adev->v_src_colorkey = 1;
281 }
282
ati128_set_blittingflags(ATI128DriverData * adrv,ATI128DeviceData * adev,CardState * state)283 void ati128_set_blittingflags( ATI128DriverData *adrv,
284 ATI128DeviceData *adev,
285 CardState *state )
286 {
287 if (adev->v_blittingflags)
288 return;
289
290 if (state->blittingflags & DSBLIT_SRC_COLORKEY) {
291 adev->ATI_color_compare = (1 << 24) | 5;
292 }
293 else {
294 adev->ATI_color_compare = 0;
295 }
296
297 adev->blittingflags = state->blittingflags;
298 adev->v_blittingflags = 1;
299 }
300
ati128_set_blending_function(ATI128DriverData * adrv,ATI128DeviceData * adev,CardState * state)301 void ati128_set_blending_function( ATI128DriverData *adrv,
302 ATI128DeviceData *adev,
303 CardState *state )
304 {
305 if (adev->v_blending_function)
306 return;
307
308 adev->ATI_blend_function = SCALE_3D_CNTL_SCALE_3D_FN_SCALE |
309 ati128SourceBlend[state->src_blend - 1] |
310 ati128DestBlend [state->dst_blend - 1] |
311 SCALE_3D_CNTL_TEX_MAP_AEN_ON;
312
313 adev->v_blending_function = 1;
314 }
315