Should be

    mov al, 0
    out dx, al

Should be

    mov dx, 03dah
WaitNotRetrace:
    in al, dx

Should be

WaitRetrace:
    in al, dx

Should be

    rep outs dx, word ptr es:[si]

Since it can't go wrong, why return an error code?

Should be

    mov al, 0
    out dx, al

Should be

    rep ins word ptr es:[di], dx

or

    rep insw

Again, why bother?

Also, the fact that you disable interrupts while waiting for vertical
retrace is a very {*filter*} thing to do in a multi-tasking environment. It
can cause lost data if, for instance, another program is receiving from
a serial port. My advice is just to loop until you're in a retrace, then
disable interrupts while you output the palette. Once in a great while,
you'll fall off the end of the retrace, and a little artifact may appear
at the top of the screen, but only very rarely.

By the way, there are BIOS functions that do these things.

--

Ciao,
Paul

return address, which has been altered to foil junk mail senders.)

Hi,

        I've never programmed in assembler before (allthought I've
read all sorts of intersting and useful docs) . . and I just
discovered I need it for this program I'm working on.  Can someone
please take a minute and tell me if I'm on the right track?  Thanks.

        here's the code.. most of it is self-explanitory. They are
routines that read/write palettes to/from the VGA graphics card.  It's
in a .cpp file, and is ment to compile under Turbo C++ 3.0 by Borland.

-GLog_Error is a typedef for unsigned int.
-PPalette_aucActualPalette is a global array of unsigned characters
which contains the active palette

---------------------------------------------------------------------------------------------------------
GLog_Error PPalette_UpdatePalette (
   void
   ) asm
{
   push     si

   mov      dx,0x3c8       //setup palette register to receive palette
   out      dx,0
   inc      dx

   mov      ax,SEG PPalette_aucActualPalette //load palette
   mov      es,ax
   mov      si,OFFSET PPalette_aucActualPalette //load palette

   mov      cx,64          //do only 64words at a time
   mov      bh,2           //do 2 loops

   cli                     //disable interupts

:WaitNotRetrace
   in       al,0x3da       //check VR status
   test     al,0x008
   jnz      WaitNotRetrace

:WaitRetrace
   in       al,0x3da
   test     al,0x008
   jz       WaitRetrace

   rep outs dx, WORD PRT si

   mov      cx,64
   dec      bh
   jnz      WaitNotRetrace

   sti

   pop      si
   xor      ax,ax          //return 0
   xor      dx,dx

GLog_Error PPalette_GetPalette (
   unsigned char *      io_aucPalette
   ) asm
{
   push     di

   mov      dx,0x3c7       //setup palette register to receive palette
   out      dx,0
   inc      dx
   inc      dx

   mov      ax,SEG io_aucPalette //load palette
   mov      es,ax
   mov      di,OFFSET io_aucPalette //load palette

   rep ins  WORD PRT di,dx

   pop      di
   xor      AX,AX          //return 0
   xor      DX,DX

---------------------------------------------------------------------------------------------------------

Thanks in advance!

        Geoff

Yes, you are.

--
               *** When you build it, they will come ***

http://www.ptf.hro.nl/~walter/

On Mon, 05 May 1997 23:26:05 -0700, "Paul D. DeRocco"
Wow, thanks for all these useful comments!  Can I ask a few questions
about them?

Is it better to do it that way?  I read that there is an intruction to
output and input imediate ports and values to ports.  Is it just
better, or did read it wrong?

I can answer that:  it's part of an overall coding standard.  The
exceptions routines can return are define in the package's (or
modules, if you prefer) header file, and *all* functions return an
error code.  This way, even if a function doesn't orgianly return an
error, if at some future date it needs does the error will always be
picked up by the next level, because it always checks for errors.
        This may seem pointless, but the errors it catches and the
stability it offers far outweigh the time it occationally wastes.

considering how long those loops have to weight for the next retrace,
can it still cause data loss?

umm.. good point.  It's good practice, though :)

Aren't immediate ins and outs restricted to port values of 0 to 255?

Regards, Rob.