hal_misc.c

epson 13506 driver code

         return 16;

      default:
         return 0;
      }
}

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

unsigned seGetTvBitsPerPixel(void)
   {
   return seGetCrtBitsPerPixel();
   }

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

/*
** If a surface has more than one display device (such as LCD and CRT),
** seGetBitsPerPixel() reads the BPP from the LCD.
*/
unsigned seGetBitsPerPixel(void)
{
   if (_ActiveImageSurface->DisplayMode & LCD)
      return seGetLcdBitsPerPixel();
   else if (_ActiveImageSurface->DisplayMode & (CRT | TV))
      return seGetCrtBitsPerPixel();
   else
      return 0;
}

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

/*
** seGetAvailableMemorySize()
** 
** Description: Returns the last available byte of display memory before
**              the dual panel buffer. This function does not rely
**              on the display surface structure.
*/
DWORD seGetAvailableMemorySize(void)
{
   DWORD Mem;
   DWORD SizeDualPanel;

   SizeDualPanel = seVmemGetDualPanelBufferSize();
   Mem = _MemorySize;

   if (SizeDualPanel <= Mem)
      return Mem - SizeDualPanel;
   else
      return 0;
}

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


/*
** seDisplayBlank()
** 
** Description: Blanks display
*/
void seDisplayBlank(BOOL activate)
   {
   _DisplayFifo(!activate);
   }

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

void seDisplayLcdBlank(BOOL activate)
   {
   _DisplayLcdFifo(!activate);
   }

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

void seDisplayCrtBlank(BOOL activate)
   {
   _DisplayCrtFifo(!activate);
   }

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

void seDisplayTvBlank(BOOL activate)
   {
   _DisplayTvFifo(!activate);
   }

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

void seLcdDisplayEnable(BOOL activate)
   {
   unsigned regDisplayMode;

   regDisplayMode = seReadRegByte(REG_DISPLAY_MODE);

   if (activate)
      regDisplayMode |= LCD;
   else
      regDisplayMode &= ~LCD;

   seWriteRegByte(REG_DISPLAY_MODE, regDisplayMode);
   }

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

void seCrtDisplayEnable(BOOL activate)
   {
   unsigned regDisplayMode;

   regDisplayMode = seReadRegByte(REG_DISPLAY_MODE);

   /*
   ** Must also disable *2 clock; this clock must only be used for TV
   */
   seWriteRegByte(REG_CRTTV_PCLK_CFG, seReadRegByte(REG_CRTTV_PCLK_CFG) & ~0x80);

   regDisplayMode &= ~TV;

   if (activate)
      {
      // Ensure that TV PAL/NTSC bit is set to 0 when CRT mode enabled
      seWriteRegByte(REG_TV_OUTPUT_CTRL, seReadRegByte(REG_TV_OUTPUT_CTRL) & ~0x01);

      regDisplayMode |= CRT;
      }
   else
      regDisplayMode &= ~CRT;

   seWriteRegByte(REG_DISPLAY_MODE, regDisplayMode);
   }

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

void seTvDisplayEnable(BOOL activate)
   {
   unsigned regDisplayMode;

   /*
   ** Enable/disable TV
   */
   regDisplayMode = seReadRegByte(REG_DISPLAY_MODE);

   if (activate)
      {
      regDisplayMode |= TV;

      if (_HalInfo->wTVFlickerFilter)
         {
         /*
         ** Must also enable *2 clock; this clock must only be used for TV
         */
         seWriteRegByte(REG_CRTTV_PCLK_CFG, seReadRegByte(REG_CRTTV_PCLK_CFG) | 0x80);
         regDisplayMode |= CRT;
         }
      else
         {
         /*
         ** Must also disable *2 clock; this clock must only be used for TV
         */
         seWriteRegByte(REG_CRTTV_PCLK_CFG, seReadRegByte(REG_CRTTV_PCLK_CFG) & ~0x80);
         regDisplayMode &= ~CRT;
         }
      }
   else
      {
      /*
      ** Must also disable *2 clock; this clock must only be used for TV
      */
      seWriteRegByte(REG_CRTTV_PCLK_CFG, seReadRegByte(REG_CRTTV_PCLK_CFG) & ~0x80);
      regDisplayMode &= ~(TV | CRT);
      }

   seWriteRegByte(REG_DISPLAY_MODE, regDisplayMode);
   }

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

