/******************************Module*Header**********************************\
*
*                           ***************
*                           * SAMPLE CODE *
*                           ***************
*
* Module Name: Permedia.h
*
* Content:     various definitions for the Permedia DMA and FIFO interface
*              and the Permedia class
*
* Copyright (c) 1994-1998 3Dlabs Inc. Ltd. All rights reserved.
* Copyright (c) 1995-1999 Microsoft Corporation.  All rights reserved.
\*****************************************************************************/

#ifndef __permedia__
#define __permedia__

#include "mini.h"

#define FASTCALL __fastcall

#if defined(_X86_)
typedef LONG __fastcall _InterlockedExchange( IN OUT PLONG, IN LONG);
typedef _InterlockedExchange *PInterlockedExchange;
#endif

#if defined(_ALPHA_)
extern "C" VOID  __MB(VOID);
#endif

//
//  handy typedefs for FlushDMA and CheckForEOB function pointers
//
typedef VOID (GFNFLUSHDMA)(P2DMA*);
typedef VOID (GFNCHECKEOB)(P2DMA*, LONG);

// Some macros for DirectDraw
#define IN_VRETRACE(xppdev) bInVerticalRetrace(xppdev)
#define IN_DISPLAY(xppdev)  (!IN_VRETRACE(xppdev))
#define CURRENT_VLINE(xppdev) lCurrentLine(xppdev)
#define DRAW_ENGINE_BUSY    bDrawEngineBusy(pP2dma)
#define SYNC_WITH_PERMEDIA  vSyncWithPermedia(pP2dma)

#define READ_CTRL_REG(uiReg)\
    READ_REGISTER_ULONG(&pP2dma->pCtrlBase[uiReg/sizeof(ULONG)])

#define P2_READ_CTRL_REG(uiReg)\
    READ_REGISTER_ULONG(&ppdev->pCtrlBase[uiReg/sizeof(ULONG)])

#define WRITE_CTRL_REG(uiReg, uiValue)\
{   \
    WRITE_REGISTER_ULONG(&pP2dma->pCtrlBase[uiReg/sizeof(ULONG)],uiValue); \
    MEMORY_BARRIER();\
}


