hal_misc.c

epson 13506 driver code

      seVmemFree(_LcdSurface.LinearAddress);
#endif
   
   _LcdSurface.LinearAddress = 0;
   _LcdSurface.OffsetAddress = 0;
   _LcdSurface.DisplayMemorySize = 0;
   

   // Free CRT/TV memory
#ifdef INTEL_DOS
   seVmemFree(_CrtTvSurface.LinearAddress);
#else
   if (_CrtTvSurface.LinearAddress > 0)
      seVmemFree(_CrtTvSurface.LinearAddress);
#endif
   
   _CrtTvSurface.LinearAddress = 0;
   _CrtTvSurface.OffsetAddress = 0;
   _CrtTvSurface.DisplayMemorySize = 0;


   // Free LCD Ink Layer/Cursor
#ifdef INTEL_DOS
   seVmemFree(_LcdInkCursor.LinearAddress);
#else
   if (_LcdInkCursor.LinearAddress > 0)
      seVmemFree(_LcdInkCursor.LinearAddress);
#endif

   _LcdInkCursor.LinearAddress = 0;
   _LcdInkCursor.OffsetAddress = 0;


   // Free CRT/TV Ink Layer/Cursor
#ifdef INTEL_DOS
   seVmemFree(_CrtTvInkCursor.LinearAddress);
#else
   if (_CrtTvInkCursor.LinearAddress > 0)
      seVmemFree(_CrtTvInkCursor.LinearAddress);
#endif

   _CrtTvInkCursor.LinearAddress = 0;
   _CrtTvInkCursor.OffsetAddress = 0;


   if (seGetLcdOrientation() & ROTATE90)
      LcdHeight = 1024;

   /*
   ** Allocate memory for the new mode.
   */
   LcdLength = LcdWidth * LcdHeight / nPelsPerWord * 2;  /* length in bytes */
   CrtLength = CrtWidth * CrtHeight / nPelsPerWord * 2;  /* length in bytes */

   if (LcdLength > CrtLength)
      lLength = LcdLength;
   else
      lLength = CrtLength;

   _LcdSurface.LinearAddress = seVmemAlloc(lLength);


#ifdef INTEL_DOS
   if (_LcdSurface.LinearAddress == -1)
      return -1;
#else
   if (_LcdSurface.LinearAddress == 0)
      return 0;
#endif

   _LcdSurface.OffsetAddress = _LcdSurface.LinearAddress - _DispLinearAddress;
   _LcdSurface.DisplayMemorySize = lLength;

   _CrtTvSurface.LinearAddress = _LcdSurface.LinearAddress;
   _CrtTvSurface.OffsetAddress = _LcdSurface.OffsetAddress;
   _CrtTvSurface.DisplayMemorySize = _LcdSurface.DisplayMemorySize;

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

   regLcdDisplayMode = seReadRegByte(REG_LCD_DISPLAY_MODE);
   regCrtTvDisplayMode = seReadRegByte(REG_CRTTV_DISPLAY_MODE);

   /*
   ** Change bits-per-pixel
   */
   regLcdDisplayMode &= ~0x07;  /* Clear bits for BPP */
   regLcdDisplayMode |= BPP;
   seWriteRegByte( REG_LCD_DISPLAY_MODE, regLcdDisplayMode );

   regCrtTvDisplayMode &= ~0x07;  /* Clear bits for BPP */
   regCrtTvDisplayMode |= BPP;
   seWriteRegByte( REG_CRTTV_DISPLAY_MODE, regCrtTvDisplayMode );

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

   /*
   ** Set up new Memory Address Offset
   */


   /*
   ** Memory Address Offset = width / # pixels per word
   */
   MemAddressOffset = LcdWidth / nPelsPerWord;
   seWriteRegWord(REG_LCD_MEM_ADDR_OFFSET0, MemAddressOffset);

   MemAddressOffset = CrtWidth / nPelsPerWord;
   seWriteRegWord(REG_CRTTV_MEM_ADDR_OFFSET0, MemAddressOffset);


   // Reset pan and scroll; do not wait on VNDP
   _PanScroll(0, 0, FALSE, &_LcdSurface);
   _PanScroll(0, 0, FALSE, &_CrtTvSurface);

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

   /*
   ** Set the LUT to default values.
   */
   // CRT/TV LUT
   switch (nBitsPerPixel)
      {
      case 4:
         seWriteCrtLut( LUT4_Color, 16 );
         seWriteCrtLut( LUT4_Color, 16 );
         break;

      case 8:
         seWriteCrtLut( LUT8_Color, 256 );
         break;

      default:
         break;
      }


   // LCD LUT
   if (seReadRegByte(REG_PANEL_TYPE) & 0x04)  /* color */
      {
      switch (nBitsPerPixel)
         {
         case 4:
            seWriteLcdLut( LUT4_Color, 16 );
            seWriteLcdLut( LUT4_Color, 16 );
            break;

         case 8:
            seWriteLcdLut( LUT8_Color, 256 );
            break;

         default:
            break;
         }
      }
   else switch (nBitsPerPixel)   /* mono */
      {
      case 4:
         for (i = 0; i < 16; ++i)
            {
            color[HAL_RED] = (BYTE) (i << 4);
            color[HAL_GREEN] = (BYTE) (i << 4);
            color[HAL_BLUE] = (BYTE) (i << 4);
            seWriteLcdLutEntry( i, color );
            }
         break;

      case 8:
         for (i = 0; i < 256; ++i)
            {
            color[HAL_RED] = (BYTE) (i << 4);
            color[HAL_GREEN] = (BYTE) (i << 4);
            color[HAL_BLUE] = (BYTE) (i << 4);
            seWriteLcdLutEntry( i, color );
            }
         break;

      default:
         break;
      }


   return _LcdSurface.LinearAddress;
}

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