/*
** seDisplayEnable()
** 
** Description: Enables or disables display
*/
void seDisplayEnable(BOOL activate)
   {
   int DisplayMode;

   DisplayMode = _ActiveImageSurface->DisplayMode;

   if (DisplayMode & LCD)
      seLcdDisplayEnable(activate);

   if (DisplayMode & TV)
      seTvDisplayEnable(activate);
   else if (DisplayMode & CRT)
      seCrtDisplayEnable(activate);
   }

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

/*
** _DisplayLcdFifo()
** 
** Description: Turns LCD display FIFO on or off
*/
void _DisplayLcdFifo(BOOL activate)
   {
   unsigned val;

   val = seReadRegByte(REG_LCD_DISPLAY_MODE);

   if (activate)
      val &= ~0x80;
   else
      val |= 0x80;

   seWriteRegByte(REG_LCD_DISPLAY_MODE, val);
   }

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

/*
** _DisplayCrtFifo()
** 
** Description: Turns CRT display FIFO on or off
*/
void _DisplayCrtFifo(BOOL activate)
   {
   unsigned val;

   val = seReadRegByte(REG_CRTTV_DISPLAY_MODE);

   if (activate)
      val &= ~0x80;
   else
      val |= 0x80;

   seWriteRegByte(REG_CRTTV_DISPLAY_MODE, val);
   }

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

/*
** _DisplayTvFifo()
** 
** Description: Turns TV display FIFO on or off
*/
void _DisplayTvFifo(BOOL activate)
   {
   _DisplayCrtFifo(activate);
   }

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

/*
** _DisplayFifo()
** 
** Description: Turns display FIFO on or off
*/
void _DisplayFifo(BOOL activate)
   {
   unsigned val;

   if (_ActiveImageSurface->DisplayMode & LCD)
      {
      val = seReadRegByte(REG_LCD_DISPLAY_MODE);

      if (activate)
         val &= ~0x80;
      else
         val |= 0x80;

      seWriteRegByte(REG_LCD_DISPLAY_MODE, val);
      }


   if (_ActiveImageSurface->DisplayMode & (CRT | TV))
      {
      val = seReadRegByte(REG_CRTTV_DISPLAY_MODE);

      if (activate)
         val &= ~0x80;
      else
         val |= 0x80;

      seWriteRegByte(REG_CRTTV_DISPLAY_MODE, val);
      }
   }

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

/*
** seDelay()
**
** Most platforms don't have an easily accessable clock BUT I can get at
** the vertical non-display period status. For non-Intel platforms,
** the active display device is used for timing (counting VNDP cycles).
*/
#if defined(INTEL_W32) || defined(INTEL_DOS)

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

   time(&StartTime);

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

   return(ERR_OK);
   }

#else

int seDelay(DWORD Seconds)
   {
   BYTE regDisplayMode, regVNDP;
   DWORD FrameRate, count;
   BYTE reg;

   /*
   ** Use VNDP Status as a timer for embedded systems.
   */

   /*
   ** Don't delay if in power save mode
   */
   if (seReadRegByte(REG_PWR_SAVE_CFG) & 0x01)
      return ERR_FAILED;

   /*
   ** Get frame rate
   */
   regDisplayMode = seReadRegByte(REG_DISPLAY_MODE);

   if (regDisplayMode & 0x01)
      {
      FrameRate = _HalInfo->wPanelFrameRate;
      reg = REG_LCD_VNDP;
      }
   else if (regDisplayMode & 0x06)
      {
      FrameRate = _HalInfo->wCrtTvFrameRate;
      reg = REG_CRTTV_VNDP;
      }
   else
      return ERR_FAILED;


   /*
   ** Implement delay
   */
   for (count = FrameRate * Seconds; count > 0; --count)
      {
      do
         regVNDP = seReadRegByte(reg);
      while (!(regVNDP & 0x80));  /* Get out of current VDP */

      do
         regVNDP = seReadRegByte(reg);
      while (regVNDP & 0x80);     /* Get out of VNDP */
      }

   return ERR_OK;
   }

