hal_misc.c

epson 13506 driver code

      _AutoAllocDualPanelBufferAddr = seVmemAllocDualPanelBuffer(size);

#ifdef INTEL_DOS
      if (_AutoAllocDualPanelBufferAddr == -1)
         return ERR_NOT_ENOUGH_MEMORY;
#else
      if (_AutoAllocDualPanelBufferAddr == 0)
         return ERR_NOT_ENOUGH_MEMORY;
#endif
      }
#endif   // "endif" for "ifdef IDP68K"

   return ERR_OK;
}

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

DWORD _CalcDualPanelBufferSize(void)
{
   DWORD width, height;

   /*
   ** If single panel, there is no dual panel buffer.
   */
   if ((seReadRegByte(REG_PANEL_TYPE) & 0x02) == 0)
      return 0;

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

   if (seReadRegByte(REG_PANEL_TYPE) & 0x04)  /* color */
      return((width * height * 4L) / 16L);
   else
      return((width * height) / 16L);
}

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

int _AllocDualPanelBuffer(DWORD size)
{
   if (seVmemAllocDualPanelBuffer(size) != 0)
      return ERR_OK;
   else
      return ERR_FAILED;
}

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

DWORD seSetLcdBitsPerPixel(unsigned nBitsPerPixel)
{
   unsigned regLcdDisplayMode;
   unsigned BPP = 0;
   unsigned nHeight, nWidth;
   DWORD lLength;
   unsigned nPelsPerWord;
   DWORD MemAddressOffset;
   int i;
   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;
      }


   _ActiveImageSurface = &_LcdSurface;

   _LcdSurface.DisplayMode = LCD;

   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
   */
   if ((seGetLcdOrientation() & ROTATE90) &&
       (nBitsPerPixel != 8) && (nBitsPerPixel != 15) && (nBitsPerPixel != 16))
      return 0;


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

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

   _LcdSurface.LinearAddress = 0;
   _LcdSurface.OffsetAddress = 0;
   _LcdSurface.DisplayMemorySize = 0;

   /*
   ** Ensure that LCD image starts at the beginning of display buffer memory by freeing 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)
      nHeight = 1024;

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

   _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;

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

   regLcdDisplayMode = seReadRegByte(REG_LCD_DISPLAY_MODE);

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

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

   /*
   ** Set up new Memory Address Offset
   */
   seGetLcdResolution(&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;

   seWriteRegWord(REG_LCD_MEM_ADDR_OFFSET0, MemAddressOffset);


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

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

   /*
   ** Set the LUT to default values.
   */
   if (seReadRegByte(REG_PANEL_TYPE) & 0x04)  /* color */
      {
      switch (nBitsPerPixel)
         {
         case 4:
            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;
}

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

DWORD seSetCrtBitsPerPixel(unsigned nBitsPerPixel)
{
   unsigned BPP = 0;
   unsigned nHeight, nWidth;
   DWORD lLength;
   unsigned nPelsPerWord;
   DWORD MemAddressOffset;
   unsigned regCrtTvDisplayMode;
   unsigned regDisplayMode;


   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;
      }


   _ActiveImageSurface = &_CrtTvSurface;

   // If in rotate90 mode, get into landscape mode
   regDisplayMode = seReadRegByte(REG_DISPLAY_MODE);
   seWriteRegByte(REG_DISPLAY_MODE, regDisplayMode & ~0x40);


   _CrtTvSurface.DisplayMode = CRT;

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


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

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

   _CrtTvSurface.OffsetAddress = 0;
   _CrtTvSurface.DisplayMemorySize = 0;

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

   _CrtTvSurface.LinearAddress = seVmemAlloc(lLength);


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

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

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

   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
   */
   seGetCrtResolution(&nWidth, &nHeight);


   /*
   ** Memory Address Offset = width / # pixels per word
   */
   MemAddressOffset = nWidth / nPelsPerWord;

   seWriteRegWord(REG_CRTTV_MEM_ADDR_OFFSET0, MemAddressOffset);


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

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

   switch (nBitsPerPixel)
      {
      case 4:
         seWriteCrtLut( LUT4_Color, 16 );
         break;

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

      default:
         break;
      }

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

   return _CrtTvSurface.LinearAddress;
}

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

DWORD seSetTvBitsPerPixel(unsigned nBitsPerPixel)
   {
   DWORD addr = seSetCrtBitsPerPixel(nBitsPerPixel);

   _CrtTvSurface.DisplayMode = TV;

   return addr;
   }

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

// Set bpp for one surface with LCD & CRT
DWORD seSetLcdCrtBitsPerPixel(unsigned nBitsPerPixel)
{
   unsigned regLcdDisplayMode;
   unsigned regCrtTvDisplayMode;
   unsigned BPP = 0;
   unsigned LcdWidth, LcdHeight;
   unsigned CrtWidth, CrtHeight;
   DWORD LcdLength, CrtLength;
   DWORD lLength;
   unsigned nPelsPerWord;
   DWORD MemAddressOffset;
   int i;
   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;
      }


   _ActiveImageSurface = &_LcdSurface;

   _LcdSurface.DisplayMode = LCD;

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


   /*
   ** Cancel ROTATE90 mode
   */
   seWriteRegByte(REG_DISPLAY_MODE, seReadRegByte(REG_DISPLAY_MODE) & ~0x40);
   

   /*
   ** Get current width and height
   */
   seGetLcdResolution(&LcdWidth, &LcdHeight);
   seGetCrtResolution(&CrtWidth, &CrtHeight);

   /*
   ** Free any memory allocated to these surfaces.
   */
   // Free LCD memory
#ifdef INTEL_DOS
   seVmemFree(_LcdSurface.LinearAddress);
#else
   if (_LcdSurface.LinearAddress > 0)