hal_misc.c

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

      case 0x01:
         *pBitsPerPixel = 2;
         break;

      case 0x02:
         *pBitsPerPixel = 4;
         break;

      case 0x03:
         *pBitsPerPixel = 8;
         break;

      case 0x04:
         *pBitsPerPixel = 15;
         break;

      case 0x05:
      default:   /* This default case should never occur */
         *pBitsPerPixel = 16;
         break;
      }

   return ERR_OK;
}

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

/*
** seGetLastUsableByte()
** 
** Description: Returns the last usable byte of display memory before
**              the half frame buffer.
*/
int seGetLastUsableByte( int seReserved1, DWORD *pLastByte )
{
   UINT width, height;
   int EnableColor, PanelDual;
   BYTE RegPanelType;
   BYTE RegDisplayMode;
   DWORD SizeHalfFrame;
   DWORD Mem;
   int PanelEnabled, CrtEnabled;


   ASSERT( 0 == seReserved1 );
   ASSERT( NULL != pLastByte );

   seGetMemSize(seReserved1, &Mem);
   seGetScreenSize(seReserved1, &width, &height);

   RegPanelType = ReadRegister(seReserved1, REG_PANEL_TYPE);
   EnableColor = RegPanelType & 0x04;
   PanelDual = RegPanelType & 0x02;

   RegDisplayMode = ReadRegister(seReserved1, REG_DISPLAY_MODE);
   PanelEnabled = RegDisplayMode & 0x01;
   CrtEnabled = RegDisplayMode & 0x02;


   if (PanelDual && PanelEnabled && !CrtEnabled)
      {
      /*
      ** Must double height for dual panels
      */
      SizeHalfFrame = (DWORD) width * (DWORD) height * 2;

      if (EnableColor)
         SizeHalfFrame *= 4L;

      SizeHalfFrame /= 16L;
      }
   else
      SizeHalfFrame = 0;


   if (SizeHalfFrame <= Mem - 1)
      *pLastByte = Mem - SizeHalfFrame - 1;
   else
      *pLastByte = 0;

   return ERR_OK;
}

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

/*
** seDisplayEnable()
** 
** Description: Enables or disables display
*/
int seDisplayEnable(int seReserved1, BYTE NewState)
   {
   BYTE val;

   ASSERT( 0 == seReserved1 );

   val = ReadRegister(seReserved1, REG_DISPLAY_MODE);

   if (NewState)
      {
      if (UsingCrt)
         val |= 0x02;

      if (UsingLcd)
         val |= 0x01;
      }
   else
      val &= ~0x03;   /* Turn off CRT and LCD */

   WriteRegister(seReserved1, REG_DISPLAY_MODE, val);

   return ERR_OK;
   }

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

/*
** seDisplayFifo()
** 
** Description: Turns display FIFO on or off
*/
int seDisplayFifo(int seReserved1, BYTE NewState)
   {
   BYTE val;

   ASSERT( 0 == seReserved1 );

   val = ReadRegister(seReserved1, REG_PERF_ENHANCEMENT1);

   if (NewState)
      val &= ~0x80;   /* enable FIFO */
   else
      val |= 0x80;    /* disable FIFO */

   WriteRegister(seReserved1, REG_PERF_ENHANCEMENT1, val);

   return ERR_OK;
   }

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

/*
** seDelay()
**
** Most platforms don't have an easily accessable clock BUT I can get at
** the vertical non-display period status
*/
#ifdef INTEL

int seDelay(int seReserved1, DWORD Seconds)
   {
   time_t StartTime, CurrentTime;

   ASSERT ( 0 == seReserved1 );

   time(&StartTime);

   do
      time(&CurrentTime);
   while ((DWORD) CurrentTime < (DWORD) (StartTime + Seconds));

   /*
   // Only need "seReserved1" for embedded systems (see below).
   */
   seReserved1;

   return(ERR_OK);
   }

#else

int seDelay(int seReserved1, DWORD Seconds)
   {
   BYTE regDisplayMode, regVertNonDisp;
   DWORD FrameRate, count;
   extern LPHAL_STRUCT HalInfoArray[MAX_DEVICE];

   ASSERT ( 0 == seReserved1 );
   
   /*
   // Use VNDP Status as a timer for embedded systems.
   */

   /*
   // Don't delay if there has been a software/hardware suspend and the bus
   // returns 0x00 or 0xff.
   */
   regDisplayMode = ReadRegister(seReserved1, REG_DISPLAY_MODE);

   if ((regDisplayMode == 0) || (regDisplayMode == 0xff))
      return ERR_FAILED;

   /*
   // Get frame rate
   */
   switch (regDisplayMode & 0x03)
      {
      default:
         return ERR_FAILED;  /* CRT or panel must be enabled */
         break;

      case 1: /* PANEL */
         FrameRate = HalInfoArray[seReserved1]->wPanelFrameRate;
         break;

      case 2: /* CRT */
      case 3: /* SIMULTANEOUS */
         FrameRate = HalInfoArray[seReserved1]->wCrtFrameRate;
         break;
      }


   /*
   // Implement delay
   */
   for (count = FrameRate * Seconds; count > 0; --count)
      {
      do
         regVertNonDisp = ReadRegister(seReserved1, REG_VERT_NONDISP_PERIOD);
      while (!(regVertNonDisp & 0x80));  /* Get out of current VDP */

      do
         regVertNonDisp = ReadRegister(seReserved1, REG_VERT_NONDISP_PERIOD);
      while (regVertNonDisp & 0x80);     /* Get out of VNDP */
      }

   return ERR_OK;
   }

