Rev 5354 | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
1221 | serge | 1 | |
2 | #include |
||
5078 | serge | 3 | #include "radeon.h" |
1221 | serge | 4 | #include "radeon_object.h" |
5 | |||
6321 | serge | 6 | |
5354 | serge | 7 | |
1221 | serge | 8 | |
1428 | serge | 9 | |
10 | |||
11 | |||
5078 | serge | 12 | |
1221 | serge | 13 | |
1246 | serge | 14 | static void __stdcall move_cursor(cursor_t *cursor, int x, int y); |
15 | |||
1221 | serge | 16 | |
2175 | serge | 17 | |
1313 | serge | 18 | |
19 | {}; |
||
20 | |||
21 | |||
1221 | serge | 22 | { |
23 | struct radeon_device *rdev; |
||
24 | |||
25 | |||
26 | uint32_t *src; |
||
27 | |||
28 | |||
29 | int r; |
||
30 | |||
31 | |||
5078 | serge | 32 | |
1221 | serge | 33 | |
1963 | serge | 34 | 4096, false, RADEON_GEM_DOMAIN_VRAM, 0, NULL, NULL, (struct radeon_bo**)&cursor->cobj); |
5354 | serge | 35 | |
1221 | serge | 36 | |
37 | return r; |
||
38 | |||
39 | |||
5354 | serge | 40 | if (unlikely(r != 0)) |
1404 | serge | 41 | return r; |
42 | |||
1221 | serge | 43 | |
5354 | serge | 44 | if (unlikely(r != 0)) |
1404 | serge | 45 | return r; |
46 | |||
47 | |||
5354 | serge | 48 | if (r) { |
1221 | serge | 49 | DRM_ERROR("radeon: failed to map cursor (%d).\n", r); |
50 | return r; |
||
51 | }; |
||
52 | |||
53 | |||
54 | |||
55 | |||
56 | { |
||
57 | for(j = 0; j < 32; j++) |
||
58 | *bits++ = *src++; |
||
59 | for(j = 32; j < CURSOR_WIDTH; j++) |
||
1230 | serge | 60 | *bits++ = 0; |
1221 | serge | 61 | } |
62 | for(i = 0; i < CURSOR_WIDTH*(CURSOR_HEIGHT-32); i++) |
||
63 | *bits++ = 0; |
||
64 | |||
65 | |||
5354 | serge | 66 | |
1221 | serge | 67 | |
1963 | serge | 68 | |
1313 | serge | 69 | |
1221 | serge | 70 | }; |
71 | |||
72 | |||
2175 | serge | 73 | { |
1313 | serge | 74 | list_del(&cursor->list); |
75 | radeon_bo_unpin(cursor->cobj); |
||
5354 | serge | 76 | KernelFree(cursor->data); |
1313 | serge | 77 | __DestroyObject(cursor); |
78 | }; |
||
79 | |||
80 | |||
1246 | serge | 81 | { |
1221 | serge | 82 | struct radeon_device *rdev = (struct radeon_device *)os_display->ddev->dev_private; |
5078 | serge | 83 | |
1230 | serge | 84 | |
2004 | serge | 85 | |
86 | WREG32(RADEON_MM_INDEX, EVERGREEN_CUR_CONTROL); |
||
87 | WREG32(RADEON_MM_DATA, EVERGREEN_CURSOR_EN | |
||
88 | EVERGREEN_CURSOR_MODE(EVERGREEN_CURSOR_24_8_PRE_MULT)); |
||
89 | } else if (ASIC_IS_AVIVO(rdev)) { |
||
90 | WREG32(RADEON_MM_INDEX, AVIVO_D1CUR_CONTROL); |
||
1246 | serge | 91 | WREG32(RADEON_MM_DATA, AVIVO_D1CURSOR_EN | |
1230 | serge | 92 | (AVIVO_D1CURSOR_MODE_24BPP << AVIVO_D1CURSOR_MODE_SHIFT)); |
93 | } else { |
||
94 | WREG32(RADEON_MM_INDEX, RADEON_CRTC_GEN_CNTL); |
||
1275 | serge | 95 | WREG32_P(RADEON_MM_DATA, (RADEON_CRTC_CUR_EN | |
1230 | serge | 96 | (RADEON_CRTC_CUR_MODE_24BPP << RADEON_CRTC_CUR_MODE_SHIFT)), |
97 | ~(RADEON_CRTC_CUR_EN | RADEON_CRTC_CUR_MODE_MASK)); |
||
98 | } |
||
99 | } |
||
100 | |||
101 | |||
102 | { |
||
1221 | serge | 103 | struct radeon_device *rdev; |
104 | cursor_t *old; |
||
105 | uint32_t gpu_addr; |
||
106 | |||
107 | |||
5078 | serge | 108 | |
1221 | serge | 109 | |
5078 | serge | 110 | |
1221 | serge | 111 | |
5078 | serge | 112 | gpu_addr = radeon_bo_gpu_offset(cursor->cobj); |
5354 | serge | 113 | |
1221 | serge | 114 | |
2004 | serge | 115 | { |
116 | WREG32(EVERGREEN_CUR_SURFACE_ADDRESS_HIGH, 0); |
||
117 | WREG32(EVERGREEN_CUR_SURFACE_ADDRESS, gpu_addr); |
||
118 | } |
||
119 | else if (ASIC_IS_AVIVO(rdev)) |
||
120 | { |
||
121 | if (rdev->family >= CHIP_RV770) |
||
122 | WREG32(R700_D1CUR_SURFACE_ADDRESS_HIGH, 0); |
||
123 | WREG32(AVIVO_D1CUR_SURFACE_ADDRESS, gpu_addr); |
||
1246 | serge | 124 | } |
2004 | serge | 125 | else { |
1221 | serge | 126 | WREG32(RADEON_CUR_OFFSET, gpu_addr - rdev->mc.vram_start); |
1430 | serge | 127 | } |
1221 | serge | 128 | |
1230 | serge | 129 | |
1221 | serge | 130 | }; |
131 | |||
132 | |||
1246 | serge | 133 | { |
134 | struct radeon_device *rdev; |
||
135 | |||
1221 | serge | 136 | |
5078 | serge | 137 | |
1246 | serge | 138 | |
139 | |||
140 | |||
2004 | serge | 141 | cur_lock = RREG32(EVERGREEN_CUR_UPDATE); |
142 | if (lock) |
||
143 | cur_lock |= EVERGREEN_CURSOR_UPDATE_LOCK; |
||
144 | else |
||
145 | cur_lock &= ~EVERGREEN_CURSOR_UPDATE_LOCK; |
||
146 | WREG32(EVERGREEN_CUR_UPDATE, cur_lock); |
||
147 | } else if (ASIC_IS_AVIVO(rdev)) { |
||
148 | cur_lock = RREG32(AVIVO_D1CUR_UPDATE); |
||
1246 | serge | 149 | if (lock) |
150 | cur_lock |= AVIVO_D1CURSOR_UPDATE_LOCK; |
||
151 | else |
||
152 | cur_lock &= ~AVIVO_D1CURSOR_UPDATE_LOCK; |
||
153 | WREG32(AVIVO_D1CUR_UPDATE, cur_lock); |
||
154 | } else { |
||
155 | cur_lock = RREG32(RADEON_CUR_OFFSET); |
||
156 | if (lock) |
||
157 | cur_lock |= RADEON_CUR_LOCK; |
||
158 | else |
||
159 | cur_lock &= ~RADEON_CUR_LOCK; |
||
160 | WREG32(RADEON_CUR_OFFSET, cur_lock); |
||
161 | } |
||
162 | } |
||
163 | |||
164 | |||
165 | |||
1230 | serge | 166 | { |
1221 | serge | 167 | struct radeon_device *rdev; |
1230 | serge | 168 | rdev = (struct radeon_device *)os_display->ddev->dev_private; |
5078 | serge | 169 | |
1221 | serge | 170 | |
1230 | serge | 171 | int hot_y = cursor->hot_y; |
172 | int w = 32; |
||
2004 | serge | 173 | |
1221 | serge | 174 | |
1246 | serge | 175 | |
1221 | serge | 176 | |
2004 | serge | 177 | WREG32(EVERGREEN_CUR_POSITION,(x << 16) | y); |
178 | WREG32(EVERGREEN_CUR_HOT_SPOT, (hot_x << 16) | hot_y); |
||
179 | WREG32(EVERGREEN_CUR_SIZE, ((w - 1) << 16) | 31); |
||
180 | } else if (ASIC_IS_AVIVO(rdev)) { |
||
181 | WREG32(AVIVO_D1CUR_POSITION, (x << 16) | y); |
||
1246 | serge | 182 | WREG32(AVIVO_D1CUR_HOT_SPOT, (hot_x << 16) | hot_y); |
183 | WREG32(AVIVO_D1CUR_SIZE, ((w - 1) << 16) | 31); |
||
184 | } else { |
||
1275 | serge | 185 | |
1404 | serge | 186 | |
1246 | serge | 187 | int xorg =0, yorg=0; |
1404 | serge | 188 | |
1221 | serge | 189 | |
1404 | serge | 190 | y = y - hot_y; |
191 | |||
192 | |||
193 | { |
||
194 | xorg = -x + 1; |
||
195 | x = 0; |
||
196 | } |
||
197 | |||
198 | |||
199 | { |
||
200 | yorg = -hot_y + 1; |
||
201 | y = 0; |
||
202 | }; |
||
203 | |||
204 | |||
1246 | serge | 205 | (RADEON_CUR_LOCK | (xorg << 16) | yorg )); |
1404 | serge | 206 | WREG32(RADEON_CUR_HORZ_VERT_POSN, |
1246 | serge | 207 | (RADEON_CUR_LOCK | (x << 16) | y)); |
1221 | serge | 208 | |
209 | |||
5354 | serge | 210 | |
1246 | serge | 211 | |
1221 | serge | 212 | WREG32(RADEON_CUR_OFFSET, |
1246 | serge | 213 | (gpu_addr - rdev->mc.vram_start + (yorg * 256))); |
1430 | serge | 214 | } |
1221 | serge | 215 | radeon_lock_cursor(false); |
1246 | serge | 216 | } |
1221 | serge | 217 | |
218 | |||
1230 | serge | 219 | { |
220 | }; |
||
221 | |||
1221 | serge | 222 | |
1233 | serge | 223 | |
1404 | serge | 224 | { |
1233 | serge | 225 | struct drm_device *dev; |
1275 | serge | 226 | |
1246 | serge | 227 | |
5271 | serge | 228 | bool retval = true; |
229 | u32 ifl; |
||
230 | |||
1233 | serge | 231 | |
232 | |||
233 | |||
5078 | serge | 234 | |
1233 | serge | 235 | |
5078 | serge | 236 | |
1233 | serge | 237 | |
1246 | serge | 238 | { |
239 | list_for_each_entry(cursor, &os_display->cursors, list) |
||
5078 | serge | 240 | { |
1275 | serge | 241 | init_cursor(cursor); |
242 | }; |
||
243 | |||
1233 | serge | 244 | |
5078 | serge | 245 | os_display->init_cursor = init_cursor; |
246 | os_display->select_cursor = select_cursor; |
||
247 | os_display->show_cursor = NULL; |
||
248 | os_display->move_cursor = move_cursor; |
||
249 | os_display->restore_cursor = restore_cursor; |
||
250 | os_display->disable_mouse = disable_mouse; |
||
251 | |||
1233 | serge | 252 | |
5078 | serge | 253 | radeon_show_cursor(); |
1246 | serge | 254 | }; |
255 | safe_sti(ifl); |
||
256 | |||
257 | |||
3764 | Serge | 258 | |
3120 | serge | 259 | |
1233 | serge | 260 | |
261 | |||
1239 | serge | 262 | }; |
1233 | serge | 263 | |
264 | |||
265 | |||
1404 | serge | 266 | { |
267 | #define BYTES_PER_LONG (BITS_PER_LONG/8) |
||
268 | #define PADDING (BYTES_PER_LONG - (sizeof(struct fb_info) % BYTES_PER_LONG)) |
||
269 | int fb_info_size = sizeof(struct fb_info); |
||
270 | struct fb_info *info; |
||
271 | char *p; |
||
272 | |||
1233 | serge | 273 | |
1404 | serge | 274 | fb_info_size += PADDING; |
275 | |||
276 | |||
277 | |||
278 | |||
279 | return NULL; |
||
280 | |||
281 | |||
282 | |||
283 | |||
284 | info->par = p + fb_info_size; |
||
285 | |||
286 | |||
287 | #undef PADDING |
||
288 | #undef BYTES_PER_LONG |
||
289 | } |
||
290 | |||
291 | |||
292 | { |
||
293 | kfree(info); |
||
294 | } |
||
295 | |||
296 | |||
1963 | serge | 297 | |
2997 | Serge | 298 | #define I2F_FRAC_BITS 23 |
299 | #define I2F_MASK ((1 << I2F_FRAC_BITS) - 1) |
||
300 | |||
301 | |||
302 | * Converts unsigned integer into 32-bit IEEE floating point representation. |
||
303 | * Will be exact from 0 to 2^24. Above that, we round towards zero |
||
304 | * as the fractional bits will not fit in a float. (It would be better to |
||
305 | * round towards even as the fpu does, but that is slower.) |
||
306 | */ |
||
307 | __pure uint32_t int2float(uint32_t x) |
||
308 | { |
||
309 | uint32_t msb, exponent, fraction; |
||
310 | |||
311 | |||
312 | if (!x) return 0; |
||
313 | |||
314 | |||
315 | msb = __fls(x); |
||
316 | |||
317 | |||
318 | * Use a rotate instead of a shift because that works both leftwards |
||
319 | * and rightwards due to the mod(32) behaviour. This means we don't |
||
320 | * need to check to see if we are above 2^24 or not. |
||
321 | */ |
||
322 | fraction = ror32(x, (msb - I2F_FRAC_BITS) & 0x1f) & I2F_MASK; |
||
323 | exponent = (127 + msb) << I2F_FRAC_BITS; |
||
324 | |||
325 | |||
326 | }><>><>><>><>>>><>><>><>><>><>><>><>><>>>>> |
||
327 |