// Set bpp for one surface with LCD & TV
DWORD seSetLcdTvBitsPerPixel(unsigned nBitsPerPixel)
{
   DWORD addr;

   addr = seSetLcdCrtBitsPerPixel(nBitsPerPixel);
   _CrtTvSurface.DisplayMode = TV;
   return addr;
}
/*-------------------------------------------------------------------------*/

DWORD seSetBitsPerPixel(unsigned nBitsPerPixel)
{
   unsigned regLcdDisplayMode;
   unsigned regCrtTvDisplayMode;
   unsigned regDisplayMode;
   unsigned BPP = 0;
   unsigned nHeight, nWidth;
   DWORD lLength;
   unsigned nPelsPerWord;
   DWORD MemAddressOffset;
   int i;
   unsigned orientation;
   BYTE color[3];


   if (_AutoAllocDualPanelBuffer() != ERR_OK)
      return 0;

   /*
   ** Calculate the register BPP value.
   */
   switch (nBitsPerPixel)
      {
      case 4:
         BPP = 0x02;
         break;

      case 8:
         BPP = 0x03;
         break;

      case 15:
         BPP = 0x04;
         break;

      case 16:
         BPP = 0x05;
         break;

      default:  /* This default case should not be necessary. */
         return 0;
      }


   // If in rotate90 mode for CRT/TV, get into landscape mode
   regDisplayMode = seReadRegByte(REG_DISPLAY_MODE);

   if (_ActiveImageSurface->DisplayMode & (CRT | TV))
      seWriteRegByte(REG_DISPLAY_MODE, regDisplayMode & ~0x40);


   if (nBitsPerPixel == 15)  /* 15 and 16 bpp are treated the same */
      nPelsPerWord = 1;
   else
      nPelsPerWord = 16 / nBitsPerPixel;


   /*
   ** If in rotate90 mode, only support 8/15/16 bpp
   */
   orientation = LANDSCAPE;

   if (_ActiveImageSurface->DisplayMode & LCD)
      orientation = seGetLcdOrientation();

   if ((orientation & ROTATE90) &&
       (nBitsPerPixel != 8) && (nBitsPerPixel != 15) && (nBitsPerPixel != 16))
      {
      // Restore previous mode (rotate90 or landscape)
      seWriteRegByte(REG_DISPLAY_MODE, regDisplayMode);
      return 0;
      }


   /*
   ** Get current width and height
   */
   seGetResolution(&nWidth, &nHeight);

   /*
   ** Free any memory allocated to this surface.
   */
#ifdef INTEL_DOS
   seVmemFree(_ActiveImageSurface->LinearAddress);
#else
   if (_ActiveImageSurface->LinearAddress > 0)
      seVmemFree(_ActiveImageSurface->LinearAddress);
#endif

   _ActiveImageSurface->OffsetAddress = 0;
   _ActiveImageSurface->DisplayMemorySize = 0;

   /*
   ** Must free CRT/TV memory if LCD bpp is changed.
   ** This ensures that the LCD image is at the beginning of display buffer memory.
   */
   if (_ActiveImageSurface->DisplayMode & LCD)
      {
      // Free CRT/TV memory
#ifdef INTEL_DOS
      seVmemFree(_CrtTvSurface.LinearAddress);
#else
      if (_CrtTvSurface.LinearAddress > 0)
         seVmemFree(_CrtTvSurface.LinearAddress);
#endif
   
      _CrtTvSurface.LinearAddress = 0;
      _CrtTvSurface.OffsetAddress = 0;
      _CrtTvSurface.DisplayMemorySize = 0;


      // Free LCD Ink Layer/Cursor
#ifdef INTEL_DOS
      seVmemFree(_LcdInkCursor.LinearAddress);
#else
      if (_LcdInkCursor.LinearAddress > 0)
         seVmemFree(_LcdInkCursor.LinearAddress);
#endif

      _LcdInkCursor.LinearAddress = 0;
      _LcdInkCursor.OffsetAddress = 0;


      // Free CRT/TV Ink Layer/Cursor
#ifdef INTEL_DOS
      seVmemFree(_CrtTvInkCursor.LinearAddress);
#else
      if (_CrtTvInkCursor.LinearAddress > 0)
         seVmemFree(_CrtTvInkCursor.LinearAddress);
#endif

      _CrtTvInkCursor.LinearAddress = 0;
      _CrtTvInkCursor.OffsetAddress = 0;
      }


   if ((_ActiveImageSurface->DisplayMode & LCD) && (orientation & ROTATE90))
      nHeight = 1024;

   /*
   ** Allocate memory for the new mode.
   */
   lLength = nWidth * nHeight / nPelsPerWord * 2;  /* length in bytes */

   _ActiveImageSurface->LinearAddress = seVmemAlloc(lLength);

#ifdef INTEL_DOS
   if (_ActiveImageSurface->LinearAddress == -1)
      {
      // Restore previous mode (rotate90 or landscape)
      seWriteRegByte(REG_DISPLAY_MODE, regDisplayMode);
      return -1;
      }
#else
   if (_ActiveImageSurface->LinearAddress == 0)
      {
      // Restore previous mode (rotate90 or landscape)
      seWriteRegByte(REG_DISPLAY_MODE, regDisplayMode);
      return 0;
      }
#endif

   _ActiveImageSurface->OffsetAddress = _ActiveImageSurface->LinearAddress - _DispLinearAddress;
   _ActiveImageSurface->DisplayMemorySize = lLength;

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

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

      /*
      ** Change bits-per-pixel
      */
      regLcdDisplayMode &= ~0x07;  /* Clear bits for BPP */
      regLcdDisplayMode |= BPP;
      seWriteRegByte( REG_LCD_DISPLAY_MODE, regLcdDisplayMode );
      }


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

      /*
      ** Change bits-per-pixel
      */
      regCrtTvDisplayMode &= ~0x07;  /* Clear bits for BPP */
      regCrtTvDisplayMode |= BPP;
      seWriteRegByte( REG_CRTTV_DISPLAY_MODE, regCrtTvDisplayMode );
      }

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

   /*
   ** Set up new Memory Address Offset
   */
   seGetResolution( &nWidth, &nHeight );


   /*
   ** Memory Address Offset = width / # pixels per word
   */

   /*
   ** If rotate90 mode, the virtual width is always 1024.
   */
   if (seReadRegByte(REG_DISPLAY_MODE) & 0x40)
      {
      MemAddressOffset = 1024/nPelsPerWord;
      nHeight = 1024;
      }
   else
      MemAddressOffset = nWidth / nPelsPerWord;

   if (_ActiveImageSurface->DisplayMode & LCD)
      seWriteRegWord(REG_LCD_MEM_ADDR_OFFSET0, MemAddressOffset);

   if (_ActiveImageSurface->DisplayMode & (CRT | TV))
      seWriteRegWord(REG_CRTTV_MEM_ADDR_OFFSET0, MemAddressOffset);


   // Reset pan and scroll; do not wait on VNDP
   _PanScroll(0, 0, FALSE, _ActiveImageSurface);

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

   /*
   ** Set the LUT to default values.
   */
   if ((seReadRegByte(REG_PANEL_TYPE) & 0x04)  ||   // color
       (_ActiveImageSurface->DisplayMode & (CRT | TV)))
      {
      switch (nBitsPerPixel)
         {
         case 4:
            seWriteLut( LUT4_Color, 16 );
            break;

         case 8:
            seWriteLut( LUT8_Color, 256 );
            break;

         default:
            break;
         }
      }
   else switch (nBitsPerPixel)   /* mono */
      {
      case 4:
         for (i = 0; i < 16; ++i)
            {
            color[HAL_RED] = (BYTE) (i << 4);
            color[HAL_GREEN] = (BYTE) (i << 4);
            color[HAL_BLUE] = (BYTE) (i << 4);
            seWriteLutEntry( i, color );
            }
         break;

      case 8:
         for (i = 0; i < 256; ++i)
            {
            color[HAL_RED] = (BYTE) (i << 4);
            color[HAL_GREEN] = (BYTE) (i << 4);
            color[HAL_BLUE] = (BYTE) (i << 4);
            seWriteLutEntry( i, color );
            }
         break;

      default:
         break;
      }


   // Restore previous mode (rotate90 or landscape)
   seWriteRegByte(REG_DISPLAY_MODE, regDisplayMode);

   return _ActiveImageSurface->LinearAddress;
}

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

unsigned seGetLcdBitsPerPixel(void)
{
   int val;

   val = seReadRegByte(REG_LCD_DISPLAY_MODE) & 0x07;

   switch (val)
      {
      case 0x02:
         return 4;

      case 0x03:
         return 8;

      case 0x04:
         return 15;

      case 0x05:
         return 16;

      default:
         return 0;
      }
}

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

unsigned seGetCrtBitsPerPixel(void)
{
   int val;

   val = seReadRegByte(REG_CRTTV_DISPLAY_MODE) & 0x07;

   switch (val)
      {
      case 0x02:
         return 4;

      case 0x03:
         return 8;

      case 0x04:
         return 15;

      case 0x05: