hal_init.c

一个图形显示芯片s1d13505的应用程序

/*
**===========================================================================
** HAL_INIT.C
**---------------------------------------------------------------------------
** Copyright (c) 1997, 2001 Epson Research and Development, Inc.
** All Rights Reserved.
**===========================================================================
*/

#ifdef INTEL
#include <stdio.h>
#include <stdlib.h>
#endif

#include "hal.h"
#include "assert.h"
#include "nonsefns.h"

/*-------------------------------------------------------------------------*/

static const char Revision[] = "HAL_INIT.C=$Revision: 6 $";

extern BYTE LUT1[2*3];
extern BYTE LUT2_Color[4*3];
extern BYTE LUT2_Mono[4*3];
extern BYTE LUT4_Color[16*3];
extern BYTE LUT8_Color[256*3];

/*-------------------------------------------------------------------------*/

LPHAL_STRUCT HalInfoArray[MAX_DEVICE];

DWORD MemSize[MAX_DEVICE];
int DefaultDisplayMode[MAX_DEVICE];

int UsingLcd, UsingCrt;

/*-------------------------------------------------------------------------*/

/*
** InitHal()
**
** This routine calls platform specific initialization routines
** and when multi-device support is enabled will perform any 
** initializations required to support more than one device.
** This routine must be called at the start of the 13505 application,
** before any other HAL function is called.
**
** Returns:
**  - the return value from InitPlat()
**  - ERR_OK
*/
int seInitHal( void )
{
   int err;
   int i;

   if ((err = InitPlat()) == ERR_FAILED)
      return err;

   for (i = 0; i < MAX_DEVICE; ++i)
      MemSize[i] = 0x200000;  /* Assume 2M bytes */

   for (i = 0; i < MAX_DEVICE; ++i)
      DefaultDisplayMode[i] = DISP_MODE_LCD;

   CursorInitialized = FALSE;
   InkInitialized = FALSE;
   UsingCrt = FALSE;
   UsingLcd = FALSE;

   return ERR_OK;
}

/*-------------------------------------------------------------------------*/

void CheckMemory(int seReserved1)
{
   int MemConfig;

   /*
   ** Note that CheckMemory() will not work properly if the host interface
   ** has not been enabled.
   */
   if (ReadRegister(seReserved1, REG_MISC) & 0x80)
      return;

   /*
   ** Determine amount of memory available by using lines MD7:6
   */
   MemConfig = ReadRegister(seReserved1, REG_MD_CONFIG_READBACK0) >> 6;

   switch (MemConfig)
      {
      case 0:
      case 2:
         MemSize[seReserved1] = 0x80000;   /* 512K bytes */
         break;

      default:
         MemSize[seReserved1] = 0x200000;  /* 2M bytes */
         break;
      }

#ifdef IDP68K
   MemSize[seReserved1] = 0x80000;  /* 512K bytes */
#endif
}

/*-------------------------------------------------------------------------*/

int seGetHostBusWidth(int seReserved1, int *bits)
   {
	ASSERT( 0 == seReserved1 );

   *bits = HalInfoArray[seReserved1]->wHostBusWidth;

   return ERR_OK;
   }

/*-------------------------------------------------------------------------*/

