Rev 868 | Go to most recent revision | Only display areas with differences | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed
| Rev 868 | Rev 876 | ||
|---|---|---|---|
| 1 | #define BRUSH_MONO (0<<4) |
- | |
| 2 | - | ||
| 3 | 1 | int DrawRect(draw_t* draw) |
|
| 4 | int DrawRect(draw_t* draw) |
2 | { |
| 5 | { |
3 | int x0, y0, x1, y1; |
| 6 | int x0, y0, x1, y1; |
4 | |
| 7 | 5 | local_pixmap_t *dstpixmap; |
|
| 8 | pixmap_t *dstpixmap; |
6 | clip_t dst_clip; |
| - | 7 | ||
| 9 | 8 | dstpixmap = (draw->dstpix == (void*)-1) ? &scr_pixmap : draw->dstpix ; |
|
| 10 | dstpixmap = (draw->dstpix == (void*)-1) ? &scr_pixmap : draw->dstpix ; |
9 | |
| 11 | 10 | x0 = draw->x0; |
|
| 12 | x0 = draw->x; |
11 | y0 = draw->y0; |
| 13 | y0 = draw->y; |
12 | |
| 14 | 13 | x1 = x0+draw->w-1; |
|
| 15 | x1 = x0+draw->w-1; |
14 | y1 = y0+draw->h-1; |
| 16 | y1 = y0+draw->h-1; |
15 | |
| 17 | 16 | dst_clip.xmin = 0; |
|
| - | 17 | dst_clip.ymin = 0; |
|
| - | 18 | dst_clip.xmax = dstpixmap->width-1; |
|
| - | 19 | dst_clip.ymax = dstpixmap->height-1; |
|
| - | 20 | ||
| - | 21 | ||
| - | 22 | // dbgprintf("draw rect x0:%d, y0:%d, x1:%d, y1:%d, color: %x\n", |
|
| 18 | // dbgprintf("draw rect x0:%d, y0:%d, x1:%d, y1:%d, color: %x\n", |
23 | // x0, y0, x1, y1, draw->color); |
| 19 | // x0, y0, x1, y1, draw->color); |
24 | |
| 20 | 25 | if( ! BlockClip( &dst_clip, &x0, &y0, &x1, &y1)) |
|
| 21 | if( ! BlockClip( &x0, &y0, &x1, &y1)) |
26 | { |
| 22 | { |
27 | u32_t *ring, write; |
| 23 | u32 *ring, write; |
28 | u32_t ifl; |
| - | 29 | int w, h; |
|
| 24 | int w, h; |
30 | |
| 25 | u32 ifl; |
- | |
| 26 | 31 | w = x1-x0+1; |
|
| 27 | w = x1-x0+1; |
32 | h = y1-y0+1; |
| 28 | h = y1-y0+1; |
33 | |
| 29 | 34 | ifl = safe_cli(); |
|
| 30 | ifl = safe_cli(); |
35 | |
| 31 | 36 | #if R300_PIO |
|
| 32 | - | ||
| 33 | #if R300_PIO |
37 | |
| 34 | 38 | R5xxFIFOWait(6); |
|
| 35 | R5xxFIFOWait(7); |
39 | |
| - | 40 | OUTREG(R5XX_DP_GUI_MASTER_CNTL, |
|
| - | 41 | rhd.gui_control | |
|
| 36 | 42 | R5XX_ROP3_P | |
|
| 37 | OUTREG(R5XX_DP_GUI_MASTER_CNTL, rhd.gui_control | R5XX_ROP3_P | |
43 | R5XX_GMC_BRUSH_SOLID_COLOR | |
| - | 44 | R5XX_GMC_SRC_DATATYPE_COLOR | |
|
| - | 45 | R5XX_GMC_CLR_CMP_CNTL_DIS | |
|
| - | 46 | R5XX_GMC_WR_MSK_DIS |
|
| 38 | R5XX_GMC_BRUSH_SOLID_COLOR | |
47 | ); |
| 39 | R5XX_GMC_SRC_DATATYPE_COLOR); |
- | |
| 40 | 48 | ||
| 41 | OUTREG(R5XX_DP_BRUSH_FRGD_CLR, draw->color); |
49 | OUTREG(R5XX_DP_BRUSH_FRGD_CLR, draw->color); |
| 42 | OUTREG(R5XX_DP_WRITE_MASK, 0xFFFFFFFF); |
50 | OUTREG(R5XX_DP_CNTL, R5XX_DST_X_LEFT_TO_RIGHT | R5XX_DST_Y_TOP_TO_BOTTOM); |
| 43 | OUTREG(R5XX_DP_CNTL, R5XX_DST_X_LEFT_TO_RIGHT | R5XX_DST_Y_TOP_TO_BOTTOM); |
51 | OUTREG(R5XX_DST_PITCH_OFFSET, dstpixmap->pitch_offset); |
| 44 | OUTREG(R5XX_DST_PITCH_OFFSET, dstpixmap->pitch_offset); |
- | |
| 45 | OUTREG(R5XX_DST_Y_X,(y0<<16)|x0); |
52 | OUTREG(R5XX_DST_Y_X,(draw->y0<<16)|draw->x0); |
| 46 | OUTREG(R5XX_DST_WIDTH_HEIGHT,(w<<16)|h); |
- | |
| 47 | 53 | OUTREG(R5XX_DST_WIDTH_HEIGHT,(w<<16)|h); |
|
| 48 | #else |
54 | #else |
| 49 | 55 | BEGIN_RING(); |
|
| 50 | BEGIN_RING(); |
56 | OUT_RING(CP_PACKET3(RADEON_CNTL_PAINT_MULTI, 4)); |
| 51 | OUT_RING(CP_PACKET3(RADEON_CNTL_PAINT_MULTI, 4)); |
57 | |
| 52 | 58 | OUT_RING(RADEON_GMC_DST_PITCH_OFFSET_CNTL | |
|
| 53 | OUT_RING(RADEON_GMC_DST_PITCH_OFFSET_CNTL | |
59 | RADEON_GMC_BRUSH_SOLID_COLOR | |
| 54 | RADEON_GMC_BRUSH_SOLID_COLOR | |
60 | RADEON_GMC_DST_32BPP | |
| 55 | RADEON_GMC_DST_32BPP | |
61 | RADEON_GMC_SRC_DATATYPE_COLOR | |
| 56 | RADEON_GMC_SRC_DATATYPE_COLOR | |
62 | R5XX_GMC_CLR_CMP_CNTL_DIS | |
| 57 | (1 << 28)+(1 << 30) | R5XX_ROP3_P); |
63 | R5XX_GMC_WR_MSK_DIS | |
| - | 64 | R5XX_ROP3_P |
|
| - | 65 | ); |
|
| 58 | 66 | ||
| - | 67 | OUT_RING(dstpixmap->pitch_offset); |
|
| 59 | OUT_RING(dstpixmap->pitch_offset); |
68 | OUT_RING(draw->color); |
| 60 | OUT_RING(draw->color); |
69 | OUT_RING((draw->x0<<16)|y0); |
| 61 | OUT_RING((x0<<16)|y0); |
70 | OUT_RING((w<<16)|h); |
| 62 | OUT_RING((w<<16)|h); |
71 | COMMIT_RING(); |
| 63 | COMMIT_RING(); |
72 | #endif |
| 64 | 73 | safe_sti(ifl); |
|
| 65 | #endif |
- | |
| 66 | 74 | }; |
|
| 67 | safe_sti(ifl); |
- | |
| 68 | } ; |
75 | return ERR_OK; |
| 69 | return ERR_OK; |
76 | } |
| 70 | } |
77 | |
| 71 | 78 | int FillRect(fill_t *fill) |
|
| 72 | int FillRect(fill_t *fill) |
79 | { |
| 73 | { |
80 | local_pixmap_t *dstpixmap; |
| 74 | pixmap_t *dstpixmap; |
81 | clip_t dst_clip; |
| 75 | int x0, y0, x1, y1; |
82 | int x0, y0, x1, y1; |
| - | 83 | ||
| 76 | 84 | dstpixmap = (fill->dstpix == (void*)-1) ? &scr_pixmap : fill->dstpix ; |
|
| 77 | dstpixmap = (fill->dstpix == (void*)-1) ? &scr_pixmap : fill->dstpix ; |
85 | |
| 78 | 86 | x0 = fill->x; |
|
| 79 | x0 = fill->x; |
87 | y0 = fill->y; |
| 80 | y0 = fill->y; |
88 | |
| 81 | 89 | x1 = x0+fill->w-1; |
|
| 82 | x1 = x0+fill->w-1; |
90 | y1 = y0+fill->h-1; |
| 83 | y1 = y0+fill->h-1; |
91 | |
| 84 | 92 | dst_clip.xmin = 0; |
|
| - | 93 | dst_clip.ymin = 0; |
|
| - | 94 | dst_clip.xmax = dstpixmap->width-1; |
|
| - | 95 | dst_clip.ymax = dstpixmap->height-1; |
|
| - | 96 | ||
| - | 97 | // dbgprintf("fill rect x0:%d, y0:%d, x1:%d, y1:%d\n", |
|
| 85 | // dbgprintf("fill rect x0:%d, y0:%d, x1:%d, y1:%d\n", |
98 | // x0, y0, x1, y1); |
| 86 | // x0, y0, x1, y1); |
99 | |
| 87 | 100 | if( ! BlockClip(&dst_clip, &x0, &y0, &x1, &y1)) |
|
| 88 | if( ! BlockClip( &x0, &y0, &x1, &y1)) |
101 | { |
| 89 | { |
102 | u32_t *ring, write; |
| 90 | u32 *ring, write; |
103 | u32_t ifl = safe_cli(); |
| 91 | u32 ifl; |
- | |
| 92 | - | ||
| 93 | ifl = safe_cli(); |
104 | |
| 94 | 105 | #if R300_PIO |
|
| 95 | #if R300_PIO |
106 | |
| 96 | 107 | int w = x1-x0+1; |
|
| - | 108 | int h = y1-y0+1; |
|
| - | 109 | ||
| - | 110 | R5xxFIFOWait(9); |
|
| - | 111 | ||
| 97 | #else |
112 | OUTREG(R5XX_DP_GUI_MASTER_CNTL, |
| - | 113 | RADEON_GMC_DST_PITCH_OFFSET_CNTL | |
|
| - | 114 | R5XX_GMC_BRUSH_8X8_MONO_FG_BG | |
|
| - | 115 | RADEON_GMC_DST_32BPP | |
|
| - | 116 | R5XX_GMC_SRC_DATATYPE_COLOR | |
|
| - | 117 | R5XX_GMC_CLR_CMP_CNTL_DIS | |
|
| - | 118 | R5XX_GMC_WR_MSK_DIS | |
|
| - | 119 | R5XX_ROP3_P |
|
| - | 120 | ); |
|
| - | 121 | ||
| - | 122 | OUTREG(R5XX_DP_BRUSH_BKGD_CLR, fill->bkcolor); |
|
| - | 123 | OUTREG(R5XX_DP_BRUSH_FRGD_CLR, fill->fcolor); |
|
| - | 124 | ||
| - | 125 | OUTREG(R5XX_BRUSH_DATA0, fill->bmp0); |
|
| - | 126 | OUTREG(R5XX_BRUSH_DATA1, fill->bmp1); |
|
| - | 127 | ||
| - | 128 | OUTREG(R5XX_DP_CNTL, R5XX_DST_X_LEFT_TO_RIGHT | R5XX_DST_Y_TOP_TO_BOTTOM); |
|
| - | 129 | OUTREG(R5XX_DST_PITCH_OFFSET, dstpixmap->pitch_offset); |
|
| - | 130 | ||
| - | 131 | OUTREG(R5XX_DST_Y_X,(y0<<16)|x0); |
|
| - | 132 | OUTREG(R5XX_DST_HEIGHT_WIDTH,(h<<16)|w); |
|
| - | 133 | #else |
|
| 98 | 134 | BEGIN_RING(); |
|
| 99 | BEGIN_RING(); |
135 | OUT_RING(CP_PACKET3(RADEON_CNTL_PAINT, 7)); |
| 100 | OUT_RING(CP_PACKET3(RADEON_CNTL_PAINT, 7)); |
136 | OUT_RING(RADEON_GMC_DST_PITCH_OFFSET_CNTL | |
| 101 | OUT_RING(RADEON_GMC_DST_PITCH_OFFSET_CNTL | |
137 | R5XX_GMC_BRUSH_8X8_MONO_FG_BG | |
| 102 | BRUSH_MONO | |
138 | RADEON_GMC_DST_32BPP | |
| 103 | RADEON_GMC_DST_32BPP | |
139 | RADEON_GMC_SRC_DATATYPE_COLOR | |
| 104 | RADEON_GMC_SRC_DATATYPE_COLOR | |
140 | R5XX_GMC_CLR_CMP_CNTL_DIS | |
| 105 | (1 << 28)+(1 << 30) | R5XX_ROP3_P); |
141 | R5XX_GMC_WR_MSK_DIS | |
| - | 142 | R5XX_ROP3_P |
|
| - | 143 | ); |
|
| 106 | 144 | ||
| - | 145 | OUT_RING(dstpixmap->pitch_offset); |
|
| 107 | OUT_RING(dstpixmap->pitch_offset); |
146 | OUT_RING(fill->bkcolor); |
| 108 | OUT_RING(fill->bkcolor); |
147 | OUT_RING(fill->fcolor); |
| 109 | OUT_RING(fill->fcolor); |
148 | |
| 110 | 149 | OUT_RING(fill->bmp0); |
|
| 111 | OUT_RING(fill->bmp0); |
150 | OUT_RING(fill->bmp1); |
| 112 | OUT_RING(fill->bmp1); |
151 | |
| 113 | 152 | OUT_RING((y0<<16)|x0); |
|
| 114 | OUT_RING((y0<<16)|x0); |
153 | OUT_RING((y1<<16)|x1); |
| 115 | OUT_RING((y1<<16)|x1); |
154 | COMMIT_RING(); |
| 116 | COMMIT_RING(); |
155 | |
| 117 | 156 | #endif |
|
| 118 | #endif |
157 | safe_sti(ifl); |
| 119 | 158 | }; |
|
| 120 | safe_sti(ifl); |
- | |
| 121 | }; |
159 | return ERR_OK; |
| 122 | return ERR_OK; |
160 | }; |
| 123 | } |
161 | |
| 124 | 162 | #if 0 |
|
| - | 163 | int Blit(blit_t *blit) |
|
| 125 | int Blit(blit_t *blit) |
164 | { |
| 126 | { |
165 | int x0, y0, x1, y1; |
| 127 | int x0, y0, x1, y1; |
166 | |
| 128 | 167 | x0 = blit->src_x; |
|
| 129 | x0 = blit->src_x; |
168 | y0 = blit->src_y; |
| 130 | y0 = blit->src_y; |
169 | |
| 131 | 170 | x1 = x0+blit->w-1; |
|
| 132 | x1 = x0+blit->w-1; |
171 | y1 = y0+blit->h-1; |
| 133 | y1 = y0+blit->h-1; |
172 | |
| 134 | 173 | ||
| 135 | 174 | if( ! BlockClip(&clip, &x0, &y0, &x1, &y1)) |
|
| 136 | if( ! BlockClip( &x0, &y0, &x1, &y1)) |
175 | { |
| 137 | { |
176 | u32 *ring, write; |
| 138 | u32 *ring, write; |
177 | int w, h; |
| 139 | int w, h; |
178 | u32 ifl; |
| 140 | u32 ifl; |
179 | |
| 141 | 180 | w = x1-x0+1; |
|
| 142 | w = x1-x0+1; |
181 | h = y1-y0+1; |
| 143 | h = y1-y0+1; |
182 | |
| 144 | 183 | ifl = safe_cli(); |
|
| 145 | ifl = safe_cli(); |
184 | |
| 146 | 185 | #if R300_PIO |
|
| 147 | #if R300_PIO |
186 | |
| 148 | 187 | ||
| 149 | 188 | #else |
|
| 150 | #else |
189 | |
| 151 | 190 | BEGIN_RING(); |
|
| 152 | BEGIN_RING(); |
191 | OUT_RING(CP_PACKET3(RADEON_CNTL_BITBLT, 5)); |
| 153 | OUT_RING(CP_PACKET3(RADEON_CNTL_BITBLT, 5)); |
192 | |
| 154 | 193 | OUT_RING(RADEON_GMC_SRC_PITCH_OFFSET_CNTL | |
|
| 155 | OUT_RING(RADEON_GMC_SRC_PITCH_OFFSET_CNTL | |
194 | RADEON_GMC_DST_PITCH_OFFSET_CNTL | |
| 156 | RADEON_GMC_DST_PITCH_OFFSET_CNTL | |
195 | RADEON_GMC_BRUSH_NONE | |
| 157 | RADEON_GMC_BRUSH_NONE | |
196 | RADEON_GMC_DST_32BPP | |
| 158 | RADEON_GMC_DST_32BPP | |
197 | RADEON_GMC_SRC_DATATYPE_COLOR | |
| 159 | RADEON_GMC_SRC_DATATYPE_COLOR | |
198 | RADEON_DP_SRC_SOURCE_MEMORY | |
| 160 | RADEON_DP_SRC_SOURCE_MEMORY | |
199 | (1 << 28)+(1 << 30) | R5XX_ROP3_S); |
| 161 | (1 << 28)+(1 << 30) | R5XX_ROP3_S); |
200 | |
| 162 | 201 | OUT_RING(rhd.dst_pitch_offset); |
|
| 163 | OUT_RING(rhd.dst_pitch_offset); |
202 | OUT_RING(rhd.dst_pitch_offset); |
| 164 | OUT_RING(rhd.dst_pitch_offset); |
203 | |
| 165 | 204 | OUT_RING((x0<<16)|y0); |
|
| 166 | OUT_RING((x0<<16)|y0); |
205 | OUT_RING((blit->dst_x<<16)|blit->dst_y); |
| 167 | OUT_RING((blit->dst_x<<16)|blit->dst_y); |
206 | OUT_RING((w<<16)|h); |
| 168 | OUT_RING((w<<16)|h); |
207 | COMMIT_RING(); |
| 169 | COMMIT_RING(); |
208 | |
| 170 | 209 | #endif |
|
| 171 | #endif |
210 | |
| 172 | 211 | safe_sti(ifl); |
|
| 173 | safe_sti(ifl); |
212 | } ; |
| 174 | } ; |
213 | return ERR_OK; |
| 175 | return ERR_OK; |
214 | } |
| 176 | } |
215 | |
| 177 | 216 | int Line2P(draw_t *draw) |
|
| 178 | int Line2P(line2p_t *draw) |
217 | { |
| 179 | { |
218 | local_pixmap_t *dstpixmap; |
| 180 | - | ||
| - | 219 | int x0, y0, x1, y1; |
|
| 181 | int x0, y0, x1, y1; |
220 | |
| - | 221 | dstpixmap = (draw->dstpix == (void*)-1) ? &scr_pixmap : draw->dstpix ; |
|
| - | 222 | ||
| 182 | 223 | x0 = draw->x0; |
|
| 183 | x0 = draw->x0; |
224 | y0 = draw->y0; |
| 184 | y0 = draw->y0; |
225 | |
| 185 | 226 | x1 = draw->x1; |
|
| 186 | x1 = draw->x1; |
227 | y1 = draw->y1; |
| 187 | y1 = draw->y1; |
228 | |
| 188 | 229 | if ( !LineClip(&clip, &x0, &y0, &x1, &y1 )) |
|
| 189 | if ( !LineClip( &x0, &y0, &x1, &y1 )) |
230 | { |
| 190 | { |
231 | u32 efl; |
| 191 | u32 ifl; |
232 | u32 *ring, write; |
| 192 | u32 *ring, write; |
233 | |
| 193 | 234 | efl = safe_cli(); |
|
| 194 | ifl = safe_cli(); |
235 | |
| 195 | 236 | #if R300_PIO |
|
| 196 | #if R300_PIO |
237 | |
| 197 | 238 | R5xxFIFOWait(6); |
|
| 198 | R5xxFIFOWait(6); |
239 | |
| 199 | 240 | OUTREG(R5XX_DP_GUI_MASTER_CNTL, |
|
| 200 | OUTREG(R5XX_DP_GUI_MASTER_CNTL, |
241 | rhd.gui_control | |
| 201 | rhd.gui_control | |
242 | R5XX_GMC_BRUSH_SOLID_COLOR | |
| 202 | R5XX_GMC_BRUSH_SOLID_COLOR | |
243 | R5XX_GMC_SRC_DATATYPE_COLOR | |
| 203 | R5XX_GMC_SRC_DATATYPE_COLOR | |
244 | R5XX_GMC_CLR_CMP_CNTL_DIS | |
| 204 | R5XX_GMC_CLR_CMP_CNTL_DIS | |
245 | R5XX_GMC_WR_MSK_DIS | |
| 205 | R5XX_GMC_WR_MSK_DIS | |
246 | R5XX_ROP3_P |
| 206 | R5XX_ROP3_P |
247 | ); |
| 207 | ); |
248 | |
| 208 | 249 | OUTREG(R5XX_DST_LINE_PATCOUNT, 0x55 << R5XX_BRES_CNTL_SHIFT); |
|
| 209 | OUTREG(R5XX_DST_LINE_PATCOUNT, 0x55 << R5XX_BRES_CNTL_SHIFT); |
250 | |
| 210 | 251 | OUTREG(R5XX_DP_BRUSH_FRGD_CLR, draw->color); |
|
| 211 | OUTREG(R5XX_DP_BRUSH_FRGD_CLR, draw->color); |
252 | OUTREG(R5XX_DST_PITCH_OFFSET, rhd.dst_pitch_offset); |
| 212 | OUTREG(R5XX_DST_PITCH_OFFSET, rhd.dst_pitch_offset); |
253 | |
| 213 | 254 | OUTREG(R5XX_DST_LINE_START,(y0<<16)|x0); |
|
| 214 | OUTREG(R5XX_DST_LINE_START,(y0<<16)|x0); |
255 | OUTREG(R5XX_DST_LINE_END,(y1<<16)|x1); |
| 215 | OUTREG(R5XX_DST_LINE_END,(y1<<16)|x1); |
256 | |
| 216 | 257 | #else |
|
| 217 | #else |
258 | |
| 218 | 259 | BEGIN_RING(); |
|
| 219 | BEGIN_RING(); |
260 | OUT_RING(CP_PACKET3(RADEON_CNTL_PAINT_POLYLINE, 4)); |
| 220 | OUT_RING(CP_PACKET3(RADEON_CNTL_PAINT_POLYLINE, 4)); |
261 | OUT_RING(RADEON_GMC_DST_PITCH_OFFSET_CNTL | |
| 221 | OUT_RING(RADEON_GMC_DST_PITCH_OFFSET_CNTL | |
262 | RADEON_GMC_BRUSH_SOLID_COLOR | |
| 222 | RADEON_GMC_BRUSH_SOLID_COLOR | |
263 | RADEON_GMC_DST_32BPP | |
| 223 | RADEON_GMC_DST_32BPP | |
264 | RADEON_GMC_SRC_DATATYPE_COLOR | |
| 224 | RADEON_GMC_SRC_DATATYPE_COLOR | |
265 | R5XX_GMC_CLR_CMP_CNTL_DIS | |
| 225 | R5XX_GMC_CLR_CMP_CNTL_DIS | |
266 | R5XX_GMC_WR_MSK_DIS | |
| 226 | R5XX_GMC_WR_MSK_DIS | |
267 | R5XX_ROP3_P); |
| 227 | R5XX_ROP3_P); |
268 | |
| 228 | 269 | OUT_RING(rhd.dst_pitch_offset); |
|
| 229 | OUT_RING(rhd.dst_pitch_offset); |
270 | OUT_RING(draw->color); |
| 230 | OUT_RING(draw->color); |
271 | OUT_RING((y0<<16)|x0); |
| 231 | OUT_RING((y0<<16)|x0); |
272 | OUT_RING((y1<<16)|x1); |
| 232 | OUT_RING((y1<<16)|x1); |
273 | COMMIT_RING(); |
| 233 | COMMIT_RING(); |
274 | |
| 234 | 275 | #endif |
|
| 235 | #endif |
276 | safe_sti(efl); |
| 236 | safe_sti(ifl); |
277 | |
| 237 | 278 | }; |
|
| 238 | }; |
279 | return ERR_OK; |
| 239 | return ERR_OK; |
280 | } |
| 240 | } |
281 | #endif |
| 241 | 282 | ||
| - | 283 | int CreatePixmap(pixmap_t *io) |
|
| 242 | - | ||
| 243 | int CreatePixmap(userpixmap_t *io) |
284 | { |
| 244 | { |
285 | local_pixmap_t *pixmap; |
| - | 286 | ||
| - | 287 | unsigned pitch; |
|
| 245 | 288 | size_t size; |
|
| 246 | pixmap_t *pixmap; |
- | |
| 247 | 289 | ||
| 248 | u32_t pitch; |
290 | void *local; |
| 249 | void *raw; |
291 | |
| 250 | 292 | if( (io->width == 0) || (io->width > 2048)|| |
|
| 251 | if( (io->width == 0) || (io->width > 2048)|| |
293 | (io->height == 0)|| (io->height > 2048)) |
| 252 | (io->height == 0)|| (io->height > 2048)) |
294 | { |
| 253 | { |
295 | dbgprintf("Invalid pixmap size w:%d h:%d\n", io->width,io->height); |
| 254 | dbgprintf("Invalid pixmap size w:%d h:%d\n", io->width,io->height); |
296 | return ERR_PARAM; |
| 255 | return ERR_PARAM; |
297 | }; |
| 256 | 298 | ||
| 257 | }; |
- | |
| 258 | 299 | pitch = ((io->width+15)&~15)*4; |
|
| 259 | pitch = ((io->width+15)&~15)*4; |
300 | size = pitch*io->height; |
| 260 | dbgprintf("pitch = %d\n", pitch); |
301 | |
| - | 302 | dbgprintf("pitch = %d\n", pitch); |
|
| - | 303 | ||
| 261 | 304 | local = rhd_mem_alloc(&rhd,RHD_MEM_FB,size) ; |
|
| 262 | raw = rhd_mem_alloc(&rhd,RHD_MEM_FB,pitch*io->height) ; |
305 | if ( !local) |
| 263 | if (! raw) |
306 | { |
| 264 | { |
307 | dbgprintf("Not enough memory for pixmap\n"); |
| 265 | dbgprintf("Not enough memory for pixmap\n"); |
308 | return ERR_PARAM; |
| 266 | return ERR_PARAM; |
309 | }; |
| 267 | }; |
310 | |
| 268 | 311 | pixmap = malloc(sizeof(local_pixmap_t)); |
|
| 269 | pixmap = malloc(sizeof(pixmap_t)); |
312 | if(!pixmap) |
| 270 | if(!pixmap) |
313 | { |
| 271 | { |
314 | rhd_mem_free(&rhd, RHD_MEM_FB,local); |
| 272 | rhd_mem_free(&rhd, RHD_MEM_FB,raw); |
315 | return ERR_PARAM; |
| 273 | return ERR_PARAM; |
316 | } |
| 274 | } |
317 | else |
| 275 | else |
318 | { |
| 276 | { |
319 | void *mapped; |
| 277 | io->pixmap = pixmap; |
320 | |
| 278 | io->usermap = NULL; |
321 | size = (size+4095) & ~ 4095; |
| - | 322 | ||
| 279 | io->format = PICT_a8r8g8b8; |
323 | if (mapped = UserAlloc(size)) |
| - | 324 | { |
|
| 280 | io->pitch = 0; |
325 | CommitPages(mapped, ((u32_t)local+rhd.PhisBase)|7|(1<<9), size); |
| - | 326 | ||
| - | 327 | io->mapped = mapped; |
|
| - | 328 | io->pitch = pitch; |
|
| - | 329 | io->handle = (u32_t)pixmap; |
|
| 281 | 330 | ||
| - | 331 | pixmap->width = io->width; |
|
| 282 | pixmap->width = io->width; |
332 | pixmap->height = io->height; |
| 283 | pixmap->height = io->height; |
333 | pixmap->format = PICT_a8r8g8b8; |
| 284 | pixmap->format = PICT_a8r8g8b8; |
334 | pixmap->flags = io->flags; |
| 285 | pixmap->flags = 0; |
335 | pixmap->pitch = pitch; |
| 286 | pixmap->pitch = pitch; |
336 | pixmap->mapped = mapped; |
| 287 | pixmap->offset = (u32_t)raw+rhd.FbIntAddress; |
337 | pixmap->pitch_offset = ((pitch/64)<<22)| (((u32_t)local+rhd.FbIntAddress)>>10); |
| 288 | pixmap->pitch_offset = ((pitch/64)<<22)| (pixmap->offset>>10); |
338 | pixmap->local = local; |
| 289 | pixmap->raw = raw; |
339 | |
| 290 | pixmap->usermap = NULL; |
340 | dbgprintf("pixmap.pitch_offset: %x\n", pixmap->pitch_offset); |
| 291 | - | ||
| 292 | dbgprintf("pixmap.pitch_offset: %x\n", pixmap->pitch_offset); |
341 | dbgprintf("width: %d height: %d\n",pixmap->width,pixmap->height ); |
| 293 | dbgprintf("width: %d height: %d\n",pixmap->width,pixmap->height ); |
342 | dbgprintf("map at %x\n", pixmap->mapped); |
| 294 | dbgprintf("pixmap.offset: %x\n", pixmap->offset); |
343 | |
| 295 | 344 | return ERR_OK; |
|
| 296 | } |
- | |
| 297 | return ERR_OK; |
345 | }; |
| - | 346 | rhd_mem_free(&rhd, RHD_MEM_FB,local); |
|
| - | 347 | free(pixmap); |
|
| - | 348 | }; |
|
| - | 349 | return ERR_PARAM; |
|
| - | 350 | }; |
|
| 298 | } |
351 | |
| - | 352 | ||
| 299 | 353 | int DestroyPixmap( pixmap_t *io ) |
|
| 300 | int DestroyPixmap( userpixmap_t *io) |
354 | { |
| 301 | { |
355 | local_pixmap_t *pixmap; |
| - | 356 | size_t size; |
|
| 302 | pixmap_t *pixmap; |
357 | |
| 303 | 358 | dbgprintf("Destroy pixmap %x\n", io->handle); |
|
| 304 | dbgprintf("Destroy pixmap %x\n", io->pixmap); |
359 | |
| 305 | 360 | if(io->handle == -1) |
|
| 306 | if(io->pixmap == (pixmap_t*)-1) |
361 | return ERR_PARAM; |
| 307 | return ERR_PARAM; |
362 | else |
| 308 | else |
- | |
| - | 363 | pixmap = (local_pixmap_t*)io->handle; |
|
| 309 | pixmap = io->pixmap; |
364 | |
| - | 365 | size = (pixmap->pitch*pixmap->height+4095) & ~ 4095; |
|
| 310 | 366 | ||
| 311 | if( (pixmap->flags & 1) == PX_LOCK ) |
367 | UnmapPages(pixmap->mapped, size); |
| 312 | UnlockPixmap(io); |
- | |
| 313 | - | ||
| 314 | UserFree(pixmap->usermap); |
368 | UserFree(pixmap->mapped); |
| 315 | rhd_mem_free(&rhd,RHD_MEM_FB,pixmap->raw); |
369 | |
| - | 370 | rhd_mem_free(&rhd,RHD_MEM_FB,pixmap->local); |
|
| - | 371 | free(pixmap); |
|
| 316 | free(pixmap); |
372 | |
| 317 | 373 | io->format = 0; |
|
| 318 | io->pixmap = NULL; |
374 | io->pitch = 0; |
| 319 | io->usermap = NULL; |
375 | io->mapped = NULL; |
| 320 | io->format = 0; |
376 | io->handle = 0; |
| 321 | io->pitch = 0; |
377 | |
| 322 | 378 | return ERR_OK; |
|
| 323 | return ERR_OK; |
379 | }; |
| 324 | }; |
380 | |
| 325 | 381 | #if 0 |
|
| - | 382 | ||
| - | 383 | int LockPixmap(userpixmap_t *io) |
|
| 326 | int LockPixmap(userpixmap_t *io) |
384 | { |
| 327 | { |
385 | pixmap_t *pixmap; |
| 328 | pixmap_t *pixmap; |
386 | size_t size; |
| 329 | size_t size; |
387 | void *usermap; |
| 330 | void *usermap; |
388 | |
| 331 | 389 | dbgprintf("Lock pixmap %x\n", io->pixmap); |
|
| 332 | dbgprintf("Lock pixmap %x\n", io->pixmap); |
390 | |
| 333 | 391 | if(io->pixmap == (pixmap_t*)-1) |
|
| 334 | if(io->pixmap == (pixmap_t*)-1) |
392 | return ERR_PARAM; |
| 335 | return ERR_PARAM; |
393 | else |
| 336 | else |
394 | pixmap = io->pixmap; |
| 337 | pixmap = io->pixmap; |
395 | |
| 338 | 396 | if( (pixmap->flags & 1) == PX_LOCK ) |
|
| 339 | if( (pixmap->flags & 1) == PX_LOCK ) |
397 | return ERR_PARAM; |
| 340 | return ERR_PARAM; |
398 | |
| 341 | 399 | size = (pixmap->pitch*pixmap->width+4095) & ~ 4095; |
|
| 342 | size = (pixmap->pitch*pixmap->width+4095) & ~ 4095; |
400 | if (usermap = UserAlloc(size)) |
| 343 | if (usermap = UserAlloc(size)) |
401 | { |
| 344 | { |
402 | CommitPages(usermap, ((u32_t)pixmap->raw+rhd.PhisBase)|7|(1<<9), size); |
| 345 | CommitPages(usermap, ((u32_t)pixmap->raw+rhd.PhisBase)|7|(1<<9), size); |
403 | pixmap->flags |= PX_LOCK; |
| 346 | pixmap->flags |= PX_LOCK; |
404 | pixmap->usermap = usermap; |
| 347 | pixmap->usermap = usermap; |
405 | io->usermap = usermap; |
| 348 | io->usermap = usermap; |
406 | io->pitch = pixmap->pitch; |
| 349 | io->pitch = pixmap->pitch; |
407 | dbgprintf("map at %x\n", io->usermap); |
| 350 | dbgprintf("map at %x\n", io->usermap); |
408 | |
| 351 | 409 | return ERR_OK; |
|
| 352 | return ERR_OK; |
410 | } |
| 353 | } |
411 | else |
| 354 | else |
412 | return ERR_PARAM; |
| 355 | return ERR_PARAM; |
413 | }; |
| 356 | }; |
414 | |
| 357 | 415 | int UnlockPixmap(userpixmap_t *io) |
|
| 358 | int UnlockPixmap(userpixmap_t *io) |
416 | { |
| 359 | { |
417 | pixmap_t *pixmap; |
| 360 | pixmap_t *pixmap; |
418 | size_t size; |
| 361 | size_t size; |
419 | |
| 362 | 420 | dbgprintf("Unlock pixmap %x\n", io->pixmap); |
|
| 363 | dbgprintf("Unlock pixmap %x\n", io->pixmap); |
421 | |
| 364 | 422 | if(io->pixmap == (pixmap_t*)-1) |
|
| 365 | if(io->pixmap == (pixmap_t*)-1) |
423 | return ERR_PARAM; |
| 366 | return ERR_PARAM; |
424 | else |
| 367 | else |
425 | pixmap = io->pixmap; |
| 368 | pixmap = io->pixmap; |
426 | |
| 369 | 427 | if( (pixmap->flags & 1) != PX_LOCK ) |
|
| 370 | if( (pixmap->flags & 1) != PX_LOCK ) |
428 | return ERR_PARAM; |
| 371 | return ERR_PARAM; |
429 | |
| 372 | 430 | /* Sanity checks */ |
|
| 373 | /* Sanity checks */ |
431 | |
| 374 | 432 | if( (pixmap->usermap == 0)|| |
|
| 375 | if( (pixmap->usermap == 0)|| |
433 | ((u32_t)pixmap->usermap >= 0x80000000) || |
| 376 | ((u32_t)pixmap->usermap >= 0x80000000) || |
434 | ((u32_t)pixmap->usermap & 4095) |
| 377 | ((u32_t)pixmap->usermap & 4095) |
435 | ) |
| 378 | ) |
436 | return ERR_PARAM; |
| 379 | return ERR_PARAM; |
437 | |
| 380 | 438 | size = (pixmap->pitch*pixmap->width+4095) & ~ 4095; |
|
| 381 | size = (pixmap->pitch*pixmap->width+4095) & ~ 4095; |
439 | |
| 382 | 440 | UnmapPages(pixmap->usermap, size); |
|
| 383 | UnmapPages(pixmap->usermap, size); |
441 | UserFree(pixmap->usermap); |
| 384 | UserFree(pixmap->usermap); |
442 | pixmap->usermap = NULL; |
| 385 | pixmap->usermap = NULL; |
443 | pixmap->flags &= ~PX_LOCK; |
| 386 | pixmap->flags &= ~PX_LOCK; |
444 | io->usermap = NULL; |
| 387 | io->usermap = NULL; |
445 | io->pitch = 0; |
| 388 | io->pitch = 0; |
446 | |
| 389 | 447 | return ERR_OK; |
|
| 390 | return ERR_OK; |
448 | }; |
| 391 | }; |
449 | |
| 392 | 450 | #endif |
|
| - | 451 | ||
| 393 | 452 | int PixBlit(pixblit_t *blit) |
|
| 394 | int PixBlit(pixblit_t *blit) |
453 | { |
| 395 | { |
454 | clip_t src_clip, dst_clip; |
| 396 | 455 | ||
| - | 456 | local_pixmap_t *srcpixmap; |
|
| 397 | u32 *ring, write; |
- | |
| 398 | int w, h; |
- | |
| 399 | u32 ifl; |
- | |
| 400 | int x0, y0; |
- | |
| 401 | - | ||
| 402 | pixmap_t *srcpixmap; |
457 | local_pixmap_t *dstpixmap; |
| 403 | pixmap_t *dstpixmap; |
458 | |
| 404 | 459 | //dbgprintf("Pixblit src: %x dst: %x\n",blit->srcpix, blit->dstpix); |
|
| 405 | //dbgprintf("Pixblit src: %x dst: %x\n",blit->srcpix, blit->dstpix); |
460 | |
| 406 | 461 | dstpixmap = (blit->dstpix == (void*)-1) ? &scr_pixmap : blit->dstpix ; |
|
| 407 | dstpixmap = (blit->dstpix == (void*)-1) ? &scr_pixmap : blit->dstpix ; |
462 | srcpixmap = (blit->srcpix == (void*)-1) ? &scr_pixmap : blit->srcpix ; |
| 408 | srcpixmap = (blit->srcpix == (void*)-1) ? &scr_pixmap : blit->srcpix ; |
463 | |
| 409 | 464 | //dbgprintf("srcpixmap: %x dstpixmap: %x\n",srcpixmap, dstpixmap); |
|
| 410 | //dbgprintf("srcpixmap: %x dstpixmap: %x\n",srcpixmap, dstpixmap); |
465 | |
| 411 | 466 | //dbgprintf("dst.width: %d dst.height: %d\n", dstpixmap->width,dstpixmap->height); |
|
| 412 | //dbgprintf("dst.width: %d dst.height: %d\n", dstpixmap->width,dstpixmap->height); |
467 | //dbgprintf("src.width: %d src.height: %d\n", srcpixmap->width,srcpixmap->height); |
| 413 | //dbgprintf("src.width: %d src.height: %d\n", srcpixmap->width,srcpixmap->height); |
468 | //dbgprintf("srcpitch: %x dstpitch: %x\n", |
| 414 | //dbgprintf("srcpitch: %x dstpitch: %x\n", |
469 | // srcpixmap->pitch_offset,dstpixmap->pitch_offset); |
| 415 | // srcpixmap->pitch_offset,dstpixmap->pitch_offset); |
470 | |
| 416 | 471 | src_clip.xmin = 0; |
|
| - | 472 | src_clip.ymin = 0; |
|
| - | 473 | src_clip.xmax = srcpixmap->width-1; |
|
| - | 474 | src_clip.ymax = srcpixmap->height-1; |
|
| - | 475 | ||
| - | 476 | dst_clip.xmin = 0; |
|
| - | 477 | dst_clip.ymin = 0; |
|
| - | 478 | dst_clip.xmax = dstpixmap->width-1; |
|
| - | 479 | dst_clip.ymax = dstpixmap->height-1; |
|
| - | 480 | ||
| - | 481 | if( !blit_clip(&dst_clip, &blit->dst_x, &blit->dst_y, |
|
| - | 482 | &src_clip, &blit->src_x, &blit->src_y, |
|
| - | 483 | &blit->w, &blit->h) ) |
|
| - | 484 | { |
|
| - | 485 | u32_t *ring, write; |
|
| - | 486 | ||
| - | 487 | u32_t ifl = safe_cli(); |
|
| 417 | ifl = safe_cli(); |
488 | |
| 418 | 489 | #if R300_PIO |
|
| 419 | #if R300_PIO |
490 | |
| 420 | 491 | R5xxFIFOWait(7); |
|
| 421 | R5xxFIFOWait(7); |
492 | |
| 422 | 493 | OUTREG(R5XX_DP_GUI_MASTER_CNTL, |
|
| 423 | OUTREG(R5XX_DP_GUI_MASTER_CNTL, |
494 | RADEON_GMC_SRC_PITCH_OFFSET_CNTL | |
| 424 | RADEON_GMC_SRC_PITCH_OFFSET_CNTL | |
495 | RADEON_GMC_DST_PITCH_OFFSET_CNTL | |
| 425 | RADEON_GMC_DST_PITCH_OFFSET_CNTL | |
496 | RADEON_GMC_BRUSH_NONE | |
| 426 | RADEON_GMC_BRUSH_NONE | |
497 | RADEON_GMC_DST_32BPP | |
| 427 | RADEON_GMC_DST_32BPP | |
498 | RADEON_GMC_SRC_DATATYPE_COLOR | |
| 428 | RADEON_GMC_SRC_DATATYPE_COLOR | |
499 | RADEON_DP_SRC_SOURCE_MEMORY | |
| 429 | RADEON_DP_SRC_SOURCE_MEMORY | |
500 | R5XX_GMC_CLR_CMP_CNTL_DIS | |
| 430 | R5XX_GMC_CLR_CMP_CNTL_DIS | |
501 | R5XX_GMC_WR_MSK_DIS | |
| 431 | R5XX_GMC_WR_MSK_DIS | |
502 | R5XX_ROP3_S |
| 432 | R5XX_ROP3_S |
503 | ); |
| 433 | ); |
504 | |
| 434 | 505 | OUTREG(R5XX_DP_CNTL, R5XX_DST_X_LEFT_TO_RIGHT | R5XX_DST_Y_TOP_TO_BOTTOM); |
|
| 435 | OUTREG(R5XX_DP_CNTL, R5XX_DST_X_LEFT_TO_RIGHT | R5XX_DST_Y_TOP_TO_BOTTOM); |
506 | |
| 436 | 507 | OUTREG(R5XX_DST_PITCH_OFFSET, dstpixmap->pitch_offset); |
|
| 437 | OUTREG(R5XX_DST_PITCH_OFFSET, dstpixmap->pitch_offset); |
508 | OUTREG(R5XX_SRC_PITCH_OFFSET, srcpixmap->pitch_offset); |
| 438 | OUTREG(R5XX_SRC_PITCH_OFFSET, srcpixmap->pitch_offset); |
509 | |
| 439 | 510 | OUTREG(R5XX_SRC_Y_X,(blit->src_y<<16)|blit->src_x); |
|
| 440 | OUTREG(R5XX_SRC_Y_X,(blit->src_y<<16)|blit->src_x); |
511 | OUTREG(R5XX_DST_Y_X,(blit->dst_y<<16)|blit->dst_x); |
| 441 | OUTREG(R5XX_DST_Y_X,(blit->dst_y<<16)|blit->dst_x); |
512 | OUTREG(R5XX_DST_HEIGHT_WIDTH,(blit->h<<16)|blit->w); |
| 442 | OUTREG(R5XX_DST_HEIGHT_WIDTH,(blit->h<<16)|blit->w); |
513 | |
| 443 | 514 | #else |
|
| 444 | #else |
515 | |
| 445 | 516 | BEGIN_RING(); |
|
| 446 | BEGIN_RING(); |
517 | OUT_RING(CP_PACKET3(RADEON_CNTL_BITBLT, 5)); |
| 447 | OUT_RING(CP_PACKET3(RADEON_CNTL_BITBLT, 5)); |
518 | |
| 448 | 519 | OUT_RING(RADEON_GMC_SRC_PITCH_OFFSET_CNTL | |
|
| 449 | OUT_RING(RADEON_GMC_SRC_PITCH_OFFSET_CNTL | |
520 | RADEON_GMC_DST_PITCH_OFFSET_CNTL | |
| 450 | RADEON_GMC_DST_PITCH_OFFSET_CNTL | |
521 | RADEON_GMC_BRUSH_NONE | |
| 451 | RADEON_GMC_BRUSH_NONE | |
522 | RADEON_GMC_DST_32BPP | |
| 452 | RADEON_GMC_DST_32BPP | |
523 | RADEON_GMC_SRC_DATATYPE_COLOR | |
| 453 | RADEON_GMC_SRC_DATATYPE_COLOR | |
524 | RADEON_DP_SRC_SOURCE_MEMORY | |
| 454 | RADEON_DP_SRC_SOURCE_MEMORY | |
525 | R5XX_GMC_CLR_CMP_CNTL_DIS | |
| 455 | R5XX_GMC_CLR_CMP_CNTL_DIS | |
526 | R5XX_GMC_WR_MSK_DIS | |
| 456 | R5XX_GMC_WR_MSK_DIS | |
527 | R5XX_ROP3_S |
| 457 | R5XX_ROP3_S |
528 | ); |
| 458 | ); |
529 | |
| 459 | 530 | OUT_RING(srcpixmap->pitch_offset); |
|
| 460 | OUT_RING(srcpixmap->pitch_offset); |
531 | OUT_RING(dstpixmap->pitch_offset); |
| 461 | OUT_RING(dstpixmap->pitch_offset); |
532 | |
| 462 | 533 | OUT_RING((blit->src_x<<16)|blit->src_y); |
|
| 463 | OUT_RING((blit->src_x<<16)|blit->src_y); |
534 | OUT_RING((blit->dst_x<<16)|blit->dst_y); |
| 464 | OUT_RING((blit->dst_x<<16)|blit->dst_y); |
535 | OUT_RING((blit->w<<16)|blit->h); |
| 465 | OUT_RING((blit->w<<16)|blit->h); |
536 | COMMIT_RING(); |
| 466 | COMMIT_RING(); |
537 | |
| 467 | 538 | #endif |
|
| 468 | #endif |
539 | safe_sti(ifl); |
| 469 | 540 | }; |
|
| 470 | safe_sti(ifl); |
- | |
| 471 | return ERR_OK; |
541 | return ERR_OK; |
| - | 542 | }; |
|
| 472 | } |
543 | |
| 473 | 544 | ||
| 474 | 545 | int TransBlit(pixblit_t *blit) |
|
| 475 | int TransBlit(pixblit_t *blit) |
546 | { |
| 476 | { |
547 | clip_t src_clip, dst_clip; |
| 477 | 548 | ||
| - | 549 | local_pixmap_t *srcpixmap; |
|
| 478 | u32 *ring, write; |
- | |
| 479 | int w, h; |
- | |
| 480 | u32 ifl; |
- | |
| 481 | int x0, y0; |
- | |
| 482 | - | ||
| 483 | pixmap_t *srcpixmap; |
550 | local_pixmap_t *dstpixmap; |
| 484 | pixmap_t *dstpixmap; |
551 | |
| 485 | 552 | // dbgprintf("Transblit src: %x dst: %x\n",blit->srcpix, blit->dstpix); |
|
| 486 | // dbgprintf("Transblit src: %x dst: %x\n",blit->srcpix, blit->dstpix); |
553 | |
| 487 | 554 | dstpixmap = (blit->dstpix == (void*)-1) ? &scr_pixmap : blit->dstpix ; |
|
| 488 | dstpixmap = (blit->dstpix == (void*)-1) ? &scr_pixmap : blit->dstpix ; |
555 | srcpixmap = (blit->srcpix == (void*)-1) ? &scr_pixmap : blit->srcpix ; |
| 489 | srcpixmap = (blit->srcpix == (void*)-1) ? &scr_pixmap : blit->srcpix ; |
556 | |
| 490 | 557 | //dbgprintf("srcpixmap: %x dstpixmap: %x\n",srcpixmap, dstpixmap); |
|
| 491 | //dbgprintf("srcpixmap: %x dstpixmap: %x\n",srcpixmap, dstpixmap); |
558 | |
| 492 | 559 | //dbgprintf("dst.width: %d dst.height: %d\n", dstpixmap->width,dstpixmap->height); |
|
| 493 | //dbgprintf("dst.width: %d dst.height: %d\n", dstpixmap->width,dstpixmap->height); |
560 | //dbgprintf("src.width: %d src.height: %d\n", srcpixmap->width,srcpixmap->height); |
| 494 | //dbgprintf("src.width: %d src.height: %d\n", srcpixmap->width,srcpixmap->height); |
561 | //dbgprintf("srcpitch: %x dstpitch: %x\n", |
| 495 | //dbgprintf("srcpitch: %x dstpitch: %x\n", |
562 | // srcpixmap->pitch_offset,dstpixmap->pitch_offset); |
| 496 | // srcpixmap->pitch_offset,dstpixmap->pitch_offset); |
563 | src_clip.xmin = 0; |
| 497 | 564 | src_clip.ymin = 0; |
|
| - | 565 | src_clip.xmax = srcpixmap->width-1; |
|
| - | 566 | src_clip.ymax = srcpixmap->height-1; |
|
| - | 567 | ||
| - | 568 | dst_clip.xmin = 0; |
|
| - | 569 | dst_clip.ymin = 0; |
|
| - | 570 | dst_clip.xmax = dstpixmap->width-1; |
|
| - | 571 | dst_clip.ymax = dstpixmap->height-1; |
|
| - | 572 | ||
| - | 573 | if( !blit_clip(&dst_clip, &blit->dst_x, &blit->dst_y, |
|
| - | 574 | &src_clip, &blit->src_x, &blit->src_y, |
|
| - | 575 | &blit->w, &blit->h) ) |
|
| - | 576 | { |
|
| - | 577 | u32_t *ring, write; |
|
| - | 578 | ||
| - | 579 | u32_t ifl = safe_cli(); |
|
| 498 | ifl = safe_cli(); |
580 | |
| 499 | 581 | #if R300_PIO |
|
| 500 | #if R300_PIO |
582 | |
| 501 | 583 | R5xxFIFOWait(10); |
|
| 502 | R5xxFIFOWait(10); |
584 | |
| 503 | 585 | OUTREG(R5XX_DP_GUI_MASTER_CNTL, |
|
| 504 | OUTREG(R5XX_DP_GUI_MASTER_CNTL, |
586 | RADEON_GMC_SRC_PITCH_OFFSET_CNTL | |
| 505 | RADEON_GMC_SRC_PITCH_OFFSET_CNTL | |
587 | RADEON_GMC_DST_PITCH_OFFSET_CNTL | |
| 506 | RADEON_GMC_DST_PITCH_OFFSET_CNTL | |
588 | RADEON_GMC_BRUSH_NONE | |
| 507 | RADEON_GMC_BRUSH_NONE | |
589 | RADEON_GMC_DST_32BPP | |
| 508 | RADEON_GMC_DST_32BPP | |
590 | RADEON_GMC_SRC_DATATYPE_COLOR | |
| 509 | RADEON_GMC_SRC_DATATYPE_COLOR | |
591 | RADEON_DP_SRC_SOURCE_MEMORY | |
| 510 | RADEON_DP_SRC_SOURCE_MEMORY | |
592 | R5XX_GMC_WR_MSK_DIS | |
| 511 | R5XX_GMC_WR_MSK_DIS | |
593 | R5XX_ROP3_S |
| 512 | R5XX_ROP3_S |
594 | ); |
| 513 | ); |
595 | |
| 514 | 596 | OUTREG(R5XX_DP_CNTL, R5XX_DST_X_LEFT_TO_RIGHT | R5XX_DST_Y_TOP_TO_BOTTOM); |
|
| 515 | OUTREG(R5XX_DP_CNTL, R5XX_DST_X_LEFT_TO_RIGHT | R5XX_DST_Y_TOP_TO_BOTTOM); |
597 | |
| 516 | 598 | OUTREG(R5XX_CLR_CMP_CLR_SRC, 0xFF000000); |
|
| 517 | OUTREG(R5XX_CLR_CMP_CLR_SRC, 0xFF000000); |
599 | OUTREG(R5XX_CLR_CMP_MASK, R5XX_CLR_CMP_MSK); |
| 518 | OUTREG(R5XX_CLR_CMP_MASK, R5XX_CLR_CMP_MSK); |
600 | OUTREG(R5XX_CLR_CMP_CNTL, R5XX_SRC_CMP_EQ_COLOR | R5XX_CLR_CMP_SRC_SOURCE); |
| 519 | OUTREG(R5XX_CLR_CMP_CNTL, R5XX_SRC_CMP_EQ_COLOR | R5XX_CLR_CMP_SRC_SOURCE); |
601 | |
| 520 | 602 | OUTREG(R5XX_DST_PITCH_OFFSET, dstpixmap->pitch_offset); |
|
| 521 | OUTREG(R5XX_DST_PITCH_OFFSET, dstpixmap->pitch_offset); |
603 | OUTREG(R5XX_SRC_PITCH_OFFSET, srcpixmap->pitch_offset); |
| 522 | OUTREG(R5XX_SRC_PITCH_OFFSET, srcpixmap->pitch_offset); |
604 | |
| 523 | 605 | OUTREG(R5XX_SRC_Y_X,(blit->src_y<<16)|blit->src_x); |
|
| 524 | OUTREG(R5XX_SRC_Y_X,(blit->src_y<<16)|blit->src_x); |
606 | OUTREG(R5XX_DST_Y_X,(blit->dst_y<<16)|blit->dst_x); |
| 525 | OUTREG(R5XX_DST_Y_X,(blit->dst_y<<16)|blit->dst_x); |
607 | OUTREG(R5XX_DST_HEIGHT_WIDTH,(blit->h<<16)|blit->w); |
| 526 | OUTREG(R5XX_DST_HEIGHT_WIDTH,(blit->h<<16)|blit->w); |
608 | |
| 527 | 609 | #else |
|
| 528 | #else |
610 | |
| 529 | 611 | BEGIN_RING(); |
|
| 530 | BEGIN_RING(); |
612 | OUT_RING(CP_PACKET3(RADEON_CNTL_TRANBLT, 8)); |
| 531 | OUT_RING(CP_PACKET3(RADEON_CNTL_TRANBLT, 8)); |
613 | |
| 532 | 614 | OUT_RING(RADEON_GMC_SRC_PITCH_OFFSET_CNTL | |
|
| 533 | OUT_RING(RADEON_GMC_SRC_PITCH_OFFSET_CNTL | |
615 | RADEON_GMC_DST_PITCH_OFFSET_CNTL | |
| 534 | RADEON_GMC_DST_PITCH_OFFSET_CNTL | |
616 | RADEON_GMC_BRUSH_NONE | |
| 535 | RADEON_GMC_BRUSH_NONE | |
617 | RADEON_GMC_DST_32BPP | |
| 536 | RADEON_GMC_DST_32BPP | |
618 | RADEON_GMC_SRC_DATATYPE_COLOR | |
| 537 | RADEON_GMC_SRC_DATATYPE_COLOR | |
619 | RADEON_DP_SRC_SOURCE_MEMORY | |
| 538 | RADEON_DP_SRC_SOURCE_MEMORY | |
620 | R5XX_GMC_WR_MSK_DIS | |
| 539 | R5XX_GMC_WR_MSK_DIS | |
621 | R5XX_ROP3_S |
| 540 | R5XX_ROP3_S |
622 | ); |
| 541 | ); |
623 | |
| 542 | 624 | OUT_RING(srcpixmap->pitch_offset); |
|
| 543 | OUT_RING(srcpixmap->pitch_offset); |
625 | OUT_RING(dstpixmap->pitch_offset); |
| 544 | OUT_RING(dstpixmap->pitch_offset); |
626 | |
| 545 | 627 | OUT_RING(R5XX_CLR_CMP_SRC_SOURCE | R5XX_SRC_CMP_EQ_COLOR); |
|
| 546 | OUT_RING(R5XX_CLR_CMP_SRC_SOURCE | R5XX_SRC_CMP_EQ_COLOR); |
628 | OUT_RING(0xFF000000); |
| 547 | OUT_RING(0xFF000000); |
629 | OUT_RING(0xFF000000); |
| 548 | OUT_RING(0xFF000000); |
630 | |
| 549 | 631 | OUT_RING((blit->src_x<<16)|blit->src_y); |
|
| 550 | OUT_RING((blit->src_x<<16)|blit->src_y); |
632 | OUT_RING((blit->dst_x<<16)|blit->dst_y); |
| 551 | OUT_RING((blit->dst_x<<16)|blit->dst_y); |
633 | OUT_RING((blit->w<<16)|blit->h); |
| 552 | OUT_RING((blit->w<<16)|blit->h); |
634 | |
| 553 | 635 | COMMIT_RING(); |
|
| 554 | COMMIT_RING(); |
636 | |
| 555 | 637 | #endif |
|
| 556 | #endif |
638 | |
| 557 | 639 | safe_sti(ifl); |
|
| 558 | safe_sti(ifl); |
640 | }; |
| 559 | return ERR_OK; |
641 | return ERR_OK; |
| - | 642 | } |
|
| 560 | } |
643 | > |
| 561 | > |
644 | > |
| 562 | > |
645 | > |
| 563 | > |
646 | > |
| 564 | > |
647 | |
| 565 | 648 | #else |
|
| 566 | #else |
649 | |
| 567 | 650 | > |
|
| 568 | > |
651 | |
| 569 | 652 | #else |
|
| 570 | #else |
653 | |
| 571 | 654 | > |
|
| 572 | > |
655 | > |
| 573 | > |
656 | > |
| 574 | > |
657 | > |
| 575 | > |
658 | > |
| 576 | > |
659 | > |
| 577 | > |
660 | > |
| 578 | > |
661 | > |
| 579 | > |
662 | > |
| 580 | > |
663 | > |
| 581 | > |
664 | > |
| 582 | > |
665 | #else |
| 583 | > |
666 | > |
| 584 | > |
667 | #else |
| 585 | > |
668 | > |
| 586 | > |
669 | > |
| 587 | 670 | > |
|
| 588 | #else |
671 | > |
| 589 | 672 | > |
|
| 590 | > |
673 | > |
| 591 | 674 | > |
|
| 592 | #else |
675 | #else |
| 593 | 676 | > |
|
| 594 | > |
677 | #else |
| 595 | > |
678 | > |
| 596 | > |
- | |
| 597 | - | ||
| 598 | - | ||
| 599 | int> |
- | |
| 600 | - | ||
| 601 | - | ||
| 602 | int> |
- | |