?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Hint added.
[AROS.git] / workbench / hidds / radeon / ati_class.c
blobb4596650e34b73bc8e49db3f9000facc59855aa4
1 /*
2 Copyright © 2004-2015, The AROS Development Team. All rights reserved.
3 $Id$
4 */
5
6 #include <utility/tagitem.h>
7
8 #include <proto/exec.h>
9 #include <proto/oop.h>
10 #include <proto/utility.h>
11
12 #include "ati.h"
13 #include "radeon.h"
14 #include "radeon_reg.h"
15 #include "radeon_bios.h"
16 #include "radeon_accel.h"
17 #include "radeon_macros.h"
18
19 #define DEBUG 0
20 #include <aros/debug.h>
21
22 #define sd ((struct ati_staticdata*)SD(cl))
23
24 #undef HiddPCIDeviceAttrBase
25 #undef HiddGfxAttrBase
26 #undef HiddPixFmtAttrBase
27 #undef HiddSyncAttrBase
28 #undef HiddBitMapAttrBase
29 #define HiddPCIDeviceAttrBase (sd->pciAttrBase)
30 #define HiddATIBitMapAttrBase (sd->atiBitMapAttrBase)
31 #define HiddBitMapAttrBase (sd->bitMapAttrBase)
32 #define HiddPixFmtAttrBase (sd->pixFmtAttrBase)
33 #define HiddGfxAttrBase (sd->gfxAttrBase)
34 #define HiddSyncAttrBase (sd->syncAttrBase)
35
36 #define ToRGB8888(alp,c) ((c) | ((alp) << 24))
37
38 #if AROS_BIG_ENDIAN
39
40 #define CURSOR_SWAPPING_DECL_MMIO ULONG __temp_surface_cntl = INREG(RADEON_SURFACE_CNTL)
41 #define CURSOR_SWAPPING_START() \
42 OUTREG(RADEON_SURFACE_CNTL, \
43 (__temp_surface_cntl | \
44 RADEON_NONSURF_AP0_SWP_32BPP) & \
45 ~RADEON_NONSURF_AP0_SWP_16BPP)
46 #define CURSOR_SWAPPING_END() (OUTREG(RADEON_SURFACE_CNTL, \
47 __temp_surface_cntl))
48
49 #else
50
51 #define CURSOR_SWAPPING_DECL_MMIO
52 #define CURSOR_SWAPPING_START()
53 #define CURSOR_SWAPPING_END()
54
55 #endif
56
57 #define MAKE_SYNC(name,clock,hdisp,hstart,hend,htotal,vdisp,vstart,vend,vtotal,descr) \
58 struct TagItem sync_ ## name[]={ \
59 { aHidd_Sync_PixelClock, clock*1000 }, \
60 { aHidd_Sync_HDisp, hdisp }, \
61 { aHidd_Sync_HSyncStart, hstart }, \
62 { aHidd_Sync_HSyncEnd, hend }, \
63 { aHidd_Sync_HTotal, htotal }, \
64 { aHidd_Sync_VDisp, vdisp }, \
65 { aHidd_Sync_VSyncStart, vstart }, \
66 { aHidd_Sync_VSyncEnd, vend }, \
67 { aHidd_Sync_VTotal, vtotal }, \
68 { aHidd_Sync_Description, (IPTR)descr}, \
69 { TAG_DONE, 0UL }}
70
71 //#define DEBUG_POINTER
72
73 #ifdef DEBUG_POINTER
74
75 #define PRINT_POINTER(image, xsize, xmax, ymax) \
76 bug("[ATI] Pointer data:\n"); \
77 { \
78 ULONG *pix = (ULONG *)image; \
79 ULONG x, y; \
80 \
81 for (y = 0; y < ymax; y++) { \
82 for (x = 0; x < xmax; x++) \
83 bug("0x%08X ", pix[x]); \
84 bug("\n"); \
85 pix += xsize; \
86 } \
87 }
88
89 #else
90 #define PRINT_POINTER(image, xsize, xmax, ymax)
91 #endif
92
93 OOP_Object *METHOD(ATI, Hidd_Gfx, Show)
94 {
95 OOP_Object *fb = NULL;
96 if (msg->bitMap)
97 {
98 atiBitMap *bm = OOP_INST_DATA(OOP_OCLASS(msg->bitMap), msg->bitMap);
99 if (bm->state)
100 {
101 /* Suppose bm has properly allocated state structure */
102 if (bm->fbgfx)
103 {
104 bm->usecount++;
105
106 LOCK_HW
107 LoadState(sd, bm->state);
108 DPMS(sd, sd->dpms);
109
110 fb = bm->BitMap;
111 ShowHideCursor(sd, sd->Card.cursorVisible);
112
113 RADEONEngineReset(sd);
114 RADEONEngineRestore(sd);
115
116 UNLOCK_HW
117 }
118 }
119 }
120
121 if (!fb)
122 fb = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
123
124 return fb;
125 }
126
127 OOP_Object *METHOD(ATI, Hidd_Gfx, CreateObject)
128 {
129 OOP_Object *object = NULL;
130
131 if (msg->cl == sd->basebm)
132 {
133 BOOL displayable, framebuffer;
134 OOP_Class *classptr = NULL;
135 struct TagItem mytags[] =
136 {
137 { TAG_IGNORE, TAG_IGNORE }, /* Placeholder for aHidd_BitMap_ClassPtr */
138 { TAG_MORE, (IPTR)msg->attrList }
139 };
140
141 struct pHidd_Gfx_CreateObject p;
142
143 /* Displayable bitmap ? */
144 displayable = GetTagData(aHidd_BitMap_Displayable, FALSE, msg->attrList);
145 framebuffer = GetTagData(aHidd_BitMap_FrameBuffer, FALSE, msg->attrList);
146
147 if (framebuffer)
148 {
149 /* If the user asks for a framebuffer map we must ALLWAYS supply a class */
150 classptr = sd->OnBMClass;
151 }
152 else if (displayable)
153 {
154 classptr = sd->OnBMClass; //offbmclass;
155 }
156 else
157 {
158 HIDDT_ModeID modeid;
159 /*
160 For the non-displayable case we can either supply a class ourselves
161 if we can optimize a certain type of non-displayable bitmaps. Or we
162 can let the superclass create on for us.
163
164 The attributes that might come from the user deciding the bitmap
165 pixel format are:
166 - aHidd_BitMap_ModeID: a modeid. create a nondisplayable
167 bitmap with the size and pixelformat of a gfxmode.
168 - aHidd_BitMap_StdPixFmt: a standard pixelformat as described in
169 hidd/graphics.h
170 - aHidd_BitMap_Friend: if this is supplied and none of the two above
171 are supplied, then the pixel format of the created bitmap
172 will be the same as the one of the friend bitmap.
173
174 These tags are listed in prioritized order, so if
175 the user supplied a ModeID tag, then you should not care about StdPixFmt
176 or Friend. If there is no ModeID, but a StdPixFmt tag supplied,
177 then you should not care about Friend because you have to
178 create the correct pixelformat. And as said above, if only Friend
179 is supplied, you can create a bitmap with same pixelformat as Frien
180 */
181
182 modeid = (HIDDT_ModeID)GetTagData(aHidd_BitMap_ModeID, vHidd_ModeID_Invalid, msg->attrList);
183
184 if (vHidd_ModeID_Invalid != modeid)
185 {
186 /* User supplied a valid modeid. We can use our offscreen class */
187 classptr = sd->OffBMClass;
188 }
189 else
190 {
191 /*
192 We may create an offscreen bitmap if the user supplied a friend
193 bitmap. But we need to check that he did not supplied a StdPixFmt
194 */
195 HIDDT_StdPixFmt stdpf = (HIDDT_StdPixFmt)GetTagData(aHidd_BitMap_StdPixFmt, vHidd_StdPixFmt_Unknown, msg->attrList);
196
197 if (vHidd_StdPixFmt_Plane == stdpf)
198 {
199 classptr = sd->PlanarBMClass;
200 }
201 else if (vHidd_StdPixFmt_Unknown == stdpf)
202 {
203 /* No std pixfmt supplied */
204 OOP_Object *friend;
205
206 /* Did the user supply a friend bitmap ? */
207 friend = (OOP_Object *)GetTagData(aHidd_BitMap_Friend, 0, msg->attrList);
208 if (NULL != friend)
209 {
210 OOP_Class *friend_class = NULL;
211 /* User supplied friend bitmap. Is the friend bitmap a Ati Gfx hidd bitmap ? */
212 OOP_GetAttr(friend, aHidd_BitMap_ClassPtr, (APTR)&friend_class);
213 if (friend_class == sd->OnBMClass)
214 {
215 /* Friend was ATI hidd bitmap. Now we can supply our own class */
216 classptr = sd->OffBMClass;
217 }
218 }
219 }
220 }
221 }
222
223 D(bug("[ATI] classptr = %p\n", classptr));
224
225 /* Do we supply our own class ? */
226 if (NULL != classptr)
227 {
228 /* Yes. We must let the superclass not that we do this. This is
229 done through adding a tag in the frot of the taglist */
230 mytags[0].ti_Tag = aHidd_BitMap_ClassPtr;
231 mytags[0].ti_Data = (IPTR)classptr;
232 }
233
234 /* Like in Gfx::New() we init a new message struct */
235 p.mID = msg->mID;
236 p.cl = msg->cl;
237 p.attrList = mytags;
238
239 /* Pass the new message to the superclass */
240 object = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)&p);
241 }
242 else
243 object = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
244
245 return object;
246 }
247
248 void METHOD(ATI, Hidd_Gfx, CopyBox)
249 {
250 ULONG mode = GC_DRMD(msg->gc);
251 IPTR src=0, dst=0;
252
253 /* Check whether we can get Drawable attribute of our ATI class */
254 OOP_GetAttr(msg->src, aHidd_ATIBitMap_Drawable, &src);
255 OOP_GetAttr(msg->dest, aHidd_ATIBitMap_Drawable, &dst);
256
257 if (!dst || !src)
258 {
259 /* No. One of the bitmaps is not an ATI bitmap */
260 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
261 }
262 else
263 {
264
265 /* Yes. Get the instance data of both bitmaps */
266 atiBitMap *bm_src = OOP_INST_DATA(OOP_OCLASS(msg->src), msg->src);
267 atiBitMap *bm_dst = OOP_INST_DATA(OOP_OCLASS(msg->dest), msg->dest);
268
269 D(bug("[ATI] CopyBox(src(%p,%d:%d@%d),dst(%p,%d:%d@%d),%d:%d\n",
270 bm_src->framebuffer,msg->srcX,msg->srcY,bm_src->depth,
271 bm_dst->framebuffer,msg->destX,msg->destY,bm_dst->depth,
272 msg->width, msg->height));
273
274 /* Case -1: (To be fixed) one of the bitmaps have chunky outside GFX mem */
275 if (!bm_src->fbgfx || !bm_dst->fbgfx)
276 {
277 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
278 }
279 /* Case 0: one of bitmaps is 8bpp, whereas the other is TrueColor one */
280 else if ((bm_src->depth <= 8 || bm_dst->depth <= 8) &&
281 (bm_src->depth != bm_dst->depth))
282 {
283 /* Unsupported case */
284 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
285 return;
286 }
287 /* Case 1: both bitmaps have the same depth - use Blit engine */
288 else if (bm_src->depth == bm_dst->depth)
289 {
290 int xdir = 0, ydir = 0;
291 WORD xa = msg->srcX;
292 WORD ya = msg->srcY;
293 WORD xb = msg->destX;
294 WORD yb = msg->destY;
295 WORD w = msg->width;
296 WORD h = msg->height;
297
298 if (bm_src->pitch_offset == bm_dst->pitch_offset)
299 {
300 xdir = xa - xb;
301 ydir = ya - yb;
302
303 if (xdir < 0) xa += w - 1, xb += w - 1;
304 if (ydir < 0) ya += h - 1, yb += h - 1;
305 }
306
307 LOCK_MULTI_BITMAP
308 LOCK_BITMAP_BM(bm_src)
309 LOCK_BITMAP_BM(bm_dst)
310 UNLOCK_MULTI_BITMAP
311
312 LOCK_HW
313 sd->Card.Busy = TRUE;
314
315 RADEONWaitForFifo(sd, 2);
316 OUTREG(RADEON_DST_PITCH_OFFSET, bm_dst->pitch_offset);
317 OUTREG(RADEON_SRC_PITCH_OFFSET, bm_src->pitch_offset);
318
319 bm_dst->dp_gui_master_cntl_clip = (bm_dst->dp_gui_master_cntl
320 | RADEON_GMC_BRUSH_NONE
321 | RADEON_GMC_SRC_DATATYPE_COLOR
322 | RADEON_GMC_SRC_PITCH_OFFSET_CNTL
323 | RADEON_ROP[mode].rop
324 | RADEON_DP_SRC_SOURCE_MEMORY);
325
326 RADEONWaitForFifo(sd, 6);
327 OUTREG(RADEON_DP_GUI_MASTER_CNTL, bm_dst->dp_gui_master_cntl_clip);
328 OUTREG(RADEON_DP_WRITE_MASK, ~0);
329 OUTREG(RADEON_DP_CNTL,
330 ((xdir >= 0 ? RADEON_DST_X_LEFT_TO_RIGHT : 0) |
331 (ydir >= 0 ? RADEON_DST_Y_TOP_TO_BOTTOM : 0)));
332
333 OUTREG(RADEON_SRC_Y_X, (ya << 16) | (UWORD)xa);
334 OUTREG(RADEON_DST_Y_X, (yb << 16) | (UWORD)xb);
335 OUTREG(RADEON_DST_HEIGHT_WIDTH, (h << 16) | (UWORD)w);
336
337 UNLOCK_HW
338
339 UNLOCK_BITMAP_BM(bm_src)
340 UNLOCK_BITMAP_BM(bm_dst)
341 }
342 else /* Case 2: different bitmaps. HELP? */
343 {
344 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
345 }
346
347 bm_src->usecount++;
348 bm_dst->usecount++;
349
350
351 }
352 }
353
354 BOOL METHOD(ATI, Hidd_Gfx, SetCursorShape)
355 {
356 D(bug("[ATI] Set cursor shape %08x\n", msg->shape));
357
358 if (msg->shape == NULL)
359 {
360 ShowHideCursor(sd, 0);
361 sd->Card.cursorVisible = 0;
362 }
363 else
364 {
365 IPTR width, height;
366 ULONG x;
367 ULONG save1=0, save2=0;
368
369 volatile ULONG *curimg = (ULONG*)((IPTR)sd->Card.CursorStart + (IPTR)sd->Card.FrameBuffer);
370
371 CURSOR_SWAPPING_DECL_MMIO;
372
373 OOP_GetAttr(msg->shape, aHidd_BitMap_Width, &width);
374 OOP_GetAttr(msg->shape, aHidd_BitMap_Height, &height);
375
376 if (width > 64) width = 64;
377 if (height > 64) height = 64;
378
379 LOCK_HW
380
381 if (!sd->Card.IsSecondary) {
382 save1 = INREG(RADEON_CRTC_GEN_CNTL) & ~(ULONG)(RADEON_CRTC_ARGB_EN|RADEON_CRTC_ARGB_EN);
383 save1 |= RADEON_CRTC_ARGB_EN;
384 OUTREG(RADEON_CRTC_GEN_CNTL, save1 & (ULONG)~RADEON_CRTC_CUR_EN);
385 }
386
387 if (sd->Card.IsSecondary) {
388 save2 = INREG(RADEON_CRTC_GEN_CNTL) & ~(ULONG)(RADEON_CRTC_ARGB_EN|RADEON_CRTC_ARGB_EN);
389 save2 |= RADEON_CRTC_ARGB_EN;
390 OUTREG(RADEON_CRTC2_GEN_CNTL, save2 & (ULONG)~RADEON_CRTC2_CUR_EN);
391 }
392
393 for (x = 0; x < 64*64; x++)
394 curimg[x] = 0;
395
396 /* I always get the image in BGRA32 format (it becomes ARGB32 when picked up as ULONG on little-endian),
397 so i don't turn on byte swapping */
398
399 CURSOR_SWAPPING_START();
400
401 #if AROS_BIG_ENDIAN
402 HIDD_BM_GetImage(msg->shape, (UBYTE *)curimg, 64*4, 0, 0, width, height, vHidd_StdPixFmt_ARGB32);
403 #else
404 HIDD_BM_GetImage(msg->shape, (UBYTE *)curimg, 64*4, 0, 0, width, height, vHidd_StdPixFmt_BGRA32);
405 #endif
406 PRINT_POINTER(curimg, 64, 16, 16);
407
408 CURSOR_SWAPPING_END();
409
410 if (!sd->Card.IsSecondary)
411 OUTREG(RADEON_CRTC_GEN_CNTL, save1);
412
413 if (sd->Card.IsSecondary)
414 OUTREG(RADEON_CRTC2_GEN_CNTL, save2);
415
416 UNLOCK_HW
417 }
418
419 return TRUE;
420 }
421
422 void METHOD(ATI, Hidd_Gfx, SetCursorVisible)
423 {
424 ShowHideCursor(sd, msg->visible);
425 sd->Card.cursorVisible = msg->visible;
426 }
427
428 void METHOD(ATI, Hidd_Gfx, SetCursorPos)
429 {
430 D(bug("[ATI] Set cursor pos %d:%d\n", msg->x, msg->y));
431
432 WORD x,y,xoff=0,yoff=0;
433
434 x = (WORD)msg->x;
435 y = (WORD)msg->y;
436
437 if (x < 0)
438 {
439 xoff = -x;
440 x = 0;
441 }
442
443 if (y < 0)
444 {
445 yoff = -y;
446 y = 0;
447 }
448
449 if (!sd->Card.IsSecondary) {
450 OUTREG(RADEON_CUR_HORZ_VERT_OFF, RADEON_CUR_LOCK | (xoff << 16) | (yoff & 0xffff));
451 OUTREG(RADEON_CUR_HORZ_VERT_POSN, (RADEON_CUR_LOCK
452 | (x << 16)
453 | (y & 0xffff)));
454 OUTREG(RADEON_CUR_OFFSET, sd->Card.CursorStart);
455
456 D(bug("[ATI] OFF=%08x, HV_OFF=%08x, HV_POSN=%08x\n",
457 INREG(RADEON_CUR_OFFSET),
458 INREG(RADEON_CUR_HORZ_VERT_OFF),
459 INREG(RADEON_CUR_HORZ_VERT_POSN)));
460
461 } else {
462 OUTREG(RADEON_CUR2_HORZ_VERT_OFF, RADEON_CUR2_LOCK | (xoff << 16) | (yoff & 0xffff));
463 OUTREG(RADEON_CUR2_HORZ_VERT_POSN, (RADEON_CUR2_LOCK
464 | (x << 16)
465 | (y & 0xffff)));
466 OUTREG(RADEON_CUR2_OFFSET, sd->Card.CursorStart /* + addend???? */);
467 }
468 }
469
470 OOP_Object *METHOD(ATI, Root, New)
471 {
472 struct TagItem pftags_24bpp[] = {
473 { aHidd_PixFmt_RedShift, 8 }, /* 0 */
474 { aHidd_PixFmt_GreenShift, 16 }, /* 1 */
475 { aHidd_PixFmt_BlueShift, 24 }, /* 2 */
476 { aHidd_PixFmt_AlphaShift, 0 }, /* 3 */
477 { aHidd_PixFmt_RedMask, 0x00ff0000 }, /* 4 */
478 { aHidd_PixFmt_GreenMask, 0x0000ff00 }, /* 5 */
479 { aHidd_PixFmt_BlueMask, 0x000000ff }, /* 6 */
480 { aHidd_PixFmt_AlphaMask, 0x00000000 }, /* 7 */
481 { aHidd_PixFmt_ColorModel, vHidd_ColorModel_TrueColor }, /* 8 */
482 { aHidd_PixFmt_Depth, 24 }, /* 9 */
483 { aHidd_PixFmt_BytesPerPixel, 4 }, /* 10 */
484 { aHidd_PixFmt_BitsPerPixel, 24 }, /* 11 */
485 { aHidd_PixFmt_StdPixFmt, vHidd_StdPixFmt_Native }, /* 12 Native */
486 // { aHidd_PixFmt_StdPixFmt, vHidd_StdPixFmt_BGR032 }, /* 12 Native */
487 { aHidd_PixFmt_BitMapType, vHidd_BitMapType_Chunky }, /* 15 */
488 { TAG_DONE, 0UL }
489 };
490
491 struct TagItem pftags_16bpp[] = {
492 { aHidd_PixFmt_RedShift, 16 }, /* 0 */
493 { aHidd_PixFmt_GreenShift, 21 }, /* 1 */
494 { aHidd_PixFmt_BlueShift, 27 }, /* 2 */
495 { aHidd_PixFmt_AlphaShift, 0 }, /* 3 */
496 { aHidd_PixFmt_RedMask, 0x0000f800 }, /* 4 */
497 { aHidd_PixFmt_GreenMask, 0x000007e0 }, /* 5 */
498 { aHidd_PixFmt_BlueMask, 0x0000001f }, /* 6 */
499 { aHidd_PixFmt_AlphaMask, 0x00000000 }, /* 7 */
500 { aHidd_PixFmt_ColorModel, vHidd_ColorModel_TrueColor }, /* 8 */
501 { aHidd_PixFmt_Depth, 16 }, /* 9 */
502 { aHidd_PixFmt_BytesPerPixel, 2 }, /* 10 */
503 { aHidd_PixFmt_BitsPerPixel, 16 }, /* 11 */
504 { aHidd_PixFmt_StdPixFmt, vHidd_StdPixFmt_Native }, /* 12 */
505 // { aHidd_PixFmt_StdPixFmt, vHidd_StdPixFmt_RGB16_LE }, /* 12 */
506 { aHidd_PixFmt_BitMapType, vHidd_BitMapType_Chunky }, /* 15 */
507 { TAG_DONE, 0UL }
508 };
509
510 struct TagItem pftags_15bpp[] = {
511 { aHidd_PixFmt_RedShift, 17 }, /* 0 */
512 { aHidd_PixFmt_GreenShift, 22 }, /* 1 */
513 { aHidd_PixFmt_BlueShift, 27 }, /* 2 */
514 { aHidd_PixFmt_AlphaShift, 0 }, /* 3 */
515 { aHidd_PixFmt_RedMask, 0x00007c00 }, /* 4 */
516 { aHidd_PixFmt_GreenMask, 0x000003e0 }, /* 5 */
517 { aHidd_PixFmt_BlueMask, 0x0000001f }, /* 6 */
518 { aHidd_PixFmt_AlphaMask, 0x00000000 }, /* 7 */
519 { aHidd_PixFmt_ColorModel, vHidd_ColorModel_TrueColor }, /* 8 */
520 { aHidd_PixFmt_Depth, 15 }, /* 9 */
521 { aHidd_PixFmt_BytesPerPixel, 2 }, /* 10 */
522 { aHidd_PixFmt_BitsPerPixel, 15 }, /* 11 */
523 { aHidd_PixFmt_StdPixFmt, vHidd_StdPixFmt_Native }, /* 12 */
524 // { aHidd_PixFmt_StdPixFmt, vHidd_StdPixFmt_RGB15_LE }, /* 12 */
525 { aHidd_PixFmt_BitMapType, vHidd_BitMapType_Chunky }, /* 15 */
526 { TAG_DONE, 0UL }
527 };
528
529 MAKE_SYNC(640x480_60, 25174,
530 640, 656, 752, 800,
531 480, 490, 492, 525,
532 "ATI:640x480");
533
534 MAKE_SYNC(800x600_56, 36000, // 36000
535 800, 824, 896, 1024,
536 600, 601, 603, 625,
537 "ATI:800x600");
538
539 MAKE_SYNC(1024x768_60, 65000, //78654=60kHz, 75Hz. 65000=50kHz,62Hz
540 1024, 1048, 1184, 1344,
541 768, 771, 777, 806,
542 "ATI:1024x768");
543
544 MAKE_SYNC(1152x864_60, 80000,
545 1152, 1216, 1328, 1456,
546 864, 870, 875, 916,
547 "ATI:1152x864");
548
549 MAKE_SYNC(1280x1024_60, 108880,
550 1280, 1360, 1496, 1712,
551 1024, 1025, 1028, 1060,
552 "ATI:1280x1024");
553
554 MAKE_SYNC(1600x1200_60, 155982,
555 1600, 1632, 1792, 2048,
556 1200, 1210, 1218, 1270,
557 "ATI:1600x1200");
558
559 /* "new" 16:10 modes */
560
561 MAKE_SYNC(1280x800_60, 83530,
562 1280, 1344, 1480, 1680,
563 800, 801, 804, 828,
564 "ATI:1280x800");
565
566 MAKE_SYNC(1440x900_60, 106470,
567 1440, 1520, 1672, 1904,
568 900, 901, 904, 932,
569 "ATI:1440x900");
570
571 MAKE_SYNC(1680x1050_60, 147140,
572 1680, 1784, 1968, 2256,
573 1050, 1051, 1054, 1087,
574 "ATI:1680x1050");
575
576 MAKE_SYNC(1920x1080_60, 173000,
577 1920, 2048, 2248, 2576,
578 1080, 1083, 1088, 1120,
579 "ATI:1920x1080");
580
581 MAKE_SYNC(1920x1200_60, 154000,
582 1920, 1968, 2000, 2080,
583 1200, 1203, 1209, 1235,
584 "ATI:1920x1200");
585
586 // MAKE_SYNC(1920x1200_60, 162090,
587 // 1920, 1984, 2176, 2480,
588 // 1200, 1201, 1204, 1250,
589 // "ATI:1920x1200");
590
591 // MAKE_SYNC(1920x1200_60, 193160,
592 // 1920, 2048, 2256, 2592,
593 // 1200, 1201, 1204, 1242,
594 // "ATI:1920x1200");
595
596 struct TagItem modetags[] = {
597 { aHidd_Gfx_PixFmtTags, (IPTR)pftags_24bpp },
598 { aHidd_Gfx_PixFmtTags, (IPTR)pftags_16bpp },
599 { aHidd_Gfx_PixFmtTags, (IPTR)pftags_15bpp },
600 { aHidd_Gfx_SyncTags, (IPTR)sync_1280x1024_60 },
601 { aHidd_Gfx_SyncTags, (IPTR)sync_640x480_60 },
602 { aHidd_Gfx_SyncTags, (IPTR)sync_800x600_56 },
603 { aHidd_Gfx_SyncTags, (IPTR)sync_1024x768_60 },
604 { aHidd_Gfx_SyncTags, (IPTR)sync_1152x864_60 },
605 { aHidd_Gfx_SyncTags, (IPTR)sync_1600x1200_60 },
606 { aHidd_Gfx_SyncTags, (IPTR)sync_1280x800_60 },
607 { aHidd_Gfx_SyncTags, (IPTR)sync_1440x900_60 },
608 { aHidd_Gfx_SyncTags, (IPTR)sync_1680x1050_60 },
609 { aHidd_Gfx_SyncTags, (IPTR)sync_1920x1080_60 },
610 { aHidd_Gfx_SyncTags, (IPTR)sync_1920x1200_60 },
611
612 { TAG_DONE, 0UL }
613 };
614
615 struct TagItem mytags[] = {
616 { aHidd_Gfx_ModeTags, (IPTR)modetags },
617 { TAG_MORE, (IPTR)msg->attrList }
618 };
619
620 struct pRoot_New mymsg;
621
622 mymsg.mID = msg->mID;
623 mymsg.attrList = mytags;
624
625 msg = &mymsg;
626
627 o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
628 if (o)
629 {
630 sd->AtiObject = o;
631 }
632
633 EnterFunc(bug("[ATI] RadeonDriver::New()=%08x\n",o));
634
635 return o;
636 }
637
638 void METHOD(ATI, Root, Get)
639 {
640 ULONG idx;
641 BOOL found = FALSE;
642
643 if (IS_GFX_ATTR(msg->attrID, idx))
644 {
645 switch (idx)
646 {
647 case aoHidd_Gfx_SupportsHWCursor:
648 *msg->storage = (IPTR)TRUE;
649 found = TRUE;
650 break;
651
652 case aoHidd_Gfx_DPMSLevel:
653 *msg->storage = sd->dpms;
654 found = TRUE;
655 break;
656 }
657 }
658
659 if (!found)
660 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
661
662 return;
663 }
664
665 void METHOD(ATI, Root, Set)
666 {
667 ULONG idx;
668 struct TagItem *tag;
669 struct TagItem *tags = msg->attrList;
670
671 while ((tag = NextTagItem(&tags)))
672 {
673 if (IS_GFX_ATTR(tag->ti_Tag, idx))
674 {
675 switch(idx)
676 {
677 case aoHidd_Gfx_DPMSLevel:
678 LOCK_HW
679
680 DPMS(sd, tag->ti_Data);
681 sd->dpms = tag->ti_Data;
682
683 UNLOCK_HW
684 break;
685 }
686 }
687 }
688
689 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
690 }
Mirror of AROS' svn.