// For sending permedia tags.
#define SEND_PERMEDIA_DATA(tag,data)                                    \
    LD_INPUT_FIFO(__Permedia2Tag##tag, data)

#define SEND_PERMEDIA_DATA_OFFSET(tag,data, i)  \
    LD_INPUT_FIFO(__Permedia2Tag##tag+i, data)

#define COPY_PERMEDIA_DATA(tag,data)                            \
    LD_INPUT_FIFO( __Permedia2Tag##tag, *((unsigned long*) &(data)))

#define HOLD_CMD(tag, count) ( __Permedia2Tag##tag | ((count-1) << 16))

// use macros instead of inlines for Fifo downloads.

//@@BEGIN_DDKSPLIT
#if DBG && MULTITHREADED
#define PERMEDIA_DEFS(xppdev)       \
    P2DMA *pP2dma=xppdev->pP2dma;   \
    PULONG pTmp;                    \
    if (pP2dma != NULL) { pP2dma->ppdev = xppdev; }
#else
//@@END_DDKSPLIT

#define PERMEDIA_DEFS(xppdev)  \
    P2DMA *pP2dma=xppdev->pP2dma;\
    PULONG pTmp;

//@@BEGIN_DDKSPLIT
#endif
//@@END_DDKSPLIT

//----------------------------------------------------------------------------
//
//  here are the API macros for DMA transport
//
//
//  RESERVEDMAPTR(n)                // reserve n entries for DMA 
//  n=GetFreeEntries()              // get number of free entries to fill
//                                      (optional)
//  up to n LD_INPUT_FIFO  
//  COMMITDMAPTR()                 // adjust DMA buffer pointer
//
//  FLUSHDMA();
//
//----------------------------------------------------------------------------

//@@BEGIN_DDKSPLIT
#if 1

#define RESERVEDMAWORDS(n) \
{ \
    ASSERTLOCK(pP2dma->ppdev, RESERVEDMAWORDS); \
    pTmp=ReserveDMAPtr(pP2dma,n); \
}

#define RESERVEDMAPTR(n) \
{ \
    ASSERTLOCK(pP2dma->ppdev, RESERVEDMAPTR); \
    pTmp=ReserveDMAPtr(pP2dma,2*n); \
}

#else
//@@END_DDKSPLIT

#define RESERVEDMAWORDS(n) \
{    pTmp=ReserveDMAPtr(pP2dma,n);}

#define RESERVEDMAPTR(n) \
{    pTmp=ReserveDMAPtr(pP2dma,2*n);}

//@@BEGIN_DDKSPLIT
#endif
//@@END_DDKSPLIT

#define COMMITDMAPTR() \
{    CommitDMAPtr(pP2dma,pTmp);}

#define GETFREEENTRIES() \
    GetFreeEntries(pP2dma)

#define FLUSHDMA()    (pP2dma->pgfnFlushDMA)(pP2dma)

// compiler does not resolve C++ inlines until use of /Ob1,
// so write inline as a real macro
#define LD_INPUT_FIFO(uiTag, uiData) \
{   *pTmp++=(uiTag);\
    *pTmp++=(uiData);\
}    

#define LD_INPUT_FIFO_DATA(uiData)    \
    *pTmp++=(uiData); 




//-----------------------------------------------------------------------------
//
// define register file of Permedia 2 chip and other chip constants
//
//-----------------------------------------------------------------------------

#define PREG_RESETSTATUS  0x0
#define PREG_INTENABLE    0x8
#define PREG_INTFLAGS     0x10
#define PREG_INFIFOSPACE  0x18
#define PREG_OUTFIFOWORDS 0x20
#define PREG_INDMAADDRESS   0x28
#define PREG_INDMACOUNT     0x30
#define PREG_ERRORFLAGS   0x38
#define PREG_VCLKCTL      0x40
#define PERMEDIA_REG_TESTREGISTER 0x48
#define PREG_APERTUREONE  0x50
#define PREG_APERTURETWO  0x58
#define PREG_DMACONTROL   0x60
#define PREG_FIFODISCON   0x68
#define PREG_FIFODISCON_GPACTIVE   0x80000000L
#define PREG_CHIPCONFIG   0x70
#define PREG_OUTDMAADDRESS 0x80
#define PREG_OUTDMACOUNT     0x88
#define PREG_AGPTEXBASEADDRESS  0x90
#define PREG_BYDMAADDRESS   0xa0
#define PREG_BYDMASTRIDE    0xb8
#define PREG_BYDMAMEMADDR   0xc0
#define PREG_BYDMASIZE      0xc8
#define PREG_BYDMABYTEMASK  0xd0
#define PREG_BYDMACONTROL   0xd8
#define PREG_BYDMACOMPLETE  0xe8
#define PREG_FIFOINTERFACE  0x2000 

#define PREG_LINECOUNT      0x3070
#define PREG_VBEND          0x3040

#define PREG_SCREENBASE      0x3000
#define PREG_SCREENBASERIGHT 0x3080
#define PREG_VIDEOCONTROL    0x3058

#define PREG_VC_STEREOENABLE 0x800
// use this for stereo
#define PREG_VC_SCREENBASEPENDING 0xc180
#define PREG_VC_RIGHTFRAME   0x2000

// for non stereo modes
// #define PREG_VC_SCREENBASEPENDING 0x080

// GP video enabled/disabled bit of VideoControl
#define PREG_VC_VIDEO_ENABLE 0x0001

#define P2_EXTERNALVIDEO  0x4000

#define CTRLBASE    0
#define COREBASE    0x8000
#define GPFIFO      0x2000

#define MAXINPUTFIFOLENGTH 0x100

//-----------------------------------------------------------------------------
//
//  various register flags
//
//-----------------------------------------------------------------------------

#define PREG_INTFLAGS_DMA   1
#define PREG_INTFLAGS_VS    0x10
#define PREG_INTFLAGS_ERROR 0x8
#define PREG_INTFLAGS_SYNC  2

//
// DisconnectControl bits
//
#define DISCONNECT_INPUT_FIFO_ENABLE    0x1
#define DISCONNECT_OUTPUT_FIFO_ENABLE   0x2
#define DISCONNECT_INOUT_ENABLE         (DISCONNECT_INPUT_FIFO_ENABLE | \
                                         DISCONNECT_OUTPUT_FIFO_ENABLE)
#define DISCONNECT_INOUT_DISABLE        0x0

//-----------------------------------------------------------------------------
//
// Size of DMA buffer. Since we use only one wraparound DMA Buffer
// with continous physical memory, it should not be too long.
// We allocate this buffer at start of day and keep it forever, unless
// somebody forces an unload of the display driver. Selecting a larger
// size makes it more likely for the call to fail.
//
// The usage counter for the DMA memory is handled in the miniport, because
// the Permedia class gets unloaded on a mode switch.
//
//-----------------------------------------------------------------------------

// DMA command buffer stream size and minimum size
#define DMACMDSIZE     DMA_BUFFERSIZE
#define DMACMDMINSIZE  0x2000L
#define MAXBLKSIZE     0x1000       // limit block transfers to 16 kb per chunk
                                    // to have a good balance between download
                                    // speed and latencies
#define ALIGNFACTOR    0x400        // alignment factor (4kb page)

//-----------------------------------------------------------------------------
//
// shared memory section of P2 interrupt driven DMA handler
//
//-----------------------------------------------------------------------------

struct _P2DMA {
    INTERRUPT_CONTROL_BLOCK ICB;

    // these are the linear Permedia base addresses of the control registers
    // and the Fifo area
    ULONG *pCtrlBase;
    ULONG *pGPFifo;

    // handle to videoport of instance
    HANDLE hDriver;

    LONG  lDMABufferSize;         // size of DMA buffer in ULONGs

    ULONG uiInstances;            // currently active driver instances using 
                                  // the shared memory

    ULONG ulIntFlags;             // cache for interrupt flag register

#if defined(_X86_)
                                  // pointer to Interlockedexchange function in
                                  // the kernel.
    PInterlockedExchange pInterlockedExchange;
#endif

    BOOL bDMAEmulation;           // remember if we run in DMA emulation

    GFNCHECKEOB*pgfnCheckEOB;     // DMA CheckEOB buffer function pointer
    GFNFLUSHDMA*pgfnFlushDMA;     // DMA FlushDMA buffer function pointer

    ULONG *pSharedDMABuffer;      // virtual address of shared DMA buffer
    LONG   lSharedDMABufferSize;  // size of shared DMA buffer in BYTEs

    ULONG *pEmulatedDMABuffer;    // address of DMA emulation buffer
    LONG   lEmulatedDMABufferSize;// size of DMA emulation buffer in BYTEs

    BOOL bEnabled;                // check if the DMA code is enabled

#if DBG
    LONG lDBGState;               // keep track of state in debug version
                                  // 0:   idle
                                  // 2:   ReserveDMAPtr was called
    LONG bDBGIgnoreAssert;
    ULONG *pDBGReservedEntries;   // pointer to which we have reserved
                                  // for debugging checks
//@@BEGIN_DDKSPLIT
#if MULTITHREADED
    PPDev ppdev;                  // For checking multithreaded semaphore
#endif
//@@END_DDKSPLIT
#endif

} ;

//-----------------------------------------------------------------------------
//
//  definitions for functions which are different in non-DMA, DMA and 
//  multiprocessing DMA cases. bInitializeP2DMA will decide which ones to use
//  and preset the function pointers.
//
//-----------------------------------------------------------------------------

VOID vFlushDMA(P2DMA *pP2dma);
VOID vFlushDMAMP(P2DMA *pP2dma);
VOID vFlushDMAEmulation(P2DMA *pP2dma);

VOID vCheckForEOB(P2DMA *pP2dma,LONG lEntries);
VOID vCheckForEOBMP(P2DMA *pP2dma,LONG lEntries);
VOID vCheckForEOBEmulation(P2DMA *pP2dma,LONG lEntries);

//-----------------------------------------------------------------------------
//
//  more helper and blockdownload functions
//
//-----------------------------------------------------------------------------

VOID vWaitDMAComplete(P2DMA *pP2dma);
LONG lWaitOutputFifoReady(P2DMA *pP2dma);
BOOL bDrawEngineBusy(P2DMA *pP2dma);
BOOL bInVerticalRetrace(PPDev ppdev);
LONG lCurrentLine(PPDev ppdev);

VOID vBlockLoadInputFifoByte (P2DMA *pP2dma, 
                              ULONG uiTag, 
                              BYTE *pImage, 
                              LONG lWords);
VOID vBlockLoadInputFifo     (P2DMA *pP2dma, 
                              ULONG uiTag,
                              ULONG *pImage, 
                              LONG lWords);

//-----------------------------------------------------------------------------
//
// Basic reserve/commit Api functions. They are provided as inlines for free 
// builds and as functions with debug checks in checked builds.
//
//-----------------------------------------------------------------------------

ULONG *ReserveDMAPtr (P2DMA *pP2dma, const LONG nEntries);
VOID   CommitDMAPtr  (P2DMA *pP2dma, ULONG *pDMAPtr);
LONG   GetFreeEntries(P2DMA *pP2dma);


//
//  completely synchronize chip here 
//

VOID vSyncWithPermedia(P2DMA *pP2dma);

//
// initialization and cleanup routines
//
BOOL bInitializeP2DMA(  P2DMA *pP2dma,
                        HANDLE hDriver, 
                        ULONG *pChipBase, 
                        DWORD dwAccelerationLevel,
                        BOOL NewReference
                      );
VOID vFree(P2DMA *pP2dma);


#if !DBG

//----------------------------------------------------------------------------
//
//  ReserveDMAPtr
//
//  return a pointer to current position in DMA buffer. The function guarantees
//  that there are at least lEntries available in the buffer.
//  Otherwise the caller can ask GetFreeEntries and adjust the download to 
//  batch more entries. The caller MUST call CommitDMAPtr after a call to
//  to ReserveDMAPtr to readjust the Index pointer.
//
//----------------------------------------------------------------------------

inline ULONG *ReserveDMAPtr(P2DMA *pP2dma,const LONG lEntries)
{
    while (pP2dma->ICB.pDMAWritePos+lEntries>=
           pP2dma->ICB.pDMAWriteEnd)
    {
        (*pP2dma->pgfnCheckEOB)(pP2dma,lEntries);
    }   

    return (ULONG *)pP2dma->ICB.pDMAWritePos;  
}


//----------------------------------------------------------------------------
//
//  CommitDMAPtr
//
//  pDMAPtr----DMA buffer address to which the caller has written to.
//
//  Readjust write pointer after being reserved by ReserveDMAPtr. 
//  By committing the pointer a DMA to the committed position could already
//  be started by interrupt handler!
//
//----------------------------------------------------------------------------

inline VOID CommitDMAPtr(P2DMA *pP2dma,ULONG *pDMAPtr)
{
    pP2dma->ICB.pDMAWritePos=pDMAPtr;
}

//----------------------------------------------------------------------------
//
//  GetFreeEntries
//
//  Get free entries available for consecutive writing to the DMA buffer.
//  The maximum number of returned entries is now MAXBLKSIZE.
// 
//  returns---number of available entries in ULONGS
//
//----------------------------------------------------------------------------

inline LONG GetFreeEntries(P2DMA *pP2dma)
{   
    LONG EntriesAvailable = (LONG)(pP2dma->ICB.pDMAWriteEnd - pP2dma->ICB.pDMAWritePos);
    return min(MAXBLKSIZE,EntriesAvailable);
}

#endif
#endif