arch/common/hidd.vmwaresvga/vmwaresvgahardware.c

   1 /*
   2     Copyright © 1995-2008, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: vmware svga hardware functions
   6     Lang: English
   7 */
   8
   9 #define DEBUG 1 /* no SysBase */
  10 #include <aros/debug.h>
  11
  12 #include <asm/io.h>
  13
  14 #include "vmwaresvgahardware.h"
  15 #include "svga_reg.h"
  16 #include "vmwaresvgaclass.h"
  17
  18 ULONG vmwareReadReg(struct HWData *data, ULONG reg)
  19 {
  20     outl(reg, data->indexReg);
  21     return inl(data->valueReg);
  22 }
  23
  24 void vmwareWriteReg(struct HWData *data, ULONG reg, ULONG val)
  25 {
  26     outl(reg, data->indexReg);
  27     outl(val, data->valueReg);
  28 }
  29
  30 #undef SysBase
  31 extern struct ExecBase *SysBase;
  32
  33 ULONG getVMWareSVGAID(struct HWData *data)
  34 {
  35     ULONG id;
  36
  37     vmwareWriteReg(data, SVGA_REG_ID, SVGA_ID_2);
  38     id = vmwareReadReg(data, SVGA_REG_ID);
  39     if (id == SVGA_ID_2)
  40         return id;
  41     vmwareWriteReg(data, SVGA_REG_ID, SVGA_ID_1);
  42     id = vmwareReadReg(data, SVGA_REG_ID);
  43     if (id == SVGA_ID_1)
  44         return id;
  45     if (id == SVGA_ID_0)
  46         return id;
  47     return SVGA_ID_INVALID;
  48 }
  49
  50 VOID initVMWareSVGAFIFO(struct HWData *data)
  51 {
  52     ULONG *fifo;
  53     ULONG fifomin;
  54
  55     vmwareWriteReg(data, SVGA_REG_CONFIG_DONE, 0);              //Stop vmware from reading the fifo
  56
  57     fifo = data->mmiobase = vmwareReadReg(data, SVGA_REG_MEM_START);
  58     data->mmiosize = vmwareReadReg(data, SVGA_REG_MEM_SIZE) & ~3;
  59
  60     if (data->capabilities & SVGA_CAP_EXTENDED_FIFO)
  61         fifomin = vmwareReadReg(data, SVGA_REG_MEM_REGS);
  62     else
  63         fifomin =4;
  64
  65     fifo[SVGA_FIFO_MIN] = fifomin * sizeof(ULONG);
  66     fifo[SVGA_FIFO_MAX] = data->mmiosize;
  67     fifo[SVGA_FIFO_NEXT_CMD] = fifomin * sizeof(ULONG);
  68     fifo[SVGA_FIFO_STOP] = fifomin * sizeof(ULONG);
  69
  70     vmwareWriteReg(data, SVGA_REG_CONFIG_DONE, 1);
  71 }
  72
  73 VOID syncVMWareSVGAFIFO(struct HWData *data)
  74 {
  75     vmwareWriteReg(data, SVGA_REG_SYNC, 1);
  76     while (vmwareReadReg(data, SVGA_REG_BUSY) != 0);
  77 #warning "maybe wait (delay) some time"
  78 }
  79
  80 VOID writeVMWareSVGAFIFO(struct HWData *data, ULONG val)
  81 {
  82     ULONG *fifo;
  83
  84     fifo = data->mmiobase;
  85     if (
  86             (fifo[SVGA_FIFO_NEXT_CMD]+4 == fifo[SVGA_FIFO_STOP]) ||
  87             (
  88                 (fifo[SVGA_FIFO_NEXT_CMD] == (fifo[SVGA_FIFO_MAX]-4)) &&
  89                 (fifo[SVGA_FIFO_STOP] == fifo[SVGA_FIFO_MIN])
  90             )
  91         )
  92         syncVMWareSVGAFIFO(data);
  93
  94     fifo[fifo[SVGA_FIFO_NEXT_CMD] / 4] = val;
  95     fifo[SVGA_FIFO_NEXT_CMD] += 4;
  96
  97     if (fifo[SVGA_FIFO_NEXT_CMD] == fifo[SVGA_FIFO_MAX])
  98         fifo[SVGA_FIFO_NEXT_CMD] = fifo[SVGA_FIFO_MIN];
  99 }
 100
 101 BOOL initVMWareSVGAHW(struct HWData *data, OOP_Object *device)
 102 {
 103     ULONG *ba;
 104     ULONG id;
 105
 106     id = getVMWareSVGAID(data);
 107     if ((id == SVGA_ID_0) || (id == SVGA_ID_INVALID))
 108     {
 109         return FALSE;
 110     }
 111
 112     initVMWareSVGAFIFO(data);
 113
 114     data->capabilities = vmwareReadReg(data, SVGA_REG_CAPABILITIES);
 115     data->depth = vmwareReadReg(data, SVGA_REG_DEPTH);
 116     data->maxwidth = vmwareReadReg(data, SVGA_REG_MAX_WIDTH);
 117     data->maxheight = vmwareReadReg(data, SVGA_REG_MAX_HEIGHT);
 118     data->redmask = vmwareReadReg(data, SVGA_REG_RED_MASK);
 119     data->greenmask = vmwareReadReg(data, SVGA_REG_GREEN_MASK);
 120     data->bluemask = vmwareReadReg(data, SVGA_REG_BLUE_MASK);
 121     data->bytesperpixel = 1;
 122
 123     if (data->depth>16)
 124         data->bytesperpixel = 4;
 125     else if (data->depth>8)
 126         data->bytesperpixel = 2;
 127
 128     if (data->capabilities & SVGA_CAP_8BIT_EMULATION)
 129     {
 130         data->bitsperpixel = vmwareReadReg(data, SVGA_REG_HOST_BITS_PER_PIXEL);
 131         vmwareWriteReg(data,SVGA_REG_BITS_PER_PIXEL, data->bitsperpixel);
 132     }
 133     else
 134         data->bitsperpixel = vmwareReadReg(data, SVGA_REG_BITS_PER_PIXEL);
 135
 136     if (data->capabilities & SVGA_CAP_MULTIMON)
 137     {
 138         data->displaycount = vmwareReadReg(data, SVGA_REG_NUM_DISPLAYS);
 139     }
 140     else
 141     {
 142         data->displaycount = 1;
 143     }
 144
 145     data->vramsize = vmwareReadReg(data, SVGA_REG_VRAM_SIZE);
 146     data->vrambase = vmwareReadReg(data, SVGA_REG_FB_START);
 147     data->pseudocolor = vmwareReadReg(data, SVGA_REG_PSEUDOCOLOR);
 148
 149     D(bug("[VMWareSVGA] Init: VRAM at 0x%08x size %d\n",data->vrambase, data->vramsize));
 150     D(bug("[VMWareSVGA] Init: no.displays: %d\n",data->displaycount));
 151     D(bug("[VMWareSVGA] Init: caps : 0x%08x\n",data->capabilities));
 152     D(bug("[VMWareSVGA] Init: no.displays: %d\n",data->displaycount));
 153     D(bug("[VMWareSVGA] Init: depth: %d\n",data->depth));
 154     D(bug("[VMWareSVGA] Init: bpp  : %d\n",data->bitsperpixel));
 155     D(bug("[VMWareSVGA] Init: maxw: %d\n",data->maxwidth));
 156     D(bug("[VMWareSVGA] Init: maxh: %d\n",data->maxheight));
 157
 158     return TRUE;
 159 }
 160
 161 VOID setModeVMWareSVGA(struct HWData *data, ULONG width, ULONG height)
 162 {
 163     D(bug("[VMWareSVGA] SetMode: %dx%d\n",width,height));
 164     vmwareWriteReg(data, SVGA_REG_ENABLE, 0);
 165     vmwareWriteReg(data, SVGA_REG_WIDTH, width);
 166     vmwareWriteReg(data, SVGA_REG_HEIGHT, height);
 167
 168     if (data->capabilities & SVGA_CAP_8BIT_EMULATION)
 169         vmwareWriteReg(data, SVGA_REG_BITS_PER_PIXEL,data->bitsperpixel);
 170
 171     vmwareWriteReg(data, SVGA_REG_ENABLE, 1);
 172
 173     data->fboffset = vmwareReadReg(data, SVGA_REG_FB_OFFSET);
 174     data->bytesperline = vmwareReadReg(data, SVGA_REG_BYTES_PER_LINE);
 175     data->depth = vmwareReadReg(data, SVGA_REG_DEPTH);
 176     data->redmask = vmwareReadReg(data, SVGA_REG_RED_MASK);
 177     data->greenmask = vmwareReadReg(data, SVGA_REG_GREEN_MASK);
 178     data->bluemask = vmwareReadReg(data, SVGA_REG_BLUE_MASK);
 179     data->pseudocolor = vmwareReadReg(data, SVGA_REG_PSEUDOCOLOR);
 180 }
 181
 182 VOID refreshAreaVMWareSVGA(struct HWData *data, struct Box *box)
 183 {
 184     writeVMWareSVGAFIFO(data, SVGA_CMD_UPDATE);
 185     writeVMWareSVGAFIFO(data, box->x1);
 186     writeVMWareSVGAFIFO(data, box->y1);
 187     writeVMWareSVGAFIFO(data, box->x2-box->x1+1);
 188     writeVMWareSVGAFIFO(data, box->y2-box->y1+1);
 189 }
 190
 191 VOID rectFillVMWareSVGA(struct HWData *data, ULONG color, LONG x, LONG y, LONG width, LONG height)
 192 {
 193     writeVMWareSVGAFIFO(data, SVGA_CMD_RECT_FILL);
 194     writeVMWareSVGAFIFO(data, color);
 195     writeVMWareSVGAFIFO(data, x);
 196     writeVMWareSVGAFIFO(data, y);
 197     writeVMWareSVGAFIFO(data, width);
 198     writeVMWareSVGAFIFO(data, height);
 199     syncVMWareSVGAFIFO(data);
 200 }
 201
 202 VOID ropFillVMWareSVGA(struct HWData *data, ULONG color, LONG x, LONG y, LONG width, LONG height, ULONG mode)
 203 {
 204     writeVMWareSVGAFIFO(data, SVGA_CMD_RECT_ROP_FILL);
 205     writeVMWareSVGAFIFO(data, color);
 206     writeVMWareSVGAFIFO(data, x);
 207     writeVMWareSVGAFIFO(data, y);
 208     writeVMWareSVGAFIFO(data, width);
 209     writeVMWareSVGAFIFO(data, height);
 210     writeVMWareSVGAFIFO(data, mode);
 211     syncVMWareSVGAFIFO(data);
 212 }
 213
 214 VOID ropCopyVMWareSVGA(struct HWData *data, LONG sx, LONG sy, LONG dx, LONG dy, ULONG width, ULONG height, ULONG mode)
 215 {
 216     writeVMWareSVGAFIFO(data, SVGA_CMD_RECT_ROP_COPY);
 217     writeVMWareSVGAFIFO(data, sx);
 218     writeVMWareSVGAFIFO(data, sy);
 219     writeVMWareSVGAFIFO(data, dx);
 220     writeVMWareSVGAFIFO(data, dy);
 221     writeVMWareSVGAFIFO(data, width);
 222     writeVMWareSVGAFIFO(data, height);
 223     writeVMWareSVGAFIFO(data, mode);
 224     syncVMWareSVGAFIFO(data);
 225 }
 226
 227 VOID defineCursorVMWareSVGA(struct HWData *data, struct MouseData *mouse)
 228 {
 229     int i;
 230     ULONG *cshape = mouse->shape;
 231     struct Box box;
 232     ULONG andmask[SVGA_PIXMAP_SIZE(mouse->width, mouse->height, data->bitsperpixel)];
 233     ULONG *a;
 234     ULONG *b;
 235
 236 #warning "convert mouse shape to current depth"
 237     writeVMWareSVGAFIFO(data, SVGA_CMD_DEFINE_CURSOR);
 238     writeVMWareSVGAFIFO(data, 1);
 239     writeVMWareSVGAFIFO(data, 0); /* hot x value */
 240     writeVMWareSVGAFIFO(data, 0); /* hot y value */
 241     writeVMWareSVGAFIFO(data, mouse->width); /* width */
 242     writeVMWareSVGAFIFO(data, mouse->height); /* height */
 243     writeVMWareSVGAFIFO(data, data->bitsperpixel); /* bits per pixel */
 244     writeVMWareSVGAFIFO(data, data->bitsperpixel); /* bits per pixel */
 245     b = cshape;
 246     a = andmask;
 247     for (i = 0; i<(SVGA_PIXMAP_SIZE(mouse->width, mouse->height, data->bitsperpixel)*2);i++)
 248     {
 249         *((UWORD *)a) = *((UWORD *)b) ? 0 : ~0;
 250
 251         a = ((UWORD *)a) + 1;
 252         b = ((UWORD *)b) + 1;
 253     }
 254     a = andmask;
 255     for (i = 0; i<SVGA_PIXMAP_SIZE(mouse->width, mouse->height, data->bitsperpixel);i++)
 256         writeVMWareSVGAFIFO(data, *a++);
 257     for (i = 0; i<SVGA_PIXMAP_SIZE(mouse->width, mouse->height, data->bitsperpixel);i++)
 258         writeVMWareSVGAFIFO(data, *cshape++);
 259     syncVMWareSVGAFIFO(data);
 260 }
 261
 262 VOID displayCursorVMWareSVGA(struct HWData *data, LONG mode)
 263 {
 264 #if 0
 265     writeVMWareSVGAFIFO(data, SVGA_CMD_DISPLAY_CURSOR);
 266     writeVMWareSVGAFIFO(data, 1);
 267     writeVMWareSVGAFIFO(data, mode);
 268     syncVMWareSVGAFIFO(data);
 269 #else
 270     vmwareWriteReg(data, SVGA_REG_CURSOR_ID, 1);
 271     vmwareWriteReg(data, SVGA_REG_CURSOR_ON, mode);
 272 #endif
 273 }
 274
 275 VOID moveCursorVMWareSVGA(struct HWData *data, LONG x, LONG y)
 276 {
 277 #if 0
 278     writeVMWareSVGAFIFO(data, SVGA_CMD_MOVE_CURSOR);
 279     writeVMWareSVGAFIFO(data, x);
 280     writeVMWareSVGAFIFO(data, y);
 281     syncVMWareSVGAFIFO(data);
 282 #else
 283     vmwareWriteReg(data, SVGA_REG_CURSOR_ID, 1);
 284     vmwareWriteReg(data, SVGA_REG_CURSOR_X, x);
 285     vmwareWriteReg(data, SVGA_REG_CURSOR_Y, y);
 286     vmwareWriteReg(data, SVGA_REG_CURSOR_ON, 1);
 287 #endif
 288 }