/*
** seRegisterDevice()
**
** At this time there is very little for this function to do.
** When support for multiple devices is added this routine will be
** reponsible for handling the registration of each new device.
*/
int seRegisterDevice( const LPHAL_STRUCT lpHalInfo, int *Device )
{

#ifdef INTEL
   static int AlreadyInit = FALSE;

   if (!AlreadyInit)
   {
      seInitHal();
		atexit(halpFreeLinearAddress);

      AlreadyInit = TRUE;
   }
#endif

   DPF( In seRegisterDevice() );

   HalInfoArray[SE_RESERVED] = lpHalInfo;

   *Device = SE_RESERVED;

   InitLinear(SE_RESERVED);

   /*
   ** The default mode may change after registration, so keep a temporary
   ** copy in DefaultDisplayMode[].
   */
   if (HalInfoArray[*Device]->dwFlags & fDEFAULT_CRT)
      DefaultDisplayMode[*Device] = DISP_MODE_CRT;
   else if (HalInfoArray[*Device]->dwFlags & fDEFAULT_LCDCRT)
      DefaultDisplayMode[*Device] = DISP_MODE_LCDCRT;
   else
      DefaultDisplayMode[*Device] = DISP_MODE_LCD;


   ASSERT(DefaultDisplayMode[*Device] < MAX_DISP_MODE);


   /*
   ** Note that CheckMemory() will not work properly if the host interface
   ** has not been enabled. This would not be a problem if seSetInit()
   ** was called after seRegisterDevice().
   */
   CheckMemory(*Device);

   /*
   ** Assume that the user will use the default mode.
   */
   switch (DefaultDisplayMode[*Device])
      {
      case DISP_MODE_LCD:
         UsingLcd = TRUE;
         UsingCrt = FALSE;
         break;

      case DISP_MODE_CRT:
         UsingLcd = FALSE;
         UsingCrt = TRUE;
         break;

      default:
         UsingLcd = TRUE;
         UsingCrt = TRUE;
         break;
      }

   return ERR_OK;
}

/*-------------------------------------------------------------------------*/

int seGetMemSize( int seReserved1, DWORD *val )
{
	ASSERT( 0 == seReserved1 );

   *val = MemSize[seReserved1];
   
   return ERR_OK;
}

/*-------------------------------------------------------------------------*/

/*
** This routine sets the register values for the given device.
** The reason for setting the registers separately from the
** the registration is to support programs like PLAY where
** it is undesirable to indiscriminately blow the registers.
*/

