?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tools/adflib: build only host variant which is used by Sam440 target
[AROS.git] / arch / m68k-amiga / hidd / uaegfx / uaegfx.c
blobc8be0d18a95928362eb147ef96856b60f71ce15f
1 /*
2 Copyright 1995-2015, The AROS Development Team. All rights reserved.
3 $Id$
4
5 Desc:
6 Lang: English.
7 */
8
9 #include <exec/libraries.h>
10 #include <exec/rawfmt.h>
11 #include <exec/types.h>
12 #include <exec/resident.h>
13 #include <exec/memory.h>
14 #include <graphics/displayinfo.h>
15 #include <intuition/intuitionbase.h>
16 #include <aros/libcall.h>
17 #include <proto/alib.h>
18 #include <proto/exec.h>
19 #include <proto/kernel.h>
20 #include <proto/oop.h>
21 #include <proto/utility.h>
22 #include <oop/oop.h>
23
24 #include <hidd/hidd.h>
25 #include <hidd/graphics.h>
26
27 #include <aros/symbolsets.h>
28
29 #include LC_LIBDEFS_FILE
30
31 #include "uaegfx.h"
32 #include "uaegfxbitmap.h"
33 #include "uaertg.h"
34
35 #define SDEBUG 0
36 #define DEBUG 0
37 #define DRTG(x) x;
38 #include <aros/debug.h>
39
40 #define SIZE_RESLIST 5
41 #define SIZE_PFLIST 19
42 #define SIZE_MODELIST (5 + RGBFB_MaxFormats)
43
44 HIDDT_ModeID *UAEGFXCl__Hidd_Gfx__QueryModeIDs(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_QueryModeIDs *msg)
45 {
46 struct uaegfx_staticdata *csd = CSD(cl);
47 struct RTGMode *node;
48 struct TagItem *tag, *tstate;
49 ULONG minwidth = 0, maxwidth = 0xFFFFFFFF;
50 ULONG minheight = 0, maxheight = 0xFFFFFFFF;
51 OOP_Object **pf = NULL;
52 HIDDT_ModeID *modeids;
53 WORD cnt;
54
55 if (csd->superforward)
56 return (HIDDT_ModeID*)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
57
58 for (tstate = msg->queryTags; (tag = NextTagItem(&tstate)); )
59 {
60 switch (tag->ti_Tag)
61 {
62 case tHidd_GfxMode_MinWidth:
63 minwidth = (ULONG)tag->ti_Tag;
64 break;
65
66 case tHidd_GfxMode_MaxWidth:
67 maxwidth = (ULONG)tag->ti_Tag;
68 break;
69
70 case tHidd_GfxMode_MinHeight:
71 minheight = (ULONG)tag->ti_Tag;
72 break;
73
74 case tHidd_GfxMode_MaxHeight:
75 maxheight = (ULONG)tag->ti_Tag;
76 break;
77
78 case tHidd_GfxMode_PixFmts:
79 pf = (OOP_Object**)tag->ti_Tag;
80 break;
81
82 }
83 }
84 DB2(bug("QueryModeIDs (%dx%d)-(%dx%d) %p\n", minwidth, minheight, maxwidth, maxheight, pf));
85 cnt = 0;
86 ForeachNode(&csd->rtglist, node) {
87 if (node->width >= minwidth && node->width <= maxwidth && node->height >= minheight && node->height <= maxheight) {
88 OOP_Object **pfp = NULL;
89 if (pf) {
90 pfp = pf;
91 while (*pfp) {
92 if (*pfp == node->pf) {
93 pfp = NULL;
94 break;
95 }
96 pfp++;
97 }
98 }
99 if (!pfp)
100 cnt++;
101 }
102 }
103 modeids = AllocVec((cnt + 1) * sizeof(HIDDT_ModeID), MEMF_PUBLIC);
104 if (!modeids)
105 return NULL;
106 cnt = 0;
107 ForeachNode(&csd->rtglist, node) {
108 if (node->width >= minwidth && node->width <= maxwidth && node->height >= minheight && node->height <= maxheight) {
109 OOP_Object **pfp = NULL;
110 if (pf) {
111 pfp = pf;
112 while (*pfp) {
113 if (*pfp == node->pf) {
114 pfp = NULL;
115 break;
116 }
117 pfp++;
118 }
119 }
120 if (!pfp) {
121 DB2(bug("%d: %08x\n", cnt, node->modeid));
122 modeids[cnt++] = node->modeid;
123 }
124 }
125 }
126 modeids[cnt] = vHidd_ModeID_Invalid;
127 return modeids;
128 }
129
130 VOID UAEGFXCl__Hidd_Gfx__ReleaseModeIDs(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_ReleaseModeIDs *msg)
131 {
132 struct uaegfx_staticdata *csd = CSD(cl);
133 if (csd->superforward)
134 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
135 else
136 FreeVec(msg->modeIDs);
137 }
138
139 HIDDT_ModeID UAEGFXCl__Hidd_Gfx__NextModeID(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_NextModeID *msg)
140 {
141 struct uaegfx_staticdata *csd = CSD(cl);
142 struct RTGMode *node = NULL;
143 HIDDT_ModeID mid = vHidd_ModeID_Invalid;
144
145 DB2(bug("NextModeID %08x\n", msg->modeID));
146 if (msg->modeID != vHidd_ModeID_Invalid) {
147 ForeachNode(&csd->rtglist, node) {
148 if (node->modeid == msg->modeID) {
149 node = (struct RTGMode*)node->node.ln_Succ;
150 break;
151 }
152 }
153 }
154 if (!node)
155 node = (struct RTGMode*)csd->rtglist.lh_Head;
156 if (node->node.ln_Succ) {
157 mid = node->modeid;
158 *msg->syncPtr = node->sync;
159 *msg->pixFmtPtr = node->pf;
160 }
161 DB2(bug("=%08x %p %p\n", mid, *msg->syncPtr, *msg->pixFmtPtr));
162 return mid;
163 }
164
165 BOOL UAEGFXCl__Hidd_Gfx__GetMode(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_GetMode *msg)
166 {
167 struct uaegfx_staticdata *csd = CSD(cl);
168 struct RTGMode *node;
169
170 if (csd->superforward)
171 return (BOOL)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
172
173 DB2(bug("GetMode %08x\n", msg->modeID));
174 ForeachNode(&csd->rtglist, node) {
175 if (node->modeid == msg->modeID) {
176 *msg->syncPtr = node->sync;
177 *msg->pixFmtPtr = node->pf;
178 DB2(bug("= %p %p\n", node->sync, node->pf));
179 return TRUE;
180 }
181 }
182 DB2(bug("= FAIL\n"));
183 return FALSE;
184 }
185
186 struct RTGFormat
187 {
188 UWORD rgbformat;
189 ULONG rm, gm, bm, am;
190 UWORD rs, gs, bs, as;
191 BOOL endianswap;
192 };
193
194 static const struct RTGFormat formats[] =
195 {
196 { RGBFB_CLUT, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00000000, 8, 16, 24, 0, FALSE },
197
198 { RGBFB_B8G8R8A8, 0x0000ff00, 0x00ff0000, 0xff000000, 0x000000ff, 16, 8, 0, 24, FALSE },
199 { RGBFB_R8G8B8A8, 0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff, 0, 8, 16, 24, FALSE },
200 { RGBFB_A8B8G8R8, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000, 24, 16, 8, 0, FALSE },
201 { RGBFB_A8R8G8B8, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000, 8, 16, 24, 0, FALSE },
202
203 { RGBFB_B8G8R8, 0x000000ff, 0x0000ff00, 0x00ff0000, 0x00000000, 24, 16, 8, 0, FALSE },
204 { RGBFB_R8G8B8, 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00000000, 8, 16, 24, 0, FALSE },
205
206 { RGBFB_R5G5B5, 0x00007c00, 0x000003e0, 0x0000001f, 0x00000000, 17, 22, 27, 0, FALSE },
207 { RGBFB_R5G6B5, 0x0000f800, 0x000007e0, 0x0000001f, 0x00000000, 16, 21, 27, 0, FALSE },
208
209 { RGBFB_R5G5B5PC, 0x00007c00, 0x000003e0, 0x0000001f, 0x00000000, 17, 22, 27, 0, TRUE },
210 { RGBFB_R5G6B5PC, 0x0000f800, 0x000007e0, 0x0000001f, 0x00000000, 16, 21, 27, 0, TRUE },
211 /*
212 { RGBFB_B5G5R5PC, 0x0000003e, 0x000007c0, 0x0000f800, 0x00000000, 26, 21, 16, 0, TRUE },
213 { RGBFB_B5G6R5PC, 0x0000001f, 0x000007e0, 0x0000f800, 0x00000000, 27, 21, 16, 0, TRUE },
214 */
215 { 0 }
216 };
217
218 static const UBYTE rgbtypelist[] = {
219 RGBFB_CLUT,
220
221 RGBFB_R5G6B5PC,
222 RGBFB_R5G5B5PC,
223 RGBFB_B5G6R5PC,
224 RGBFB_B5G5R5PC,
225 RGBFB_R5G6B5,
226 RGBFB_R5G5B5,
227
228 RGBFB_B8G8R8,
229 RGBFB_R8G8B8,
230
231 RGBFB_B8G8R8A8,
232 RGBFB_A8B8G8R8,
233 RGBFB_A8R8G8B8,
234 RGBFB_R8G8B8A8,
235 0
236 };
237
238 OOP_Object *UAEGFXCl__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
239 {
240 struct uaegfx_staticdata *csd = CSD(cl);
241 struct LibResolution *r;
242 WORD rescnt, i, j, k, l;
243 struct TagItem *reslist, *restags, *pflist, *modetags;
244 struct pRoot_New mymsg;
245 struct TagItem mytags[2];
246 UWORD supportedformats, gotmodes;
247
248 if (csd->initialized)
249 return NULL;
250
251 NEWLIST(&csd->rtglist);
252 NEWLIST(&csd->bitmaplist);
253 InitSemaphore(&csd->HWLock);
254 InitSemaphore(&csd->MultiBMLock);
255
256 supportedformats = gw(csd->boardinfo + PSSO_BoardInfo_RGBFormats);
257 //kprintf("====== SUPPORTED FORMATS: 0x%x\n", supportedformats);
258
259 rescnt = 0;
260 ForeachNode(csd->boardinfo + PSSO_BoardInfo_ResolutionsList, r) {
261 rescnt++;
262 }
263 D(bug("UAEGFX: resolutions: %d, supportmask: %x\n", rescnt, supportedformats));
264
265 reslist = AllocVec(rescnt * SIZE_RESLIST * sizeof(struct TagItem), MEMF_PUBLIC | MEMF_CLEAR);
266 restags = AllocVec((rescnt + 1) * sizeof(struct TagItem), MEMF_PUBLIC | MEMF_CLEAR);
267 pflist = AllocVec(RGBFB_MaxFormats * SIZE_PFLIST * sizeof(struct TagItem), MEMF_PUBLIC | MEMF_CLEAR);
268 modetags = AllocVec(SIZE_MODELIST * sizeof(struct TagItem), MEMF_PUBLIC | MEMF_CLEAR);
269
270 i = 0;
271 ForeachNode(csd->boardinfo + PSSO_BoardInfo_ResolutionsList, r) {
272 reslist[i * SIZE_RESLIST + 0].ti_Tag = aHidd_Sync_HDisp;
273 reslist[i * SIZE_RESLIST + 0].ti_Data = r->Width;
274 reslist[i * SIZE_RESLIST + 1].ti_Tag = aHidd_Sync_VDisp;
275 reslist[i * SIZE_RESLIST + 1].ti_Data = r->Height;
276 reslist[i * SIZE_RESLIST + 2].ti_Tag = aHidd_Sync_Description;
277 reslist[i * SIZE_RESLIST + 2].ti_Data = (IPTR)(csd->CardBase ? "RTGFX:%hx%v" : "UAEGFX:%hx%v");
278 reslist[i * SIZE_RESLIST + 3].ti_Tag = aHidd_Sync_PixelClock;
279 reslist[i * SIZE_RESLIST + 3].ti_Data = r->Modes[CHUNKY]->PixelClock;
280 reslist[i * SIZE_RESLIST + 4].ti_Tag = TAG_DONE;
281 reslist[i * SIZE_RESLIST + 4].ti_Data = 0;
282 D(bug("%08x %d*%d\n", r, r->Width, r->Height));
283 restags[i].ti_Tag = aHidd_Gfx_SyncTags;
284 restags[i].ti_Data = (IPTR)&reslist[i * SIZE_RESLIST];
285 i++;
286 }
287 restags[i].ti_Tag = TAG_DONE;
288 restags[i].ti_Data = 0;
289
290 gotmodes = 0;
291 k = 0;
292 j = 0;
293 for (i = 0; rgbtypelist[i]; i++) {
294 UBYTE rgbtype = rgbtypelist[i];
295 WORD depth = getrtgdepth(1 << rgbtype);
296 if (!((1 << rgbtype) & RGBFB_SUPPORTMASK) || depth == 0 || !((1 << rgbtype) & supportedformats)) {
297 pflist[j].ti_Tag = TAG_DONE;
298 pflist[j].ti_Data = 0;
299 j++;
300 continue;
301 }
302 for (l = 0; formats[l].rgbformat; l++) {
303 if (formats[l].rgbformat == rgbtype)
304 break;
305 }
306 if (formats[l].rgbformat == 0) {
307 pflist[j].ti_Tag = TAG_DONE;
308 pflist[j].ti_Data = 0;
309 j++;
310 continue;
311 }
312 D(bug("RTGFORMAT=%d found. Depth=%d\n", rgbtype, depth));
313
314 if (gotmodes & (1 << (depth / 8))) {
315 D(bug("-> skipped\n"));
316 pflist[j].ti_Tag = TAG_DONE;
317 pflist[j].ti_Data = 0;
318 j++;
319 continue;
320 }
321
322 gotmodes |= 1 << (depth / 8);
323
324 modetags[k].ti_Tag = aHidd_Gfx_PixFmtTags;
325 modetags[k].ti_Data = (IPTR)&pflist[j];
326 k++;
327
328 pflist[j].ti_Tag = aHidd_PixFmt_RedShift;
329 pflist[j].ti_Data = formats[l].rs;
330 j++;
331 pflist[j].ti_Tag = aHidd_PixFmt_GreenShift;
332 pflist[j].ti_Data = formats[l].gs;
333 j++;
334 pflist[j].ti_Tag = aHidd_PixFmt_BlueShift;
335 pflist[j].ti_Data = formats[l].bs;
336 j++;
337 pflist[j].ti_Tag = aHidd_PixFmt_AlphaShift;
338 pflist[j].ti_Data = formats[l].as;
339 j++;
340 pflist[j].ti_Tag = aHidd_PixFmt_RedMask;
341 pflist[j].ti_Data = formats[l].rm;
342 j++;
343 pflist[j].ti_Tag = aHidd_PixFmt_GreenMask;
344 pflist[j].ti_Data = formats[l].gm;
345 j++;
346 pflist[j].ti_Tag = aHidd_PixFmt_BlueMask;
347 pflist[j].ti_Data = formats[l].bm;
348 j++;
349 pflist[j].ti_Tag = aHidd_PixFmt_AlphaMask;
350 pflist[j].ti_Data = formats[l].am;
351 j++;
352 pflist[j].ti_Tag = aHidd_PixFmt_CLUTMask;
353 pflist[j].ti_Data = 0x000000FF;
354 j++;
355 pflist[j].ti_Tag = aHidd_PixFmt_CLUTShift;
356 pflist[j].ti_Data = 0;
357 j++;
358 pflist[j].ti_Tag = aHidd_PixFmt_ColorModel;
359 pflist[j].ti_Data = depth <= 8 ? vHidd_ColorModel_Palette : vHidd_ColorModel_TrueColor;
360 j++;
361 pflist[j].ti_Tag = aHidd_PixFmt_Depth;
362 pflist[j].ti_Data = depth;
363 j++;
364 pflist[j].ti_Tag = aHidd_PixFmt_BytesPerPixel;
365 pflist[j].ti_Data = (depth + 7) / 8;
366 j++;
367 pflist[j].ti_Tag = aHidd_PixFmt_BitsPerPixel;
368 pflist[j].ti_Data = depth;
369 j++;
370 pflist[j].ti_Tag = aHidd_PixFmt_StdPixFmt;
371 pflist[j].ti_Data = vHidd_StdPixFmt_Native;
372 j++;
373 pflist[j].ti_Tag = aHidd_PixFmt_BitMapType;
374 pflist[j].ti_Data = vHidd_BitMapType_Chunky;
375 j++;
376 pflist[j].ti_Tag = aHidd_PixFmt_SwapPixelBytes;
377 pflist[j].ti_Data = formats[l].endianswap;
378 j++;
379 pflist[j].ti_Tag = TAG_DONE;
380 pflist[j].ti_Data = 0;
381 j++;
382 }
383
384 modetags[k].ti_Tag = aHidd_Sync_HMin;
385 modetags[k].ti_Data = 112;
386 k++;
387 modetags[k].ti_Tag = aHidd_Sync_VMin;
388 modetags[k].ti_Data = 112;
389 k++;
390 modetags[k].ti_Tag = aHidd_Sync_HMax;
391 modetags[k].ti_Data = 16384;
392 k++;
393 modetags[k].ti_Tag = aHidd_Sync_VMax;
394 modetags[k].ti_Data = 16384;
395 k++;
396 modetags[k].ti_Tag = TAG_MORE;
397 modetags[k].ti_Data = (IPTR)restags;
398
399 mytags[0].ti_Tag = aHidd_Gfx_ModeTags;
400 mytags[0].ti_Data = (IPTR)modetags;
401 mytags[1].ti_Tag = TAG_MORE;
402 mytags[1].ti_Data = (IPTR)msg->attrList;
403
404 EnterFunc(bug("UAEGFX::New() tags=%x\n", mytags));
405
406 mymsg.mID = msg->mID;
407 mymsg.attrList = mytags;
408 msg = &mymsg;
409
410 /* Register gfxmodes */
411 o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
412 if (NULL != o)
413 {
414 struct gfx_data *data = OOP_INST_DATA(cl, o);
415 HIDDT_ModeID *midp;
416
417 D(bug("UAEGFX::New(): Got object from super\n"));
418 NewList((struct List *)&data->bitmaps);
419 csd->initialized = 1;
420 csd->spritecolors = 16;
421
422 csd->superforward = TRUE;
423 midp = HIDD_Gfx_QueryModeIDs(o, NULL);
424 for (i = 0; midp[i] != vHidd_ModeID_Invalid; i++) {
425 OOP_Object *sync, *pf;
426 HIDDT_ModeID mid = midp[i];
427 IPTR dwidth, dheight;
428 struct RTGMode *node1, *node2;
429 ULONG modeid, rtgmodeid, p96mode;
430
431 if (!HIDD_Gfx_GetMode(o, mid, &sync, &pf))
432 continue;
433 OOP_GetAttr(sync, aHidd_Sync_HDisp, &dwidth);
434 OOP_GetAttr(sync, aHidd_Sync_VDisp, &dheight);
435
436 DB2(bug("w=%d h=%d mode=%08x sync=%x pf=%x\n", dwidth, dheight, mid, sync, pf));
437
438 modeid = vHidd_ModeID_Invalid;
439 ForeachNode(csd->boardinfo + PSSO_BoardInfo_ResolutionsList, r) {
440 if (r->Width == dwidth && r->Height == dheight) {
441 modeid = r->DisplayID;
442 break;
443 }
444 }
445 if (modeid == vHidd_ModeID_Invalid) {
446 D(bug("w=%d h=%d not found!\n", dwidth, dheight));
447 continue;
448 }
449
450 p96mode = getrtgformat(csd, pf);
451 rtgmodeid = (modeid & 0x00ff0000) | 0x1000 | (p96mode << 8);
452
453 ForeachNode(&csd->rtglist, node2) {
454 if (node2->width == dwidth && node2->height == dheight && node2->modeid == rtgmodeid)
455 break;
456 }
457 if (node2->node.ln_Succ != NULL) {
458 D(bug("w=%d h=%d mode=%08x already found!\n", dwidth, dheight, rtgmodeid));
459 continue;
460 }
461
462 node1 = AllocMem(sizeof(struct RTGMode), MEMF_CLEAR);
463 node1->width = dwidth;
464 node1->height = dheight;
465 node1->pf = pf;
466 node1->sync = sync;
467 node1->modeid = rtgmodeid;
468 AddTail(&csd->rtglist, &node1->node);
469
470 DB2(bug("Added %dx%d %08x %d\n", node1->width, node1->height, node1->modeid, p96mode));
471 }
472 HIDD_Gfx_ReleaseModeIDs(o, midp);
473 csd->superforward = FALSE;
474
475 }
476
477 FreeVec(restags);
478 FreeVec(reslist);
479 FreeVec(pflist);
480 FreeVec(modetags);
481
482 ReturnPtr("UAEGFX::New", OOP_Object *, o);
483 }
484
485 /********** GfxHidd::Dispose() ******************************/
486 OOP_Object *UAEGFXCl__Hidd_Gfx__CreateObject(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_CreateObject *msg)
487 {
488 OOP_Object *object = NULL;
489
490 EnterFunc(bug("UAEGFX::CreateObject()\n"));
491
492 if (msg->cl == CSD(cl)->basebm)
493 {
494 struct uaegfx_staticdata *csd = CSD(cl);
495 HIDDT_ModeID modeid;
496 struct pHidd_Gfx_CreateObject p;
497 struct TagItem tags[] =
498 {
499 { TAG_IGNORE, TAG_IGNORE }, /* Placeholder for aHidd_BitMap_ClassPtr */
500 { TAG_MORE, (IPTR)msg->attrList }
501 };
502
503 modeid = (HIDDT_ModeID)GetTagData(aHidd_BitMap_ModeID, vHidd_ModeID_Invalid, msg->attrList);
504 if (modeid != vHidd_ModeID_Invalid) {
505 tags[0].ti_Tag = aHidd_BitMap_ClassPtr;
506 tags[0].ti_Data = (IPTR)CSD(cl)->bmclass;
507 }
508 p.mID = msg->mID;
509 p.cl = msg->cl;
510 p.attrList = tags;
511
512 object = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)&p);
513 }
514 else
515 object = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
516
517 ReturnPtr("UAEGFX::CreateObject", OOP_Object *, object);
518 }
519
520 VOID UAEGFXCl__Root__Get(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
521 {
522 struct uaegfx_staticdata *csd = CSD(cl);
523 ULONG idx;
524
525 //bug("UAEGFXCl__Root__Get %x\n", msg->attrID);
526
527 if (IS_GFX_ATTR(msg->attrID, idx))
528 {
529 //bug("=%x\n", idx);
530 switch (idx)
531 {
532 case aoHidd_Gfx_HWSpriteTypes:
533 *msg->storage = csd->hardwaresprite ? vHidd_SpriteType_3Plus1 : 0;
534 return;
535 case aoHidd_Gfx_SupportsHWCursor:
536 *msg->storage = csd->hardwaresprite;
537 return;
538 case aoHidd_Gfx_NoFrameBuffer:
539 *msg->storage = TRUE;
540 return;
541 case aoHidd_Gfx_IsWindowed:
542 *msg->storage = FALSE;
543 return;
544 case aoHidd_Gfx_DriverName:
545 *msg->storage = (IPTR)"UAEGFX";
546 return;
547 }
548 }
549 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
550 }
551
552 VOID UAEGFXCl__Root__Set(OOP_Class *cl, OOP_Object *obj, struct pRoot_Set *msg)
553 {
554 struct uaegfx_staticdata *csd = CSD(cl);
555 struct TagItem *tag, *tstate;
556
557 tstate = msg->attrList;
558 while((tag = NextTagItem(&tstate)))
559 {
560 ULONG idx;
561 D(bug("UAEGFXCl__Root__Set %x\n", tag->ti_Tag));
562 if (IS_GFX_ATTR(tag->ti_Tag, idx)) {
563 D(bug("->%d\n", idx));
564 switch(idx)
565 {
566 case aoHidd_Gfx_ActiveCallBack:
567 csd->acb = (void *)tag->ti_Data;
568 break;
569
570 case aoHidd_Gfx_ActiveCallBackData:
571 csd->acbdata = (APTR)tag->ti_Data;
572 break;
573 }
574 }
575 }
576 OOP_DoSuperMethod(cl, obj, (OOP_Msg)msg);
577 }
578 #if 0
579 ULONG UAEGFXCl__Hidd_Gfx__MakeViewPort(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_MakeViewPort *msg)
580 {
581 struct uaegfx_staticdata *csd = CSD(cl);
582
583 csd->vpe = NULL;
584 if (!msg)
585 return MVP_OK;
586 bug("makeviewport %p\n", msg->Data->vpe);
587 csd->vpe = msg->Data->vpe;
588 return MVP_OK;
589 }
590
591 void UAEGFXCl__Hidd_Gfx__CleanViewPort(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_CleanViewPort *msg)
592 {
593 struct uaegfx_staticdata *csd = CSD(cl);
594
595 csd->vpe = NULL;
596 bug("cleanviewport\n");
597 }
598 #endif
599
600 static void doshow(struct uaegfx_staticdata *csd, OOP_Object *bm, struct ViewPort *vp, BOOL offonly)
601 {
602 struct IntuitionBase *ib = (struct IntuitionBase*)csd->cs_IntuitionBase;
603 struct ViewPort *vpi = NULL;
604
605 if (ib->FirstScreen)
606 vpi = &ib->FirstScreen->ViewPort;
607
608 D(bug("doshow b=%p vp=%p vpi=%p acb=%p acbd=%p\n", bm, vp, vpi, csd->acb, csd->acbdata));
609
610 if (bm && vpi == vp) {
611 /* we are topmost screen -> show our display */
612 IPTR tags[] = {aHidd_BitMap_Visible, TRUE, TAG_DONE};
613
614 if (offonly)
615 return;
616
617 OOP_SetAttrs(bm, (struct TagItem *)tags);
618
619 if (csd->acb)
620 csd->acb(csd->acbdata, NULL);
621
622 } else if (bm) {
623 /* we are not topmost -> turn off our display */
624 IPTR tags[] = {aHidd_BitMap_Visible, FALSE, TAG_DONE};
625 OOP_SetAttrs(bm, (struct TagItem *)tags);
626 } else {
627
628 LOCK_HW
629
630 /* no display */
631 SetDisplay(csd, FALSE);
632 SetSwitch(csd, FALSE);
633
634 UNLOCK_HW
635 }
636 }
637
638 OOP_Object *UAEGFXCl__Hidd_Gfx__Show(OOP_Class *cl, OOP_Object *c, struct pHidd_Gfx_Show *msg)
639 {
640 struct uaegfx_staticdata *csd = CSD(cl);
641
642 doshow(csd, msg->bitMap, csd->viewport, FALSE);
643 return msg->bitMap;
644 }
645
646 ULONG UAEGFXCl__Hidd_Gfx__PrepareViewPorts(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_ShowViewPorts *msg)
647 {
648 struct uaegfx_staticdata *csd = CSD(cl);
649 struct HIDD_ViewPortData *vpd = msg->Data;
650 OOP_Object *bm = NULL;
651 struct ViewPort *vp = NULL;
652
653 if (vpd) {
654 bm = vpd->Bitmap;
655 if (vpd->vpe)
656 vp = vpd->vpe->ViewPort;
657 }
658 csd->viewport = vp;
659 doshow(csd, bm, vp, FALSE);
660
661 bug("PrepareViewPorts viewport=%p\n", csd->viewport);
662 return MCOP_OK;
663 }
664
665 ULONG UAEGFXCl__Hidd_Gfx__ShowViewPorts(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_ShowViewPorts *msg)
666 {
667 struct uaegfx_staticdata *csd = CSD(cl);
668 struct HIDD_ViewPortData *vpd = msg->Data;
669 OOP_Object *bm = NULL;
670 struct ViewPort *vp = NULL;
671
672 if (vpd) {
673 bm = vpd->Bitmap;
674 if (vpd->vpe)
675 vp = vpd->vpe->ViewPort;
676 }
677 doshow(csd, bm, vp, FALSE);
678 return TRUE;
679 }
680
681 VOID UAEGFXCl__Hidd_Gfx__CopyBox(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_CopyBox *msg)
682 {
683 struct uaegfx_staticdata *csd = CSD(cl);
684 HIDDT_DrawMode mode = GC_DRMD(msg->gc);
685 struct bm_data *sdata = NULL;
686 struct bm_data *ddata = NULL;
687 struct RenderInfo risrc, ridst;
688
689 if (OOP_OCLASS(msg->src) == csd->bmclass) sdata = OOP_INST_DATA(OOP_OCLASS(msg->src), msg->src);
690 if (OOP_OCLASS(msg->dest) == csd->bmclass) ddata = OOP_INST_DATA(OOP_OCLASS(msg->dest), msg->dest);
691
692 if (!sdata || !ddata)
693 {
694 //kprintf("==== copybox: unknown bitmap %p %p drawmode %d\n", sdata, ddata, mode);
695 //if (!sdata) kprintf(" src: %s\n", OOP_OCLASS(msg->src)->ClassNode.ln_Name ? OOP_OCLASS(msg->src)->ClassNode.ln_Name : "unknown");
696 //if (!ddata) kprintf(" dst: %s\n", OOP_OCLASS(msg->dest)->ClassNode.ln_Name ? OOP_OCLASS(msg->dest)->ClassNode.ln_Name : "unknown");
697
698 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
699 return;
700 }
701
702 if (sdata->rgbformat != ddata->rgbformat) {
703 //kprintf("==== ocpybox: format mismatch %d %d drawmode %d\n", sdata->rgbformat, ddata->rgbformat, mode);
704 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
705 return;
706 }
707
708 LOCK_MULTI_BITMAP
709 LOCK_BITMAP(sdata)
710 LOCK_BITMAP(ddata)
711 UNLOCK_MULTI_BITMAP
712
713 LOCK_HW
714 WaitBlitter(csd);
715 UNLOCK_HW
716
717 if (!sdata->invram || !ddata->invram)
718 {
719 /* Blit from VRAM to RAM or from RAM to VRAM */
720
721 #if 0
722 kprintf("== VRAM <-> RAM blit bpp %d\n", sdata->bytesperpixel);
723 kprintf("%p to %p %d,%d -> %d,%d %d x %d modulo %d %d\n",
724 sdata->VideoData, ddata->VideoData,
725 msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height,
726 sdata->bytesperline,
727 ddata->bytesperline);
728 #endif
729
730 if (mode == vHidd_GC_DrawMode_Copy)
731 {
732 switch(sdata->bytesperpixel)
733 {
734 case 1:
735 HIDD_BM_CopyMemBox8(msg->dest,
736 sdata->VideoData,
737 msg->srcX,
738 msg->srcY,
739 ddata->VideoData,
740 msg->destX,
741 msg->destY,
742 msg->width,
743 msg->height,
744 sdata->bytesperline,
745 ddata->bytesperline);
746 break;
747
748 case 2:
749 HIDD_BM_CopyMemBox16(msg->dest,
750 sdata->VideoData,
751 msg->srcX,
752 msg->srcY,
753 ddata->VideoData,
754 msg->destX,
755 msg->destY,
756 msg->width,
757 msg->height,
758 sdata->bytesperline,
759 ddata->bytesperline);
760 break;
761
762 case 3:
763 HIDD_BM_CopyMemBox24(msg->dest,
764 sdata->VideoData,
765 msg->srcX,
766 msg->srcY,
767 ddata->VideoData,
768 msg->destX,
769 msg->destY,
770 msg->width,
771 msg->height,
772 sdata->bytesperline,
773 ddata->bytesperline);
774 break;
775
776 case 4:
777 HIDD_BM_CopyMemBox32(msg->dest,
778 sdata->VideoData,
779 msg->srcX,
780 msg->srcY,
781 ddata->VideoData,
782 msg->destX,
783 msg->destY,
784 msg->width,
785 msg->height,
786 sdata->bytesperline,
787 ddata->bytesperline);
788 break;
789
790 } /* switch(data->bytesperpix) */
791
792 } /* if (mode == vHidd_GC_DrawMode_Copy) */
793 else
794 {
795 //if (mode == vHidd_GC_DrawMode_Clear) kprintf(" clear blit %d x %d done by superclass\n", msg->width, msg->height);
796 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
797 }
798 } /* if (!sdata->invram || !ddata->invram) */
799 else
800 {
801 //if (mode == vHidd_GC_DrawMode_Clear) kprintf(" clear blit %d x %d done by me\n", msg->width, msg->height);
802
803 makerenderinfo(csd, &risrc, sdata);
804 makerenderinfo(csd, &ridst, ddata);
805
806 LOCK_HW
807
808 if (!BlitRectNoMaskComplete(csd, &risrc, &ridst,
809 msg->srcX, msg->srcY, msg->destX, msg->destY,
810 msg->width, msg->height, modetable[mode], sdata->rgbformat))
811 {
812 //kprintf("== unhandled blit %d x %d drawmode %d. super must help\n", msg->width, msg->height, mode);
813 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
814 }
815
816 UNLOCK_HW
817 }
818
819 UNLOCK_BITMAP(sdata)
820 UNLOCK_BITMAP(ddata)
821
822 }
823
824 BOOL UAEGFXCl__Hidd_Gfx__CopyBoxMasked(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_CopyBoxMasked *msg)
825 {
826 struct uaegfx_staticdata *csd = CSD(cl);
827
828 LOCK_HW
829 WaitBlitter(csd);
830 UNLOCK_HW
831
832 return OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
833 }
834
835 BOOL UAEGFXCl__Hidd_Gfx__SetCursorShape(OOP_Class *cl, OOP_Object *shape, struct pHidd_Gfx_SetCursorShape *msg)
836 {
837 struct uaegfx_staticdata *csd = CSD(cl);
838 OOP_Object *cm = NULL;
839 IPTR width, height;
840 WORD x, y, hiressprite, i;
841 UWORD *p;
842 ULONG flags;
843
844 OOP_GetAttr(msg->shape, aHidd_BitMap_Width, &width);
845 OOP_GetAttr(msg->shape, aHidd_BitMap_Height, &height);
846 OOP_GetAttr(msg->shape, aHidd_BitMap_ColorMap, (IPTR*)&cm);
847
848 LOCK_HW
849
850 if (cm) {
851 for (i = 0; i < 3; i++) {
852 HIDDT_Color c;
853 HIDD_CM_GetColor(cm, i + 1, &c);
854 SetSpriteColor(csd, i, c.red, c.green, c.blue);
855 }
856 }
857 Forbid();
858 pb(csd->boardinfo + PSSO_BoardInfo_MouseXOffset, msg->xoffset);
859 pb(csd->boardinfo + PSSO_BoardInfo_MouseYOffset, msg->yoffset);
860 p = (UWORD*)gp(csd->boardinfo + PSSO_BoardInfo_MouseImage);
861 if (p == NULL || width != csd->sprite_width || height != csd->sprite_height) {
862 FreeVec(p);
863 p = AllocVec(4 + 4 + ((width + 15) & ~15) / 8 * height * 2, MEMF_CLEAR | MEMF_PUBLIC);
864 pp(csd->boardinfo + PSSO_BoardInfo_MouseImage, p);
865 if (!p) {
866 Permit();
867
868 UNLOCK_HW
869 return FALSE;
870 }
871 csd->sprite_width = width;
872 csd->sprite_height = height;
873 }
874
875 flags = gl(csd->boardinfo + PSSO_BoardInfo_Flags);
876 flags &= ~(1 << BIB_HIRESSPRITE);
877 hiressprite = 1;
878 if (width > 16) {
879 flags |= 1 << BIB_HIRESSPRITE;
880 hiressprite = 2;
881 }
882 pl(csd->boardinfo + PSSO_BoardInfo_Flags, flags);
883
884 pb(csd->boardinfo + PSSO_BoardInfo_MouseWidth, width / hiressprite);
885 pb(csd->boardinfo + PSSO_BoardInfo_MouseHeight, height);
886
887 p += 2 * hiressprite;
888 for(y = 0; y < height; y++) {
889 UWORD pix1 = 0, pix2 = 0, xcnt = 0;
890 for(x = 0; x < width; x++) {
891 UBYTE c = HIDD_BM_GetPixel(msg->shape, x, y);
892 pix1 <<= 1;
893 pix2 <<= 1;
894 pix1 |= (c & 1) ? 1 : 0;
895 pix2 |= (c & 2) ? 1 : 0;
896 xcnt++;
897 if (xcnt == 15) {
898 xcnt = 0;
899 p[x / 16] = pix1;
900 p[width / 16 + x / 16] = pix2;
901 }
902 }
903 p += (width / 16) * 2;
904 }
905 Permit();
906 SetSpriteImage(csd);
907
908 UNLOCK_HW
909
910 return TRUE;
911 }
912
913 BOOL UAEGFXCl__Hidd_Gfx__SetCursorPos(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_SetCursorPos *msg)
914 {
915 struct uaegfx_staticdata *csd = CSD(cl);
916
917 LOCK_HW
918 pw(csd->boardinfo + PSSO_BoardInfo_MouseX, msg->x + (BYTE)csd->boardinfo[PSSO_BoardInfo_MouseXOffset]);
919 pw(csd->boardinfo + PSSO_BoardInfo_MouseY, msg->y + (BYTE)csd->boardinfo[PSSO_BoardInfo_MouseYOffset]);
920 SetSpritePosition(csd);
921 UNLOCK_HW
922
923 return TRUE;
924 }
925 VOID UAEGFXCl__Hidd_Gfx__SetCursorVisible(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_SetCursorVisible *msg)
926 {
927 struct uaegfx_staticdata *csd = CSD(cl);
928
929 LOCK_HW
930 SetSprite(csd, msg->visible);
931 UNLOCK_HW
932 }
933
934 BOOL UAEGFXCl__Hidd_Gfx__CheckMode(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_CheckMode *msg)
935 {
936 struct uaegfx_staticdata *csd = CSD(cl);
937 IPTR width, height, bpp;
938
939 OOP_GetAttr(msg->sync, aHidd_Sync_HDisp, &width);
940 OOP_GetAttr(msg->sync, aHidd_Sync_VDisp, &height);
941 OOP_GetAttr(msg->pixFmt, aHidd_PixFmt_BytesPerPixel, &bpp);
942 if (width > csd->maxwidth[bpp])
943 return FALSE;
944 if (height > csd->maxheight[bpp])
945 return FALSE;
946 return width * height * bpp < csd->vram_size;
947 }
948
949
950 static void freeattrbases(LIBBASETYPEPTR LIBBASE, struct uaegfx_staticdata *csd)
951 {
952 OOP_ReleaseAttrBase(IID_Hidd_BitMap);
953 OOP_ReleaseAttrBase(IID_Hidd_UAEGFXBitMap);
954 OOP_ReleaseAttrBase(IID_Hidd_GC);
955 OOP_ReleaseAttrBase(IID_Hidd_Sync);
956 OOP_ReleaseAttrBase(IID_Hidd_Gfx);
957 OOP_ReleaseAttrBase(IID_Hidd_PixFmt);
958 OOP_ReleaseAttrBase(IID_Hidd_ColorMap);
959 }
960
961 AROS_INTP(rtg_vblank);
962
963 struct P96RTGmode
964 {
965 UWORD w, h, id;
966 ULONG clock;
967 UWORD htotal, vtotal;
968 UWORD hborder, vborder;
969 UWORD hpos, vpos;
970 UWORD hsync, vsync;
971 UBYTE flags;
972 };
973
974 static const struct P96RTGmode rtgmodes[] =
975 {
976 { 320, 240, 1, 13020000, 408, 262, 0, 0, 32, 5, 24, 1, GMF_HPOLARITY | GMF_VPOLARITY | GMF_DOUBLESCAN },
977 { 640, 480, 3, 25060000, 800, 525, 0, 0, 40, 11, 88, 2, GMF_HPOLARITY | GMF_VPOLARITY },
978 { 800, 600, 4, 32010000, 1024, 625, 0, 0, 56, 1, 40, 2, 0 },
979 { 1024, 768, 5, 64430000, 1336, 800, 0, 0, 48, 4, 112, 5, GMF_HPOLARITY | GMF_VPOLARITY },
980 { 1152, 900, 6, 85010000, 1496, 973, 0, 0, 48, 5, 40, 4, GMF_HPOLARITY | GMF_VPOLARITY },
981 { 1440, 900, 7, 106360000, 1904, 932, 0, 0, 80, 0, 0, 10, GMF_HPOLARITY | GMF_VPOLARITY },
982 { 0 }
983 };
984 /* real RTG only */
985 static BOOL PopulateModeInfo(struct uaegfx_staticdata *csd, struct LibResolution *res, const struct P96RTGmode *mode)
986 {
987 UWORD rgbformat;
988 BOOL ok = FALSE;
989
990 for (rgbformat = 0; rgbformat < RGBFB_MaxFormats; rgbformat++) {
991 ULONG clockindex;
992 UBYTE depth, index;
993 struct ModeInfo *mi;
994 UWORD maxhval, maxvval, maxhres, maxvres;
995
996 if (!((1 << rgbformat) & RGBFB_SUPPORTMASK))
997 continue;
998 if (!((1 << rgbformat) & gw(csd->boardinfo + PSSO_BoardInfo_RGBFormats)))
999 continue;
1000 depth = getrtgdepth(1 << rgbformat);
1001 index = (depth + 7) / 8;
1002 if (res->Modes[index])
1003 continue;
1004
1005 maxhval = gw(csd->boardinfo + PSSO_BoardInfo_MaxHorValue + index * 2);
1006 maxvval = gw(csd->boardinfo + PSSO_BoardInfo_MaxVerValue + index * 2);
1007 maxhres = gw(csd->boardinfo + PSSO_BoardInfo_MaxHorResolution + index * 2);
1008 maxvres = gw(csd->boardinfo + PSSO_BoardInfo_MaxVerResolution + index * 2);
1009
1010 if (mode->htotal > maxhval || mode->vtotal > maxvval ||
1011 mode->w > maxhres || mode->h > maxvres)
1012 continue;
1013
1014 mi = AllocMem(sizeof(struct ModeInfo), MEMF_CLEAR | MEMF_PUBLIC);
1015 if (!mi)
1016 continue;
1017 mi->OpenCount = 1;
1018 mi->Active = TRUE;
1019 mi->Width = mode->w;
1020 mi->Height = mode->h;
1021 mi->Depth = depth;
1022 mi->HorTotal = mode->htotal;
1023 mi->VerTotal = mode->vtotal;
1024 mi->HorBlankSize = mode->hborder;
1025 mi->VerBlankSize = mode->vborder;
1026 mi->HorSyncStart = mode->hpos;
1027 mi->VerSyncStart = mode->vpos;
1028 mi->HorSyncSize = mode->hsync;
1029 mi->VerSyncSize = mode->vsync;
1030 mi->Flags = mode->flags;
1031 clockindex = ResolvePixelClock(csd, mi, mode->clock, rgbformat);
1032 mi->PixelClock = GetPixelClock(csd, mi, clockindex, rgbformat);
1033 DRTG(bug("%d,%p: %dx%dx%d ci=%d clk=%d (%d/%d)\n",
1034 index, mi, mi->Width, mi->Height, mi->Depth,
1035 clockindex, mi->PixelClock, mi->Numerator, mi->Denominator));
1036 res->Modes[index] = mi;
1037 ok = TRUE;
1038 }
1039 return ok;
1040 }
1041 static void PopulateResolutionList(struct uaegfx_staticdata *csd)
1042 {
1043 struct LibResolution *node;
1044 UWORD cnt;
1045
1046 NEWLIST((csd->boardinfo + PSSO_BoardInfo_ResolutionsList));
1047 for (cnt = 0; rtgmodes[cnt].clock; cnt++) {
1048 const struct P96RTGmode *mode = &rtgmodes[cnt];
1049 node = AllocMem(sizeof(struct LibResolution), MEMF_CLEAR | MEMF_PUBLIC);
1050 if (!node)
1051 break;
1052 node->Width = mode->w;
1053 node->Height = mode->h;
1054 node->DisplayID = 0x50001000 | (mode->id << 16);
1055 node->BoardInfo = csd->boardinfo;
1056 if (PopulateModeInfo(csd, node, mode))
1057 AddTail((struct List*)(csd->boardinfo + PSSO_BoardInfo_ResolutionsList), (struct Node*)node);
1058 else
1059 FreeMem(node, sizeof(struct LibResolution));
1060 }
1061 }
1062
1063 static int openall(struct uaegfx_staticdata *csd)
1064 {
1065 if ((csd->cs_UtilityBase = TaggedOpenLibrary(TAGGEDOPEN_UTILITY))) {
1066 if ((csd->cs_IntuitionBase = TaggedOpenLibrary(TAGGEDOPEN_INTUITION))) {
1067 return TRUE;
1068 }
1069 }
1070 return FALSE;
1071 }
1072 static void freeall(struct uaegfx_staticdata *csd)
1073 {
1074 CloseLibrary(csd->cs_IntuitionBase);
1075 CloseLibrary(csd->cs_UtilityBase);
1076 FreeMem(csd->vmem, sizeof(struct MemHeader));
1077 csd->vmem = NULL;
1078 FreeVec(csd->boardinfo);
1079 csd->boardinfo = NULL;
1080 }
1081
1082 static void P96DebugInfo(struct uaegfx_staticdata *csd)
1083 {
1084 UBYTE i;
1085 DRTG(bug("Name:'%s'\n",
1086 gl(csd->boardinfo + PSSO_BoardInfo_BoardName)));
1087 DRTG(bug("Reg:%08x IO:%08x\n",
1088 gl(csd->boardinfo + PSSO_BoardInfo_RegisterBase),
1089 gl(csd->boardinfo + PSSO_BoardInfo_MemoryIOBase)));
1090 DRTG(bug("BoardType:%d GCType:%d PCType:%d BPC:%d Flags:%08x\n",
1091 gl(csd->boardinfo + PSSO_BoardInfo_BoardType),
1092 gl(csd->boardinfo + PSSO_BoardInfo_GraphicsControllerType),
1093 gl(csd->boardinfo + PSSO_BoardInfo_PaletteChipType),
1094 gw(csd->boardinfo + PSSO_BoardInfo_BitsPerCannon),
1095 gl(csd->boardinfo + PSSO_BoardInfo_Flags)));
1096 for (i = 0; i < MAXMODES; i++) {
1097 DRTG(bug("%d: HV:%4d VV: %4d HR:%4d VR:%4d C:%d\n", i,
1098 gw(csd->boardinfo + PSSO_BoardInfo_MaxHorValue + i * 2),
1099 gw(csd->boardinfo + PSSO_BoardInfo_MaxVerValue + i * 2),
1100 gw(csd->boardinfo + PSSO_BoardInfo_MaxHorResolution + i * 2),
1101 gw(csd->boardinfo + PSSO_BoardInfo_MaxVerResolution + i * 2),
1102 gl(csd->boardinfo + PSSO_BoardInfo_PixelClockCount + i * 4)));
1103 }
1104 }
1105
1106 static BOOL P96Init(struct uaegfx_staticdata *csd, struct Library *lib)
1107 {
1108 DRTG(bug("P96GFX: attempting to init '%s'\n", lib->lib_Node.ln_Name));
1109 pl(csd->boardinfo + PSSO_BoardInfo_CardBase, (ULONG)lib);
1110 csd->CardBase = lib;
1111 InitRTG(csd->boardinfo);
1112 if (FindCard(csd)) {
1113 DRTG(bug("P96GFX: FindCard succeeded\n"));
1114 if (InitCard(csd)) {
1115 DRTG(bug("P96GFX: InitCard succeeded\n"));
1116 SetInterrupt(csd, FALSE);
1117 /* Without this card may not be in linear memory map mode. */
1118 SetMemoryMode(csd, RGBFB_CLUT);
1119 P96DebugInfo(csd);
1120 return TRUE;
1121 }
1122 }
1123 pl(csd->boardinfo + PSSO_BoardInfo_CardBase, 0);
1124 csd->CardBase = NULL;
1125 return FALSE;
1126 }
1127
1128
1129 BOOL Init_UAEGFXClass(LIBBASETYPEPTR LIBBASE)
1130 {
1131 struct uaegfx_staticdata *csd = &LIBBASE->csd;
1132 struct MemChunk *mc;
1133 UBYTE i;
1134 struct Interrupt *intr;
1135 struct Node *node;
1136
1137 if (!(SysBase->AttnFlags & AFF_68020))
1138 return FALSE;
1139
1140 D(bug("Init_UAEGFXClass\n"));
1141 if (!openall(csd)) {
1142 freeall(csd);
1143 return FALSE;
1144 }
1145
1146 csd->boardinfo = AllocVec(PSSO_BoardInfo_SizeOf + PSSO_BitMapExtra_Last + sizeof(struct ModeInfo), MEMF_CLEAR | MEMF_PUBLIC);
1147 if (!csd->boardinfo) {
1148 freeall(csd);
1149 return FALSE;
1150 }
1151 NEWLIST((struct List*)(csd->boardinfo + PSSO_BoardInfo_ResolutionsList));
1152 NEWLIST((struct List*)(csd->boardinfo + PSSO_BoardInfo_BitMapList));
1153 NEWLIST((struct List*)(csd->boardinfo + PSSO_BoardInfo_MemList));
1154 NEWLIST((struct List*)(csd->boardinfo + PSSO_BoardInfo_WaitQ));
1155 csd->bitmapextra = csd->boardinfo + PSSO_BoardInfo_SizeOf;
1156 csd->fakemodeinfo = (struct ModeInfo*)(csd->boardinfo + PSSO_BoardInfo_SizeOf + PSSO_BitMapExtra_Last);
1157 pl(csd->boardinfo + PSSO_BoardInfo_BitMapExtra, (ULONG)csd->bitmapextra);
1158 pl(csd->boardinfo + PSSO_BoardInfo_ExecBase, (ULONG)SysBase);
1159 pl(csd->boardinfo + PSSO_BoardInfo_UtilBase, (ULONG)csd->cs_UtilityBase);
1160 InitSemaphore((struct SignalSemaphore*)(csd->boardinfo + PSSO_BoardInfo_BoardLock));
1161 intr = (struct Interrupt*)(csd->boardinfo + PSSO_BoardInfo_HardInterrupt);
1162 intr->is_Code = (APTR)rtg_vblank;
1163 intr->is_Data = csd->boardinfo;
1164 intr->is_Node.ln_Name = "RTG VBlank";
1165 intr->is_Node.ln_Pri = 0;
1166 intr->is_Node.ln_Type = NT_INTERRUPT;
1167 intr = (struct Interrupt*)(csd->boardinfo + PSSO_BoardInfo_SoftInterrupt);
1168 intr->is_Code = (APTR)rtg_vblank;
1169 intr->is_Data = csd->boardinfo;
1170 intr->is_Node.ln_Name = "RTG VBlank";
1171 intr->is_Node.ln_Pri = 0;
1172 intr->is_Node.ln_Type = NT_INTERRUPT;
1173
1174 Forbid();
1175 ForeachNode(&SysBase->LibList.lh_Head, node) {
1176 struct Library *lib = (struct Library*)node;
1177 char *name = node->ln_Name;
1178 int len = strlen(name);
1179 if (len > 5 && !stricmp(name + len - 5, ".card")) {
1180 BOOL ret;
1181 Permit();
1182 ret = P96Init(csd, lib);
1183 Forbid();
1184 if (ret)
1185 break;
1186 DRTG(bug("P96GFX: init failed\n"));
1187 }
1188 }
1189 Permit();
1190
1191 if (!csd->CardBase) {
1192 csd->uaeromvector = (APTR)(0xf00000 + 0xff60);
1193 if ((gl(csd->uaeromvector) & 0xff00ffff) != 0xa0004e75) {
1194 D(bug("UAE boot ROM entry point not found. UAEGFX not enabled.\n"));
1195 freeall(csd);
1196 return FALSE;
1197 }
1198 if (!FindCard(csd)) {
1199 D(bug("UAEGFX: FindCard() returned false\n"));
1200 freeall(csd);
1201 return FALSE;
1202 }
1203 D(bug("UAEGFX: FindCard done\n"));
1204 InitCard(csd);
1205 csd->hardwaresprite = (gl(csd->boardinfo + PSSO_BoardInfo_Flags) & (1 << BIB_HARDWARESPRITE)) && SetSprite(csd, FALSE);
1206 } else {
1207 PopulateResolutionList(csd);
1208 csd->hardwaresprite = gl(csd->boardinfo + PSSO_BoardInfo_Flags) & (1 << BIB_HARDWARESPRITE);
1209 }
1210
1211 if (IsListEmpty((struct List*)(csd->boardinfo + PSSO_BoardInfo_ResolutionsList))) {
1212 D(bug("Resolutionlist is empty, init failed.\n"));
1213 freeall(csd);
1214 return FALSE;
1215 }
1216 for (i = 0; i < MAXMODES; i++) {
1217 csd->maxwidth[i] = gw(csd->boardinfo + PSSO_BoardInfo_MaxHorResolution + i * 2);
1218 csd->maxheight[i] = gw(csd->boardinfo + PSSO_BoardInfo_MaxVerResolution + i * 2);
1219 }
1220
1221 D(bug("InitCard done\n"));
1222
1223 DRTG(bug("hardware sprite: %d\n", csd->hardwaresprite));
1224
1225 csd->vram_start = (UBYTE*)gl(csd->boardinfo + PSSO_BoardInfo_MemoryBase);
1226
1227
1228 #if 1
1229 csd->vram_size = gl(csd->boardinfo + PSSO_BoardInfo_MemorySize);
1230 #else
1231 /* REMOVEME: 4MB hack (used for easier debug of vram <-> ram swapping) !!!!*/
1232 csd->vram_size = 4 * 1024 * 1024; /* gl(csd->boardinfo + PSSO_BoardInfo_MemorySize); */
1233 /* REMOVEME: 4MB Hack (used for easier debug of vram <-> ram swapping) !!!!*/
1234 #endif
1235
1236 DRTG(bug("P96RTG VRAM found at %08x size %08x\n", csd->vram_start, csd->vram_size));
1237 mc = (struct MemChunk*)csd->vram_start;
1238 csd->vmem = AllocVec(sizeof(struct MemHeader), MEMF_CLEAR | MEMF_PUBLIC);
1239 csd->vmem->mh_Node.ln_Type = NT_MEMORY;
1240 csd->vmem->mh_First = mc;
1241 csd->vmem->mh_Lower = (APTR)mc;
1242 csd->vmem->mh_Upper = (APTR)((ULONG)mc + csd->vram_size);
1243 csd->vmem->mh_Free = csd->vram_size;
1244 mc->mc_Next = NULL;
1245 mc->mc_Bytes = csd->vmem->mh_Free;
1246
1247 __IHidd_BitMap = OOP_ObtainAttrBase(IID_Hidd_BitMap);
1248 __IHidd_UAEGFXBitmap= OOP_ObtainAttrBase(IID_Hidd_UAEGFXBitMap);
1249 __IHidd_GC = OOP_ObtainAttrBase(IID_Hidd_GC);
1250 __IHidd_Sync = OOP_ObtainAttrBase(IID_Hidd_Sync);
1251 __IHidd_Gfx = OOP_ObtainAttrBase(IID_Hidd_Gfx);
1252 __IHidd_PixFmt = OOP_ObtainAttrBase(IID_Hidd_PixFmt);
1253 __IHidd_ColorMap = OOP_ObtainAttrBase(IID_Hidd_ColorMap);
1254
1255 HiddBitMapBase = OOP_GetMethodID(IID_Hidd_BitMap, 0);
1256 HiddColorMapBase = OOP_GetMethodID(IID_Hidd_ColorMap, 0);
1257 HiddGfxBase = OOP_GetMethodID(IID_Hidd_Gfx, 0);
1258
1259 if (!__IHidd_BitMap || !__IHidd_UAEGFXBitmap || !__IHidd_GC ||
1260 !__IHidd_Sync || !__IHidd_Gfx || !__IHidd_PixFmt || !__IHidd_ColorMap)
1261 {
1262 D(bug("Init_UAEGFXClass fail\n"));
1263 freeattrbases(LIBBASE, csd);
1264 freeall(csd);
1265 return FALSE;
1266 }
1267
1268 DRTG(bug("P96RTG done\n"));
1269 return TRUE;
1270 }
1271
1272 static int Expunge_UAEGFXClass(LIBBASETYPEPTR LIBBASE)
1273 {
1274 struct uaegfx_staticdata *csd = &LIBBASE->csd;
1275 D(bug("Expunge_UAEGFXClass\n"));
1276 freeattrbases(LIBBASE, csd);
1277 freeall(csd);
1278 return TRUE;
1279 }
1280
1281 ADD2EXPUNGELIB(Expunge_UAEGFXClass, 1)
1282
1283 #undef SysBase
1284
1285 AROS_INTH1(rtg_vblank, APTR, boardinfo)
1286 {
1287 AROS_INTFUNC_INIT
1288
1289 return 0;
1290
1291 AROS_INTFUNC_EXIT
1292
1293 }
1294
Mirror of AROS' svn.