#endif

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

unsigned seGetLcdBytesPerScanline(void)
{
   return seReadRegWord(REG_LCD_MEM_ADDR_OFFSET0) * 2;
}

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

unsigned seGetCrtBytesPerScanline(void)
{
   return seReadRegWord(REG_CRTTV_MEM_ADDR_OFFSET0) * 2;
}

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

unsigned seGetTvBytesPerScanline(void)
{
   return seReadRegWord(REG_CRTTV_MEM_ADDR_OFFSET0) * 2;
}

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

unsigned seGetBytesPerScanline(void)
{
   if (_ActiveImageSurface->DisplayMode & LCD)
      return seGetLcdBytesPerScanline();
   else if (_ActiveImageSurface->DisplayMode & (CRT | TV))
      return seGetCrtBytesPerScanline();
   else
      return 0;
}

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

void seGetLcdResolution(unsigned *width, unsigned *height)
{
   unsigned tmp;

   *width = (seReadRegByte(REG_LCD_HDP) + 1) * 8;
   *height = seReadRegWord(REG_LCD_VDP0) + 1;

   /*
   ** If rotate90 mode, swap width and height.
   */
   if (seReadRegByte(REG_DISPLAY_MODE) & 0x40)
      {
      tmp = *width;
      *width = *height;
      *height = tmp;
      }
}

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

void seGetCrtResolution(unsigned *width, unsigned *height)
{
   *width = (seReadRegByte(REG_CRTTV_HDP) + 1) * 8;
   *height = seReadRegWord(REG_CRTTV_VDP0) + 1;
}

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

void seGetTvResolution(unsigned *width, unsigned *height)
{
   seGetCrtResolution(width, height);
}

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

int seGetResolution( unsigned *width, unsigned *height )
{
   int DisplayMode;

   DisplayMode = _ActiveImageSurface->DisplayMode;
   
   if (DisplayMode & LCD)
      seGetLcdResolution(width, height);
   else if (DisplayMode & (CRT | TV))
      seGetCrtResolution(width, height);
   else
      {
      *width = 0;
      *height = 0;

      return ERR_FAILED;
      }

   return ERR_OK;
}

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

void seSetPowerSaveMode(BOOL enable)
   {
   unsigned regPwrSaveConfig;

   regPwrSaveConfig = seReadRegByte(REG_PWR_SAVE_CFG);

   if (enable)
      regPwrSaveConfig |= 0x01;
   else
      regPwrSaveConfig &= ~0x01;

   seWriteRegByte(REG_PWR_SAVE_CFG, regPwrSaveConfig);
   }

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

BOOL seGetPowerSaveMode(void)
   {
   if (seReadRegByte(REG_PWR_SAVE_CFG) & 0x01)
      return TRUE;
   else
      return FALSE;
   }

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

int seCheckEndian(BOOL *ReverseBytes)
   {
   BYTE str[2];
   WORD w = ENDIAN;
   
   str[0] = ((BYTE *) &w)[0];
   str[1] = ((BYTE *) &w)[1];

   if ((str[0] == (REV_ENDIAN & 0xff)) &&
       (str[1] == (REV_ENDIAN >> 8)))
      *ReverseBytes = TRUE;
   else
      *ReverseBytes = FALSE;

   return ERR_OK;
   }

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

unsigned seGetLcdOrientation(void)
   {
   unsigned orientation = LANDSCAPE;

   if (seReadRegByte(REG_DISPLAY_MODE) & 0x40)
      orientation |= ROTATE90;

   if (seReadRegByte(REG_LCD_DISPLAY_MODE) & 0x10)
      orientation |= ROTATE180;

   return orientation;
   }

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