/*
** Legal values for flags:
**  CLEAR_MEM, DONT_CLEAR_MEM, DISP_FIFO_OFF, DISP_FIFO_ON
** To combine the above flags, use the logical OR operation.
** For example, (CLEAR_MEM | DISP_FIFO_OFF) clears memory and
** turns off the display FIFO.
*/
int seSetDisplayMode( int seReserved1, int DisplayMode, int flags )
{
   int idx;
   UINT nBPP;
   UINT nHeight, nWidth;
   long lLength;
   BYTE bVal;
   BYTE *pRegs;
   int i;
   BYTE color[3];
   UINT BytesPerLine;

/*
   int y;
*/

   ASSERT( 0 == seReserved1 );
   ASSERT(DisplayMode < MAX_DISP_MODE);

   pRegs = &HalInfoArray[seReserved1]->Regs[DisplayMode][0];

   seSelectBusWidth(seReserved1, HalInfoArray[seReserved1]->wHostBusWidth);


   /*
   ** If REG[00] is 0xff, then the register array is not valid.
   */
   if (pRegs[0] == 0xff)
      return ERR_FAILED;

   switch (DisplayMode)
      {
      case DISP_MODE_LCD:
         UsingLcd = TRUE;
         UsingCrt = FALSE;
         break;

      case DISP_MODE_CRT:
         UsingLcd = FALSE;
         UsingCrt = TRUE;
         break;

      default:
         UsingLcd = TRUE;
         UsingCrt = TRUE;
         break;
      }


   /*
   ** Enable Host Interface
   */

   /*
   ** After reset, the S5U13505B00B card begins in HW suspend mode.
   ** This mode must be cancelled before continuing.
   */
   seHWSuspend(seReserved1, FALSE);

   /*
    * Miscellaneous Disable Register
    * REG[1Bh]
    */
   seGetReg(seReserved1, REG_MISC, &bVal);
   seSetReg(seReserved1, REG_MISC, (BYTE) (bVal & ~0x80));  /* clear bit 7 */

   CheckMemory(seReserved1);

/*--------------------------------------*/

   if (flags & DISP_FIFO_OFF)
      seDisplayFifo(seReserved1, OFF);

/*--------------------------------------*/

   /*
   ** Set Memory Configuration REG[01]
   */
   WriteRegister(seReserved1, REG_MEMORY_CONFIG,
                 HalInfoArray[seReserved1]->Regs[DisplayMode][REG_MEMORY_CONFIG]);

/*--------------------------------------*/

   /*
   ** Set Performance Enhancement 0 REG[22]
   */
   WriteRegister(seReserved1, REG_PERF_ENHANCEMENT0,
                 HalInfoArray[seReserved1]->Regs[DisplayMode][REG_PERF_ENHANCEMENT0]);

/*--------------------------------------*/

   seDisplayEnable(seReserved1, FALSE);


   /*
   ** For the registers simply dump their value from the array.
   */
   for (idx = 2; idx <= MAX_REG; idx++)
   {
      if (REG_RESERVED_1 == idx)
         continue;

      bVal = HalInfoArray[seReserved1]->Regs[DisplayMode][idx];

      if (idx == REG_PERF_ENHANCEMENT1)
         {
         if (flags & DISP_FIFO_OFF)
            bVal |= 0x80;
         else if (flags & DISP_FIFO_ON)
            bVal &= ~0x80;
         }

      WriteRegister( seReserved1, idx, bVal );
   }


   seGetBitsPerPixel(seReserved1, &nBPP);
   
   if (nBPP == 15)  /* treat 15 and 16 bpp as 16 bpp */
      nBPP = 16;
       
   /*
   ** Clear all visible display memory.
   */
   if (flags & CLEAR_MEM)
      {
      seGetBytesPerScanline(seReserved1, &BytesPerLine);
      seGetScreenSize( seReserved1, &nWidth, &nHeight );
      lLength = BytesPerLine * (long) nHeight;

      seWriteDisplayDwords(seReserved1, 0, 0, lLength / 4);
      }


   /*
   ** Based on the current BPP - set the LUT to default values.
   */
   if (pRegs[REG_PANEL_TYPE] & 0x04)   /* color */
      {
      switch (nBPP)
         {
         case 1:
            seSetLut( seReserved1, LUT1, 2 );
            break;

         case 2:
            seSetLut( seReserved1, LUT2_Color, 4 );
            break;

         case 4:
            seSetLut( seReserved1, LUT4_Color, 16 );
            break;

         case 8:
            seSetLut( seReserved1, LUT8_Color, 256 );
            break;

         default:
            break;
         }
      }
   else switch (nBPP)   /* mono */
      {
      case 1:
         seSetLut( seReserved1, LUT1, 2 );
         break;

      case 2:
         seSetLut( seReserved1, LUT2_Mono, 4 );
         break;

      case 4:
         for (i = 0; i < 16; ++i)
            {
            color[RED] = (BYTE) (i << 4);
            color[GREEN] = (BYTE) (i << 4);
            color[BLUE] = (BYTE) (i << 4);
            seSetLutEntry( seReserved1, i, color );
            }
         break;

      case 8:
         for (i = 0; i < 256; ++i)
            {
            color[RED] = (BYTE) (i << 4);
            color[GREEN] = (BYTE) (i << 4);
            color[BLUE] = (BYTE) (i << 4);
            seSetLutEntry( seReserved1, i, color );
            }
         break;

      default:
         break;
      }


   seDisplayEnable(seReserved1, TRUE);

   /*
   ** We may have to come back in here and tweak the odd register.
   */
   return ERR_OK;
}

/*-------------------------------------------------------------------------*/

/*
** seSetInit()
**
** This function simply calls seDisplayMode() with the default display mode.
*/
int seSetInit( int seReserved1 )
{
   int err;

   ASSERT(0 == seReserved1);
   ASSERT(DefaultDisplayMode[seReserved1] < MAX_DISP_MODE);


   err = seSetDisplayMode(seReserved1, DefaultDisplayMode[seReserved1], CLEAR_MEM | DISP_FIFO_OFF);

   seDisplayFifo(seReserved1, ON);

   return err;
}

/*-------------------------------------------------------------------------*/