?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
add place-holder directory for the a3000 wd533c93 scsi controller implementation.
[AROS.git] / workbench / hidds / vmwaresvga / vmwaresvga_hiddclass.c
blob553ae6b67f799dd1a9ae44d94b7aa9112ade6bd6
1 /*
2 Copyright © 1995-2019, The AROS Development Team. All rights reserved.
3 $Id$
4
5 Desc: Class for VMWare.
6 Lang: English.
7 */
8
9 #ifdef DEBUG
10 #undef DEBUG
11 #endif
12 #define DEBUG 0
13 #include <aros/debug.h>
14
15 #define __OOP_NOATTRBASES__
16
17 #include <proto/exec.h>
18 #include <proto/kernel.h>
19 #include <proto/oop.h>
20 #include <proto/utility.h>
21
22 #include <aros/symbolsets.h>
23 #include <devices/inputevent.h>
24 #include <exec/alerts.h>
25 #include <exec/memory.h>
26 #include <hardware/custom.h>
27 #include <hidd/hidd.h>
28 #include <hidd/gfx.h>
29 #include <oop/oop.h>
30 #include <clib/alib_protos.h>
31
32 #include <asm/io.h>
33
34 #include <string.h>
35 #include <stdio.h>
36
37 #include "vmwaresvga_intern.h"
38
39 #include LC_LIBDEFS_FILE
40
41 #if (DEBUG)
42 #define DINFO(x) x
43 #else
44 #define DINFO(x)
45 #endif
46
47 static OOP_AttrBase HiddAttrBase;
48 static OOP_AttrBase HiddBitMapAttrBase;
49 static OOP_AttrBase HiddPixFmtAttrBase;
50 static OOP_AttrBase HiddGfxAttrBase;
51 static OOP_AttrBase HiddSyncAttrBase;
52 static OOP_AttrBase HiddVMWareSVGAAttrBase;
53 static OOP_AttrBase HiddVMWareSVGABitMapAttrBase;
54
55 static struct OOP_ABDescr attrbases[] =
56 {
57 {IID_Hidd, &HiddAttrBase },
58 {IID_Hidd_BitMap, &HiddBitMapAttrBase },
59 {IID_Hidd_VMWareSVGABitMap, &HiddVMWareSVGABitMapAttrBase },
60 {IID_Hidd_VMWareSVGA, &HiddVMWareSVGAAttrBase },
61 {IID_Hidd_PixFmt, &HiddPixFmtAttrBase },
62 {IID_Hidd_Sync, &HiddSyncAttrBase },
63 {IID_Hidd_Gfx, &HiddGfxAttrBase },
64 {NULL, NULL }
65 };
66
67 static ULONG mask_to_shift(ULONG mask)
68 {
69 ULONG i;
70
71 for (i = 32; mask; i --) {
72 mask >>= 1;
73 }
74
75 if (mask == 32) {
76 i = 0;
77 }
78
79 return i;
80 }
81
82 static ULONG VMWareSVGA__GetDefSyncSizes(ULONG syncno, ULONG *syncwid, ULONG *synchi)
83 {
84 #define VMWARESVGA_DEFSYNCMAX 12
85 switch (syncno % VMWARESVGA_DEFSYNCMAX)
86 {
87 case 1:
88 *syncwid = 800;
89 *synchi = 600;
90 break;
91 case 2:
92 *syncwid = 1024;
93 *synchi = 768;
94 break;
95 case 3:
96 *syncwid = 1280;
97 *synchi = 1024;
98 break;
99 case 4:
100 *syncwid = 1366;
101 *synchi = 768;
102 break;
103 case 5:
104 *syncwid = 1440;
105 *synchi = 900;
106 break;
107 case 6:
108 *syncwid = 1600;
109 *synchi = 1200;
110 break;
111 case 7:
112 *syncwid = 1680;
113 *synchi = 1050;
114 break;
115 case 8:
116 *syncwid = 1920;
117 *synchi = 1080;
118 break;
119 case 9:
120 *syncwid = 1920;
121 *synchi = 1200;
122 break;
123 case 10:
124 *syncwid = 2560;
125 *synchi = 1600;
126 break;
127 case 11:
128 *syncwid = 3840;
129 *synchi = 2160;
130 break;
131 default:
132 *syncwid = 640;
133 *synchi = 480;
134 break;
135 }
136 return (syncno % VMWARESVGA_DEFSYNCMAX);
137 }
138
139 OOP_Object *VMWareSVGA__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
140 {
141 struct TagItem pftags[] =
142 {
143 {aHidd_PixFmt_RedShift, 0 }, /* 0 */
144 {aHidd_PixFmt_GreenShift, 0 }, /* 1 */
145 {aHidd_PixFmt_BlueShift, 0 }, /* 2 */
146 {aHidd_PixFmt_AlphaShift, 0 }, /* 3 */
147 {aHidd_PixFmt_RedMask, 0 }, /* 4 */
148 {aHidd_PixFmt_GreenMask, 0 }, /* 5 */
149 {aHidd_PixFmt_BlueMask, 0 }, /* 6 */
150 {aHidd_PixFmt_AlphaMask, 0 }, /* 7 */
151 {aHidd_PixFmt_ColorModel, 0 }, /* 8 */
152 {aHidd_PixFmt_Depth, 0 }, /* 9 */
153 {aHidd_PixFmt_BytesPerPixel, 0 }, /* 10 */
154 {aHidd_PixFmt_BitsPerPixel, 0 }, /* 11 */
155 {aHidd_PixFmt_StdPixFmt, 0 }, /* 12 */
156 {aHidd_PixFmt_CLUTShift, 0 }, /* 13 */
157 {aHidd_PixFmt_CLUTMask, 0x0f }, /* 14 */
158 {aHidd_PixFmt_BitMapType, 0 }, /* 15 */
159 {TAG_DONE, 0UL }
160 };
161 struct TagItem *modetags;
162 ULONG max_width, max_height;
163 ULONG sync_Width, sync_Height;
164 ULONG sync_count, sync_modes, sync_curr, sync_actual, sync_displayid, sync_modeid;
165
166 XSD(cl)->prefWidth = vmwareReadReg(&XSD(cl)->data, SVGA_REG_WIDTH);
167 XSD(cl)->prefHeight = vmwareReadReg(&XSD(cl)->data, SVGA_REG_HEIGHT);
168 DINFO(bug("[VMWareSVGA] %s: Default %dx%d\n", __func__, XSD(cl)->prefWidth, XSD(cl)->prefHeight));
169
170 max_width = vmwareReadReg(&XSD(cl)->data, SVGA_REG_MAX_WIDTH);
171 max_height = vmwareReadReg(&XSD(cl)->data, SVGA_REG_MAX_HEIGHT);
172 DINFO(bug("[VMWareSVGA] %s: Max %dx%d\n", __func__, max_width, max_height));
173
174 DINFO(bug("[VMWareSVGA] %s: counting usable modes ...\n", __func__);)
175 /* Determine the number of sync modes we will expose (per display if applicable) */
176 sync_count = VMWARESVGA_DEFSYNCMAX;
177 sync_modes = 0;
178 while (sync_count > 0)
179 {
180 sync_count = VMWareSVGA__GetDefSyncSizes(sync_count - 1, &sync_Width, &sync_Height) + 1;
181 DINFO(bug("[VMWareSVGA] %s: #%d ... %dx%d ", __func__, (VMWARESVGA_DEFSYNCMAX - sync_count) + 1, sync_Width, sync_Height);)
182 if ((sync_Width <= max_width) && (sync_Height <= max_height))
183 {
184 DINFO(bug("is suitable");)
185 sync_modes += 1;
186 }
187 sync_count -= 1;
188 DINFO(bug("\n");)
189 }
190 DINFO(bug("[VMWareSVGA] %s: %d usable modes found\n", __func__, sync_modes);)
191 sync_count = sync_modes;
192 #if defined(VMWARESVGA_USEMULTIMON)
193 sync_count *= XSD(cl)->data.displaycount;
194 #endif
195 sync_curr = 1;
196 #if defined(VMWARESVGA_USE8BIT)
197 if ((data->capabilities & SVGA_CAP_8BIT_EMULATION) && (XSD(cl)->data.depth > 8))
198 sync_curr += 1;
199 #endif
200 modetags = AllocVec((sync_count + sync_curr + 1) * sizeof(struct TagItem), MEMF_CLEAR);
201 modetags[0].ti_Tag = aHidd_Gfx_PixFmtTags;
202 modetags[0].ti_Data = (IPTR)pftags;
203 #if defined(VMWARESVGA_USE8BIT)
204 if ((data->capabilities & SVGA_CAP_8BIT_EMULATION) && (XSD(cl)->data.depth > 8))
205 {
206 }
207 #endif
208
209 sync_curr = 0;
210 while (sync_curr < sync_count)
211 {
212 char *sync_Description = AllocVec(SYNC_DESCNAME_LEN, MEMF_CLEAR);
213 struct TagItem *sync_mode = AllocVec(11 * sizeof(struct TagItem), MEMF_CLEAR);
214
215 sync_modeid = VMWareSVGA__GetDefSyncSizes(sync_curr, &sync_Width, &sync_Height);
216 sync_displayid = sync_curr/sync_modes;
217
218 DINFO(bug("[VMWareSVGA] %s: Setting Sync Mode %d for Display %d\n", __func__, sync_modeid, sync_displayid));
219
220 if (sync_displayid == 0)
221 {
222 sprintf(sync_Description, "VMWareSVGA:%dx%d", sync_Width, sync_Height);
223 }
224 else
225 {
226 sprintf(sync_Description, "VMWareSVGA.%d:%dx%d", sync_displayid, sync_Width, sync_Height);
227 }
228 DINFO(bug("[VMWareSVGA] %s: Description '%s'\n", __func__, sync_Description));
229
230 sync_mode[0].ti_Tag = aHidd_Sync_Description;
231 sync_mode[0].ti_Data = (IPTR)sync_Description;
232
233 sync_mode[1].ti_Tag = aHidd_Sync_PixelClock;
234
235 sync_mode[2].ti_Tag = aHidd_Sync_HDisp;
236 sync_mode[2].ti_Data = sync_Width;
237
238 sync_mode[3].ti_Tag = aHidd_Sync_VDisp;
239 sync_mode[3].ti_Data = sync_Height;
240
241 sync_mode[4].ti_Tag = aHidd_Sync_HSyncStart;
242
243 sync_mode[5].ti_Tag = aHidd_Sync_HSyncEnd;
244
245 sync_mode[6].ti_Tag = aHidd_Sync_HTotal;
246
247 sync_mode[7].ti_Tag = aHidd_Sync_VSyncStart;
248
249 sync_mode[8].ti_Tag = aHidd_Sync_VSyncEnd;
250
251 sync_mode[9].ti_Tag = aHidd_Sync_VTotal;
252
253 sync_mode[10].ti_Tag = TAG_DONE;
254
255 modetags[1 + sync_curr].ti_Tag = aHidd_Gfx_SyncTags;
256 modetags[1 + sync_curr].ti_Data = (IPTR)sync_mode;
257 sync_curr++;
258 }
259 modetags[1 + sync_curr].ti_Tag = TAG_DONE;
260
261 struct TagItem svganewtags[] =
262 {
263 {aHidd_Gfx_ModeTags, (IPTR)modetags },
264 { aHidd_Name , (IPTR)"VMWareSVGA" },
265 { aHidd_HardwareName , (IPTR)"VMWare SVGA Gfx Adaptor" },
266 { aHidd_ProducerName , (IPTR)"VMWare Inc" },
267 {TAG_MORE, (IPTR)msg->attrList }
268 };
269 struct pRoot_New svganewmsg;
270
271 /* set pftags = 0 */
272 if (!XSD(cl)->data.pseudocolor)
273 {
274 pftags[0].ti_Data = mask_to_shift(XSD(cl)->data.redmask);
275 pftags[1].ti_Data = mask_to_shift(XSD(cl)->data.greenmask);
276 pftags[2].ti_Data = mask_to_shift(XSD(cl)->data.bluemask);
277 }
278 else
279 {
280 pftags[0].ti_Data = 0;
281 pftags[1].ti_Data = 0;
282 pftags[2].ti_Data = 0;
283 }
284 pftags[3].ti_Data = 0;
285 pftags[4].ti_Data = XSD(cl)->data.redmask;
286 pftags[5].ti_Data = XSD(cl)->data.greenmask;
287 pftags[6].ti_Data = XSD(cl)->data.bluemask;
288 pftags[7].ti_Data = 0;
289 DINFO(bug("[VMWareSVGA] New: Masks red=%08x<<%d,green=%08x<<%d,blue%08x<<%d\n",
290 pftags[4].ti_Data, pftags[0].ti_Data,
291 pftags[5].ti_Data, pftags[1].ti_Data,
292 pftags[6].ti_Data, pftags[2].ti_Data));
293
294 if (XSD(cl)->data.pseudocolor)
295 pftags[8].ti_Data = vHidd_ColorModel_Palette;
296 else
297 pftags[8].ti_Data = vHidd_ColorModel_TrueColor;
298
299 pftags[9].ti_Data = XSD(cl)->data.depth;
300 pftags[10].ti_Data = XSD(cl)->data.bytesperpixel;
301 pftags[11].ti_Data = XSD(cl)->data.bitsperpixel;
302 pftags[12].ti_Data = vHidd_StdPixFmt_Native;
303 pftags[15].ti_Data = vHidd_BitMapType_Chunky;
304 #if defined(VMWARESVGA_USE8BIT)
305 if ((data->capabilities & SVGA_CAP_8BIT_EMULATION) && (XSD(cl)->data.depth > 8))
306 {
307 }
308 #endif
309
310 svganewmsg.mID = msg->mID;
311 svganewmsg.attrList = svganewtags;
312 msg = &svganewmsg;
313 EnterFunc(bug("[VMWareSVGA] New()\n"));
314 o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
315 if (o)
316 {
317 DINFO(bug("[VMWareSVGA] %s: object @ 0x%p\n", __func__, o);)
318
319 XSD(cl)->vmwaresvgahidd = o;
320 XSD(cl)->mouse.shape = NULL;
321 DINFO(
322 bug("[VMWareSVGA] %s: Device capabilities: %08x\n", __func__, XSD(cl)->data.capabilities);
323 )
324 if (XSD(cl)->data.capabilities & SVGA_CAP_IRQMASK)
325 {
326 UWORD port = (UWORD)((IPTR)XSD(cl)->data.iobase + SVGA_IRQSTATUS_PORT);
327 DINFO(bug("[VMWareSVGA] %s: IRQ Mask\n", __func__);)
328 vmwareWriteReg(&XSD(cl)->data, SVGA_REG_IRQMASK, 0);
329 outl(0xFF, port);
330
331 DINFO(bug("[VMWareSVGA] %s: - Registering handler for IRQ #%d\n", __func__, XSD(cl)->data.hwint);)
332 XSD(cl)->data.irq = KrnAddIRQHandler(XSD(cl)->data.hwint, vmwareHandlerIRQ, &XSD(cl)->data, NULL);
333 vmwareWriteReg(&XSD(cl)->data, SVGA_REG_IRQMASK, SVGA_IRQFLAG_ERROR);
334 }
335 DINFO(
336 if (XSD(cl)->data.capabilities & SVGA_CAP_EXTENDED_FIFO)
337 bug("[VMWareSVGA] %s: Extended FIFO\n", __func__);
338 if (XSD(cl)->data.capabilities & SVGA_CAP_ALPHA_CURSOR)
339 bug("[VMWareSVGA] %s: Alpha Cursor\n", __func__);
340 if (XSD(cl)->data.capabilities & SVGA_CAP_CURSOR_BYPASS)
341 bug("[VMWareSVGA] %s: Cursor-Bypass\n", __func__);
342 if (XSD(cl)->data.capabilities & SVGA_CAP_CURSOR_BYPASS_2)
343 bug("[VMWareSVGA] %s: Cursor-Bypass2\n", __func__);
344 if (XSD(cl)->data.capabilities & SVGA_CAP_8BIT_EMULATION)
345 bug("[VMWareSVGA] %s: 8bit-emu\n", __func__);
346 if (XSD(cl)->data.capabilities & SVGA_CAP_3D)
347 bug("[VMWareSVGA] %s: 3D.\n", __func__);
348 if (XSD(cl)->data.capabilities & SVGA_CAP_MULTIMON)
349 bug("[VMWareSVGA] %s: Multimon\n", __func__);
350 )
351 if (XSD(cl)->data.capabilities & SVGA_CAP_DISPLAY_TOPOLOGY)
352 {
353 DINFO(bug("[VMWareSVGA] %s: Display Topology\n", __func__);)
354 vmwareWriteReg(&XSD(cl)->data, SVGA_REG_NUM_GUEST_DISPLAYS, 1);
355 }
356 DINFO(
357 if (XSD(cl)->data.capabilities & SVGA_CAP_PITCHLOCK)
358 bug("[VMWareSVGA] %s: Pitchlock\n", __func__);
359 if (XSD(cl)->data.capabilities & SVGA_CAP_GMR)
360 bug("[VMWareSVGA] %s: GMR\n", __func__);
361 if (XSD(cl)->data.capabilities & SVGA_CAP_GMR2)
362 bug("[VMWareSVGA] %s: GMR2\n", __func__);
363 if (XSD(cl)->data.capabilities & SVGA_CAP_TRACES)
364 bug("[VMWareSVGA] %s: Traces\n", __func__);
365 if (XSD(cl)->data.capabilities & SVGA_CAP_SCREEN_OBJECT_2)
366 bug("[VMWareSVGA] %s: Screen-Object2\n", __func__);
367 )
368 DINFO(
369 if (XSD(cl)->data.capabilities & SVGA_CAP_RECT_COPY)
370 bug("[VMWareSVGA] %s: Copy Rect\n", __func__);
371 if (XSD(cl)->data.capabilities & SVGA_CAP_RECT_FILL)
372 bug("[VMWareSVGA] %s: Fill Rect\n", __func__);
373 if (XSD(cl)->data.capabilities & SVGA_CAP_OFFSCREEN_1)
374 bug("[VMWareSVGA] %s: BitMap/Pixmap\n", __func__);
375 if (XSD(cl)->data.capabilities & SVGA_CAP_RECT_PAT_FILL)
376 bug("[VMWareSVGA] %s: Pattern Fill\n", __func__);
377 if ((XSD(cl)->data.capabilities & (SVGA_CAP_RECT_FILL|SVGA_CAP_RASTER_OP)) == (SVGA_CAP_RECT_FILL|SVGA_CAP_RASTER_OP))
378 bug("[VMWareSVGA] %s: ROp Fill\n", __func__);
379 if ((XSD(cl)->data.capabilities & (SVGA_CAP_RECT_COPY|SVGA_CAP_RASTER_OP)) == (SVGA_CAP_RECT_COPY|SVGA_CAP_RASTER_OP))
380 bug("[VMWareSVGA] %s: ROp Copy\n", __func__);
381 if ((XSD(cl)->data.capabilities & (SVGA_CAP_RECT_PAT_FILL|SVGA_CAP_RASTER_OP)) == (SVGA_CAP_RECT_PAT_FILL|SVGA_CAP_RASTER_OP))
382 bug("[VMWareSVGA] %s: ROp Pattern Fill\n", __func__);
383 if (XSD(cl)->data.capabilities & SVGA_CAP_GLYPH)
384 bug("[VMWareSVGA] %s: Glyph\n", __func__);
385 if (XSD(cl)->data.capabilities & SVGA_CAP_GLYPH_CLIPPING)
386 bug("[VMWareSVGA] %s: Glyph Clipping\n", __func__);
387 )
388 #if (0)
389 /* Set the ID so vmware knows we are here */
390 vmwareWriteReg(&XSD(cl)->data, SVGA_REG_GUEST_ID, 0x09);
391 #endif
392 }
393
394 D(bug("[VMWareSVGA] %s: returning 0x%p\n", __func__, o);)
395
396 return o;
397 }
398
399 VOID VMWareSVGA__Root__Dispose(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
400 {
401 FreeVec(XSD(cl)->mouse.shape);
402 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
403 }
404
405 VOID VMWareSVGA__Root__Get(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
406 {
407 ULONG idx;
408 BOOL found = FALSE;
409
410 if (IS_GFX_ATTR(msg->attrID, idx))
411 {
412 switch (idx)
413 {
414 case aoHidd_Gfx_SupportsHWCursor:
415 {
416 found = TRUE;
417 if (XSD(cl)->data.capabilities & SVGA_CAP_CURSOR)
418 {
419 DINFO(bug("[VMWareSVGA] %s: HW Cursor\n", __func__);)
420 *msg->storage = (IPTR)TRUE;
421 }
422 else
423 *msg->storage = (IPTR)FALSE;
424 }
425 break;
426
427 case aoHidd_Gfx_SupportsGamma:
428 *msg->storage = (IPTR)TRUE;
429 found = TRUE;
430 break;
431
432 case aoHidd_Gfx_MemoryAttribs:
433 {
434 struct TagItem *matstate = (struct TagItem *)msg->storage;
435 found = TRUE;
436 if (matstate)
437 {
438 struct TagItem *matag;
439 while ((matag = NextTagItem(&matstate)))
440 {
441 switch(matag->ti_Tag)
442 {
443 case tHidd_Gfx_MemTotal:
444 case tHidd_Gfx_MemAddressableTotal:
445 matag->ti_Data = (IPTR)vmwareReadReg(&XSD(cl)->data, SVGA_REG_VRAM_SIZE);
446 DINFO(bug("[VMWareSVGA] %s: Mem Size = %ld\n", __func__, matag->ti_Data);)
447 break;
448 case tHidd_Gfx_MemFree:
449 case tHidd_Gfx_MemAddressableFree:
450 matag->ti_Data = 0;
451 break;
452 }
453 }
454 }
455 }
456 break;
457 }
458 }
459 if (!found)
460 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
461 }
462
463 OOP_Object *VMWareSVGA__Hidd_Gfx__CreateObject(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_CreateObject *msg)
464 {
465 OOP_Object *object = NULL;
466
467 D(bug("[VMWareSVGA] %s()\n", __func__);)
468
469 if (msg->cl == XSD(cl)->basebm)
470 {
471 BOOL displayable;
472 BOOL framebuffer;
473 OOP_Class *classptr = NULL;
474 struct TagItem tags[] =
475 {
476 { TAG_IGNORE, TAG_IGNORE }, /* Placeholder for aHidd_BitMap_ClassPtr */
477 { TAG_MORE, (IPTR)msg->attrList }
478 };
479
480 struct pHidd_Gfx_CreateObject comsg;
481
482 displayable = GetTagData(aHidd_BitMap_Displayable, FALSE, msg->attrList);
483 framebuffer = GetTagData(aHidd_BitMap_FrameBuffer, FALSE, msg->attrList);
484 if (framebuffer)
485 classptr = XSD(cl)->vmwaresvgaonbmclass;
486 else if (displayable)
487 classptr = XSD(cl)->vmwaresvgaoffbmclass;
488 else
489 {
490 HIDDT_ModeID modeid;
491 modeid = (HIDDT_ModeID)GetTagData(aHidd_BitMap_ModeID, vHidd_ModeID_Invalid, msg->attrList);
492 if (modeid != vHidd_ModeID_Invalid)
493 classptr = XSD(cl)->vmwaresvgaoffbmclass;
494 else
495 {
496 HIDDT_StdPixFmt stdpf;
497 stdpf = (HIDDT_StdPixFmt)GetTagData(aHidd_BitMap_StdPixFmt, vHidd_StdPixFmt_Unknown, msg->attrList);
498 if (stdpf == vHidd_StdPixFmt_Unknown)
499 {
500 OOP_Object *friend;
501 friend = (OOP_Object *)GetTagData(aHidd_BitMap_Friend, (IPTR)NULL, msg->attrList);
502 if (friend != NULL)
503 {
504 OOP_Class *friend_class = NULL;
505 OOP_GetAttr(friend, aHidd_BitMap_ClassPtr, (IPTR *)&friend_class);
506 if (friend_class == XSD(cl)->vmwaresvgaonbmclass)
507 {
508 classptr = XSD(cl)->vmwaresvgaoffbmclass;
509 }
510 }
511 }
512 }
513 }
514 if (classptr != NULL)
515 {
516 tags[0].ti_Tag = aHidd_BitMap_ClassPtr;
517 tags[0].ti_Data = (IPTR)classptr;
518 }
519 comsg.mID = msg->mID;
520 comsg.cl = msg->cl;
521 comsg.attrList = tags;
522
523 object = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)&comsg);
524 }
525 else if ((XSD(cl)->basegallium && (msg->cl == XSD(cl)->basegallium)) &&
526 (XSD(cl)->data.capabilities & SVGA_CAP_3D))
527 {
528 /* Create the gallium 3d driver object .. */
529 object = OOP_NewObject(NULL, CLID_Hidd_Gallium_VMWareSVGA, msg->attrList);
530 }
531 else
532 object = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
533
534 D(bug("[VMWareSVGA] %s: returning 0x%p\n", __func__, object);)
535 return object;
536 }
537
538 ULONG VMWareSVGA__Hidd_Gfx__ShowViewPorts(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_ShowViewPorts *msg)
539 {
540 IPTR width = 0, bm_width, height = 0, bm_height;
541 struct HIDD_ViewPortData *currVPD;
542
543 D(bug("[VMWareSVGA] %s()\n", __func__);)
544
545 #if defined(VMWAREGFX_UPDATEFBONSHOWVP)
546 if ((currVPD = msg->Data) != 0)
547 {
548 if ((XSD(cl)->data.shown) && (XSD(cl)->mouse.visible))
549 {
550 D(bug("[VMWareSVGA] %s: removing cursor...\n", __func__);)
551 displayCursorVMWareSVGA(&XSD(cl)->data, SVGA_CURSOR_ON_HIDE);
552 }
553
554 XSD(cl)->data.shown = currVPD;
555 D(bug("[VMWareSVGA] %s: shown = 0x%p\n", __func__, XSD(cl)->data.shown));
556
557 while ((currVPD) && (currVPD->Bitmap))
558 {
559 OOP_GetAttr(currVPD->Bitmap, aHidd_BitMap_Width, (IPTR *)&bm_width);
560 if (bm_width > width)
561 width = bm_width;
562 OOP_GetAttr(currVPD->Bitmap, aHidd_BitMap_Height, (IPTR *)&bm_height);
563 if (bm_height > height)
564 height = bm_height;
565 currVPD = currVPD->Next;
566 }
567 D(bug("[VMWareSVGA] %s: %dx%d\n", __func__, width, height));
568
569 if (width == 0)
570 width = XSD(cl)->prefWidth;
571 if (height == 0)
572 height = XSD(cl)->prefHeight;
573
574 setModeVMWareSVGA(&XSD(cl)->data, width, height);
575 syncfenceVMWareSVGAFIFO(&XSD(cl)->data, fenceVMWareSVGAFIFO(&XSD(cl)->data));
576 if (XSD(cl)->mouse.visible)
577 {
578 D(bug("[VMWareSVGA] %s: displaying cursor...\n", __func__);)
579 defineCursorVMWareSVGA(&XSD(cl)->data, &XSD(cl)->mouse);
580 moveCursorVMWareSVGA(&XSD(cl)->data, XSD(cl)->mouse.x, XSD(cl)->mouse.y);
581 displayCursorVMWareSVGA(&XSD(cl)->data, SVGA_CURSOR_ON_SHOW);
582 }
583 }
584 else
585 {
586 D(bug("[VMWareSVGA] %s: nothing to show ...\n", __func__);)
587 }
588 #endif
589 return OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
590 }
591
592 BOOL VMWareSVGA__Hidd_Gfx__SetGamma(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_Gamma *msg)
593 {
594 D(bug("[VMWareSVGA] %s()\n", __func__);)
595 #if (0)
596 int i;
597 for (i = 0; i < 256; i++) {
598 D(bug("[VMWareSVGA] %s: #%d 0x%04x:0x%04x:0x%04x\n", __func__, i, msg->Red[i], msg->Green[i], msg->Blue[i]);)
599 vmwareWriteReg(&XSD(cl)->data, SVGA_PALETTE_BASE + i * 3 + 0, msg->Red[i] >> 8);
600 vmwareWriteReg(&XSD(cl)->data, SVGA_PALETTE_BASE + i * 3 + 1, msg->Green[i] >> 8);
601 vmwareWriteReg(&XSD(cl)->data, SVGA_PALETTE_BASE + i * 3 + 2, msg->Blue[i] >> 8);
602 }
603 #endif
604 return TRUE;
605 }
606
607 VOID VMWareSVGA__Hidd_Gfx__CopyBox(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_CopyBox *msg)
608 {
609 UBYTE *src = NULL;
610 UBYTE *dst = NULL;
611 HIDDT_DrawMode mode;
612 struct HWData *hwdata = &XSD(cl)->data;
613 struct Box box = { msg->srcX, msg->srcY, msg->srcX + msg->width + 1, msg->srcY + msg->height + 1};
614
615 D(bug("[VMWareSVGA] %s()\n", __func__);)
616
617 ObtainSemaphore(&hwdata->damage_control);
618
619 mode = GC_DRMD(msg->gc);
620 OOP_GetAttr(msg->src, aHidd_VMWareSVGABitMap_Drawable, (IPTR *)&src);
621 OOP_GetAttr(msg->dest, aHidd_VMWareSVGABitMap_Drawable, (IPTR *)&dst);
622 if (((dst == NULL) || (src == NULL))) /* no vmwaregfx bitmap */
623 {
624 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
625 }
626
627 // TODO: This is nice and fast. but unfortunately has to go. We'll soon switch to a more refined accelerated blitting
628 else if ((VPVISFLAG) && (dst == src) && (OOP_OCLASS(msg->dest) == XSD(cl)->vmwaresvgaonbmclass))
629 {
630 D(bug("[VMWareSVGA] %s: suitable bitmaps used ...\n", __func__);)
631
632 struct BitmapData *data;
633 data = OOP_INST_DATA(OOP_OCLASS(msg->src), msg->src);
634 switch (mode)
635 {
636 case vHidd_GC_DrawMode_Clear:
637 clearCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
638 break;
639 case vHidd_GC_DrawMode_And:
640 andCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
641 break;
642 case vHidd_GC_DrawMode_AndReverse:
643 andReverseCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
644 break;
645 case vHidd_GC_DrawMode_Copy:
646 copyCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
647 break;
648 case vHidd_GC_DrawMode_AndInverted:
649 andInvertedCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
650 break;
651 case vHidd_GC_DrawMode_NoOp:
652 noOpCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
653 break;
654 case vHidd_GC_DrawMode_Xor:
655 xorCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
656 break;
657 case vHidd_GC_DrawMode_Or:
658 orCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
659 break;
660 case vHidd_GC_DrawMode_Nor:
661 norCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
662 break;
663 case vHidd_GC_DrawMode_Equiv:
664 equivCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
665 break;
666 case vHidd_GC_DrawMode_Invert:
667 invertCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
668 break;
669 case vHidd_GC_DrawMode_OrReverse:
670 orReverseCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
671 break;
672 case vHidd_GC_DrawMode_CopyInverted:
673 copyInvertedCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
674 break;
675 case vHidd_GC_DrawMode_OrInverted:
676 orInvertedCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
677 break;
678 case vHidd_GC_DrawMode_Nand:
679 nandCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
680 break;
681 case vHidd_GC_DrawMode_Set:
682 setCopyVMWareSVGA(data->data, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height);
683 break;
684 default:
685 {
686 D(bug("[VMWareSVGA] %s: mode %d is not handled\n", __func__, mode);)
687 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
688 }
689 }
690 }
691 else
692 {
693 struct BitmapData *srcbd = OOP_INST_DATA(OOP_OCLASS(msg->src), msg->src);
694 struct BitmapData *dstbd = OOP_INST_DATA(OOP_OCLASS(msg->dest), msg->dest);
695 UBYTE *sbuffer;
696 ULONG srestadd;
697 UBYTE *dbuffer;
698 ULONG drestadd;
699 ULONG ycnt = msg->height;
700 ULONG xcnt;
701 LONG offset;
702
703 /* get src/dest video data start addresses and skip sizes */
704 if (srcbd->VideoData == srcbd->data->vrambase)
705 {
706 offset = (msg->srcX*srcbd->bytesperpix)+(msg->srcY*srcbd->data->bytesperline);
707 srestadd = (srcbd->data->bytesperline - (msg->width*srcbd->bytesperpix));
708 if ((VPVISFLAG) && (XSD(cl)->mouse.visible))
709 {
710 displayCursorVMWareSVGA(&XSD(cl)->data, SVGA_CURSOR_ON_REMOVE_FROM_FB);
711 }
712 }
713 else
714 {
715 offset = (msg->srcX+(msg->srcY*srcbd->width))*srcbd->bytesperpix;
716 srestadd = (srcbd->width - msg->width)*srcbd->bytesperpix;
717 }
718 sbuffer = srcbd->VideoData+offset;
719 if (dstbd->VideoData == dstbd->data->vrambase)
720 {
721 offset = (msg->destX*dstbd->bytesperpix)+(msg->destY*dstbd->data->bytesperline);
722 drestadd = (dstbd->data->bytesperline - (msg->width*dstbd->bytesperpix));
723 if ((VPVISFLAG) && (XSD(cl)->mouse.visible))
724 {
725 displayCursorVMWareSVGA(&XSD(cl)->data, SVGA_CURSOR_ON_REMOVE_FROM_FB);
726 }
727 }
728 else
729 {
730 offset = (msg->destX+(msg->destY*dstbd->width))*dstbd->bytesperpix;
731 drestadd = (dstbd->width - msg->width)*dstbd->bytesperpix;
732 }
733 dbuffer = dstbd->VideoData+offset;
734
735 switch (mode)
736 {
737 case vHidd_GC_DrawMode_Copy:
738 {
739 D(bug("[VMWareSVGA] %s: using CopyMem\n", __func__);)
740 while (ycnt--)
741 {
742 xcnt = msg->width;
743
744 // NOTE: this is only valid if the two bitmaps share the same bytes per pixel.
745 // we may want to pre-process it (see below in the mouse definition code)
746 CopyMem(sbuffer, dbuffer, xcnt * dstbd->bytesperpix);
747
748 sbuffer += xcnt * dstbd->bytesperpix;
749 sbuffer += srestadd;
750 dbuffer += xcnt * dstbd->bytesperpix;
751 dbuffer += drestadd;
752 }
753 }
754 break;
755 default:
756 D(bug("[VMWareSVGA] mode = %ld, src @ 0x%p dst @ 0x%p\n", mode, src, dst);)
757 OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
758 }
759
760 if ((VPVISFLAG) && (XSD(cl)->mouse.visible))
761 {
762 displayCursorVMWareSVGA(&XSD(cl)->data, SVGA_CURSOR_ON_RESTORE_TO_FB);
763 }
764 }
765
766 box.x1 = msg->srcX;
767 box.y1 = msg->srcY;
768 box.x2 = box.x1+msg->width+1;
769 box.y2 = box.y1+msg->height+1;
770
771 VMWareSVGA_Damage_DeltaAdd(hwdata, &box);
772 ReleaseSemaphore(&hwdata->damage_control);
773
774 D(bug("[VMWareSVGA] %s: done\n", __func__);)
775 }
776
777 BOOL VMWareSVGA__Hidd_Gfx__SetCursorShape(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_SetCursorShape *msg)
778 {
779 struct VMWareSVGA_staticdata *data = XSD(cl);
780
781 D(bug("[VMWareSVGA] %s()\n", __func__);)
782
783 if (msg->shape == NULL)
784 {
785 D(bug("[VMWareSVGA] %s: blanking cursor\n", __func__);)
786 if ((VPVISFLAG) && (XSD(cl)->visible))
787 displayCursorVMWareSVGA(&XSD(cl)->data, SVGA_CURSOR_ON_HIDE);
788 data->mouse.oopshape = NULL;
789 FreeVec(data->mouse.shape);
790 data->mouse.shape = NULL;
791
792 return TRUE;
793 }
794 else
795 {
796 #if (0)
797 OOP_Object *colmap;
798 OOP_Object *pfmt;
799 HIDDT_StdPixFmt pixfmt;
800 #endif
801 IPTR tmp;
802
803 OOP_GetAttr(msg->shape, aHidd_BitMap_Width, &tmp);
804 data->mouse.width = tmp;
805 OOP_GetAttr(msg->shape, aHidd_BitMap_Height, &tmp);
806 data->mouse.height = tmp;
807 #if (0)
808 OOP_GetAttr(msg->shape, aHidd_BitMap_PixFmt, (IPTR *)&pfmt);
809 OOP_GetAttr(pfmt, aHidd_PixFmt_StdPixFmt, (IPTR *)&pixfmt);
810 OOP_GetAttr(msg->shape, aHidd_BitMap_ColorMap, (IPTR *)&colmap);
811 #endif
812
813 /* convert shape to vmware needs */
814 FreeVec(data->mouse.shape);
815 tmp = data->mouse.width * data->mouse.height;
816 data->mouse.shape = AllocVec(tmp << 2, MEMF_CLEAR|MEMF_PUBLIC);
817 if (data->mouse.shape != NULL)
818 {
819 UBYTE *shape;
820 shape = data->mouse.shape;
821
822 data->mouse.oopshape = msg->shape;
823 // Get data from the bitmap. Using the ALPHA CURSOR we can now directly pre-process the bitmap to a suitable format
824 HIDD_BM_GetImage(msg->shape, (UBYTE *)shape, data->mouse.width * 4, 0, 0, data->mouse.width, data->mouse.height, vHidd_StdPixFmt_BGRA32);
825 if (XSD(cl)->visible)
826 {
827 struct BitmapData *bmdata = OOP_INST_DATA(XSD(cl)->vmwaresvgaonbmclass, XSD(cl)->visible);
828
829 syncfenceVMWareSVGAFIFO(bmdata->data, (bmdata->data->fence - 1));
830 defineCursorVMWareSVGA(bmdata->data, &data->mouse);
831 syncfenceVMWareSVGAFIFO(bmdata->data, fenceVMWareSVGAFIFO(bmdata->data));
832 }
833 return TRUE;
834 }
835 }
836
837 return FALSE;
838 }
839
840 BOOL VMWareSVGA__Hidd_Gfx__SetCursorPos(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_SetCursorPos *msg)
841 {
842 D(bug("[VMWareSVGA] %s()\n", __func__);)
843
844 XSD(cl)->mouse.x = msg->x;
845 XSD(cl)->mouse.y = msg->y;
846
847 if ((VPVISFLAG) && (XSD(cl)->visible))
848 {
849 struct BitmapData *bmdata = OOP_INST_DATA(XSD(cl)->vmwaresvgaonbmclass, XSD(cl)->visible);
850
851 syncfenceVMWareSVGAFIFO(bmdata->data, (bmdata->data->fence - 1));
852 moveCursorVMWareSVGA(bmdata->data, XSD(cl)->mouse.x, XSD(cl)->mouse.y);
853 syncfenceVMWareSVGAFIFO(bmdata->data, fenceVMWareSVGAFIFO(bmdata->data));
854 }
855
856 return TRUE;
857 }
858
859 VOID VMWareSVGA__Hidd_Gfx__SetCursorVisible(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_SetCursorVisible *msg)
860 {
861 D(bug("[VMWareSVGA] %s()\n", __func__);)
862
863 XSD(cl)->mouse.visible = msg->visible;
864 if ((VPVISFLAG) && (XSD(cl)->visible))
865 {
866 struct BitmapData *bmdata = OOP_INST_DATA(XSD(cl)->vmwaresvgaonbmclass, XSD(cl)->visible);
867
868 syncfenceVMWareSVGAFIFO(bmdata->data, (bmdata->data->fence - 1));
869 displayCursorVMWareSVGA(bmdata->data, msg->visible ? SVGA_CURSOR_ON_SHOW : SVGA_CURSOR_ON_HIDE);
870 syncfenceVMWareSVGAFIFO(bmdata->data, fenceVMWareSVGAFIFO(bmdata->data));
871 }
872 }
873
874 static int VMWareSVGA_InitStatic(LIBBASETYPEPTR LIBBASE)
875 {
876 D(bug("[VMWareSVGA] %s()\n", __func__);)
877
878 LIBBASE->vsd.mouse.x=0;
879 LIBBASE->vsd.mouse.y=0;
880 LIBBASE->vsd.mouse.shape = NULL;
881
882 if (!OOP_ObtainAttrBases(attrbases))
883 {
884 D(bug("[VMWareSVGA] %s: attrbases init failed\n", __func__);)
885 return FALSE;
886 }
887
888 D(bug("[VMWareSVGA] %s: initialised\n", __func__);)
889
890 return TRUE;
891 }
892
893 static int VMWareSVGA_ExpungeStatic(LIBBASETYPEPTR LIBBASE)
894 {
895 D(bug("[VMWareSVGA] %s()\n", __func__);)
896
897 OOP_ReleaseAttrBases(attrbases);
898
899 D(bug("[VMWareSVGA] %s: done\n", __func__);)
900
901 return TRUE;
902 }
903
904 ADD2INITLIB(VMWareSVGA_InitStatic, 0)
905 ADD2EXPUNGELIB(VMWareSVGA_ExpungeStatic, 0)
Mirror of AROS' svn.