#endif

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

int seGetBytesPerScanline( int seReserved1, UINT *pBytes )
{
   UINT bpp;

   ASSERT (0 == seReserved1);

   /*
   ** Check if portrait mode
   */
   if (ReadRegister(seReserved1, REG_DISPLAY_MODE) & 0x80)
      {
      seGetBitsPerPixel(seReserved1, &bpp);

      switch (bpp)
         {    
         case 8:
            *pBytes = 1024;
            break;

         case 15:
         case 16:
            *pBytes = 1024*2;
            break;

         default:
            *pBytes = 0;
            return ERR_FAILED;
            break;
         }
      }
   else
      {
      *pBytes = (UINT) (((DWORD) ReadRegister(seReserved1, REG_MEM_ADDR_OFFSET0) |
               (ReadRegister(seReserved1, REG_MEM_ADDR_OFFSET1) << 8)) * 2);
               
      if (*pBytes == 0)
         *pBytes = 1;
      }

   return ERR_OK;
}

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

int seGetScreenSize( int seReserved1, UINT *width, UINT *height )
{
   UINT tmp;

   ASSERT (0 == seReserved1);
   
   *width = (ReadRegister( seReserved1, REG_HORZ_DISP_WIDTH ) + 1) * 8;

   *height = (ReadRegister( seReserved1, REG_VERT_DISP_HEIGHT0 ) |
             (ReadRegister( seReserved1, REG_VERT_DISP_HEIGHT1 ) << 8)) + 1;

   /*
   ** If only the panel is enabled, and it is a dual panel,
   ** double the height.
   */
   if ((ReadRegister(seReserved1, REG_DISPLAY_MODE) & 0x03) == 0x01)  /* only the panel is enabled */
      {
      if (ReadRegister(seReserved1, REG_PANEL_TYPE) & 0x02)  /* dual panel */
         *height *= 2;
      }

   /*
   ** If portrait mode, swap width and height.
   */
   if (ReadRegister(seReserved1, REG_DISPLAY_MODE) & 0x80)
      {
      tmp = *width;
      *width = *height;
      *height = tmp;
      }

   return ERR_OK;
}

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

int seSWSuspend(int seReserved1, BOOL val)
   {
   BYTE regPowerSaveConfig;

   ASSERT ( 0 == seReserved1 );

   regPowerSaveConfig = ReadRegister(seReserved1, REG_POWER_SAVE_CONFIG);

   if (val == TRUE)
      regPowerSaveConfig |= 0x01;
   else
      regPowerSaveConfig &= ~0x01;

   WriteRegister(seReserved1, REG_POWER_SAVE_CONFIG, regPowerSaveConfig);

   return ERR_OK;
   }

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

int seHWSuspend(int seReserved1, BOOL val)
   {
//	BYTE tmp;

   ASSERT ( 0 == seReserved1 );


//#ifdef INTEL
//	if (val == TRUE)
//		tmp = *(LPBYTE)SuspendLogicalAddr;
//	else
//		*(LPBYTE)SuspendLogicalAddr = 0;
//#endif

   /*
   ** Prevent warning message that seReserved1 isn't used.
   */
   seReserved1;

   return ERR_OK;
   }

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

int seSelectBusWidth(int seReserved1, int width)
   {
//	BYTE tmp;

   ASSERT ( 0 == seReserved1 );
   ASSERT ( (8 == width) || (16 == width) );

//#ifdef INTEL
//   switch (width)
//      {
//      case 8:
//		tmp = *(LPBYTE)(SuspendLogicalAddr + 0x80000);
//         return ERR_OK;
//         break;
//
//      case 16:
//         *(LPBYTE)(SuspendLogicalAddr + 0x80000) = 0;
//         return ERR_OK;
//         break;
//
//      default:
//         return ERR_FAILED;
//         break;
//      }
//#endif

   /*
   ** Prevent warning message that seReserved1 isn't used.
   */
   seReserved1;

   return ERR_FAILED;
   }

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