show.c

epson 13506 driver code

         break;
      }

   printf("\n");
   }

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

void ExitBadConfiguration(unsigned DisplayMode)
{
   char str[10];

   if (DisplayMode & LCD)
      strcpy(str, "LCD");
   else if (DisplayMode & CRT)
      strcpy(str, "CRT");
   else if (DisplayMode & TV)
      strcpy(str, "TV");
   else
      return;
      
   printf("\nERROR: Program not configured for %s.", str);
   printf("\n       Run 13506CFG and configure for %s.\n", str);

   exit(1);
}

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

void CheckLcdOrientationForLandscape(void)
{
   if (seGetLcdOrientation() != LANDSCAPE)
      {
      printf("\nERROR: LCD must be in landscape mode.\n");

      // Turn off displays
      seLcdDisplayEnable(FALSE);
      seCrtDisplayEnable(FALSE);
      seTvDisplayEnable(FALSE);

      exit(1);
      }
}

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

void DisplayErrorNotEnoughMemory(unsigned BitsPerPixel)
{
   unsigned count = 0;
   unsigned DisplayMode = 0;
   char szErr[50];
   DisplayMode = GetSurfaceDisplayMode(GetActiveSurfaceNumber());
   szErr[0] = 0;
   count = 0;

   if (DisplayMode & LCD)
      {
      strcat(szErr, "LCD");
      ++count;
      }

   if (DisplayMode & CRT)
      {
      if (count > 0)
         strcat(szErr, ", ");

      strcat(szErr, "CRT");
      ++count;
      }

   if (DisplayMode & TV)
      {
      if (count > 0)
         strcat(szErr, ", ");

      strcat(szErr, "TV");
      ++count;
      }

   if (count == 0)
      strcpy(szErr, "NONE");

   printf(szModeFailed, szErr, BitsPerPixel);
}

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

void SetLcdBitsPerPixel(int BitsPerPixel)
{
#ifdef INTEL_DOS
   if (seSetLcdBitsPerPixel(BitsPerPixel) == -1)
      DisplayErrorNotEnoughMemory(BitsPerPixel);
#else
   if (seSetLcdBitsPerPixel(BitsPerPixel) == 0)
      DisplayErrorNotEnoughMemory(BitsPerPixel);
#endif
}

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

void SetCrtBitsPerPixel(int BitsPerPixel)
{
#ifdef INTEL_DOS
   if (seSetCrtBitsPerPixel(BitsPerPixel) == -1)
      DisplayErrorNotEnoughMemory(BitsPerPixel);
#else
   if (seSetCrtBitsPerPixel(BitsPerPixel) == 0)
      DisplayErrorNotEnoughMemory(BitsPerPixel);
#endif
}

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

void SetTvBitsPerPixel(int BitsPerPixel)
{
   SetCrtBitsPerPixel(BitsPerPixel);
}

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

void SetLcdCrtBitsPerPixel(int BitsPerPixel)
{
#ifdef INTEL_DOS
   if (seSetLcdCrtBitsPerPixel(BitsPerPixel) == -1)
      DisplayErrorNotEnoughMemory(BitsPerPixel);
#else
   if (seSetLcdCrtBitsPerPixel(BitsPerPixel) == 0)
      DisplayErrorNotEnoughMemory(BitsPerPixel);
#endif
}

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

void SetLcdTvBitsPerPixel(int BitsPerPixel)
{
   SetLcdCrtBitsPerPixel(BitsPerPixel);
}

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

int main( int argc, char *argv[] )
   {
   unsigned nBitsPerPixel[MAX_DISP_SURFACE];
   int surface;
   int GotDisplaySurfaceIndex = FALSE;

   int i;

   int *bpp;
   int BppSize;
   int LandscapeBpp[] = { 16, 15, 8, 4 };
   int k;
   int ch;
   unsigned regDisplayMode;
   char *szPressKey = "Press any key to continue...\n";
   char *szCrtTvInLandscapeMode = "\nWARNING: CRT/TV only available in LANDSCAPE mode.\n";
   char szBad_iDisplay[] = "\nERROR: Invalid display surface number.\n";
   char *pStr;
   int iDisplay = -1;
   int LcdBitsPerPixel = 0;
   int CrtTvBitsPerPixel = 0;
   unsigned regLcdDisplayMode;
   unsigned width1, height1;
   unsigned width2, height2;
   unsigned DisplayMode = 0;
   unsigned ConfiguredBpp = 0;

   bpp = LandscapeBpp;
   BppSize = sizeof(LandscapeBpp) / sizeof(LandscapeBpp[0]);
   ShowAllBppModes = TRUE;
   SelectedLcdBppMode = FALSE;

   gnUseVertical     = FALSE;
   gnInitRegisters   = TRUE;
   gnAutoRun         = FALSE; 
   gnContinualScrnRead  = FALSE;
   gnContinualScrnWrite = FALSE;
   gnShowGrid        = FALSE;
   gnUpdateDisplayMemory = TRUE;
   NumberOfSurfaces  = 0;
   CommonMemoryBlockForAllDisplays = FALSE;
   LcdOrientation    = LANDSCAPE;
   DisplaySurfaceCombination = SURFACE_NONE;

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

   for (surface = 0; surface < MAX_DISP_SURFACE; ++surface)
      {
      nBitsPerPixel[surface] = 0;  /* 0 means show all bits-per-pixel modes. */
      Orientation[surface] = LANDSCAPE;
      SurfaceDisplayMode[surface] = 0;
      }

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

   DisplayCopyright();


   /*
   ** Parse the command line.
   */
   for (i = 1; i < argc; ++i)
      {
      strupr(argv[i]);

      if (('/' == *argv[i]) || ('-' == *argv[i]))
         {
         argv[i]++;

         if (!strcmpi( argv[i], "?" ))
            {
            DisplayUsage( );
            return 0;
            }
         else if (!strcmpi( argv[i], "A" ))
            {
            gnAutoRun = 1;
            }
         else if (!strcmpi( argv[i], "G" ))
            {
            gnShowGrid = TRUE;
            }
         else if (!strcmpi( argv[i], "S" ))
            {
            gnUseVertical = TRUE;
            }
         else if (!strcmpi( argv[i], "READ" ))
            {
            gnContinualScrnRead = TRUE;
            }
         else if (!strcmpi( argv[i], "WRITE" ))
            {
            gnContinualScrnWrite = TRUE;
            }
         else if ( !strcmpi( argv[i], "NOINIT" ))
            {
            gnInitRegisters = FALSE;
            }
         else if ( !strcmpi( argv[i], "R90" ))
            {
            LcdOrientation |= ROTATE90;
            }
         else if ( !strcmpi( argv[i], "R180" ))
            {
            LcdOrientation |= ROTATE180;
            }
         else if ( !strcmpi( argv[i], "R270" ))
            {
            LcdOrientation |= ROTATE270;
            }
         else
            {
            DisplayUsage( );
            return 1;
            }
         }
      else if (!strncmp(argv[i], "BL=", 3))
         {
         LcdBitsPerPixel = atoi( &argv[i][3] );

         switch (LcdBitsPerPixel)
            {
            case 4:
            case 8:
            case 15:
            case 16:
               ShowAllBppModes = FALSE;
               SelectedLcdBppMode = TRUE;
               break;

            default:
               DisplayUsage( );
               return 1;
            }
         }
      else if (!strncmp(argv[i], "BC=", 3))
         {
         CrtTvBitsPerPixel = atoi( &argv[i][3] );

         switch (CrtTvBitsPerPixel)
            {
            case 4:
            case 8:
            case 15:
            case 16:
               ShowAllBppModes = FALSE;
            break;

            default:
               DisplayUsage( );
               return 1;
            }
         }
      else if (!strncmp(argv[i], "DS=", 3))
         {
         if (argv[i][3] == '?')
            {
            DisplaySurfaceHelp();
            return 0;
            }

         iDisplay = atoi(&argv[i][3]);

         if ((iDisplay >= 0) && (iDisplay <= 6))
            GotDisplaySurfaceIndex = TRUE;
         else
            {
            printf("%s", szBad_iDisplay);
            return 1;
            }
         }
      else
         {
         DisplayUsage( );
         return 1;
         }
      }

   if (gnContinualScrnRead)
      {
      if (gnAutoRun)
         {
         DisplayUsage( );
         printf( "ERROR: Continual screen read will not work with the /a switch.\n" );
         return 1;
         }
      }

   if (gnContinualScrnWrite)
      {
      if (gnAutoRun)
         {
         DisplayUsage( );
         printf( "ERROR: Continual screen write will not work with the /a switch.\n" );
         return 1;
         }
      }


   switch (seRegisterDevice(&HalInfo))
      {
      case ERR_OK:
         break;

#ifdef INTEL_W32
      case ERR_PCI_DRIVER_NOT_FOUND:
         printf("ERROR: PCI driver not found.\n");
         return 1;

      case ERR_PCI_BRIDGE_ADAPTER_NOT_FOUND:
         printf("ERROR: PCI bridge adapter not found.\n");
         return 1;
#endif

      case ERR_UNKNOWN_DEVICE:
         printf("ERROR: Could not detect S1D13506.\n");
         return 1;
      
      default:
         printf("ERROR: Could not map memory from evaluation board to host platform.\n");
         return 1;
      }



   if (((LcdBitsPerPixel != 0) || (CrtTvBitsPerPixel != 0)) && !gnInitRegisters)
      {
      printf("ERROR: bl= and bc= options cannot be used with /noinit.\n");
      exit(1);
      }


   if (gnInitRegisters)
      {
      switch (iDisplay)
         {
         case 0:
            DisplayMode = LCD;
            break;

         case 1:
            DisplayMode = CRT;
            break;

         case 2:
            DisplayMode = TV;
            break;

         case 3:
         case 5:
            DisplayMode = LCD | CRT;
            break;

         case 4:
         case 6:
            DisplayMode = LCD | TV;

            if (HalInfo.wTVFlickerFilter)
               DisplayMode |= CRT;
            break;

         default:
            DisplayMode = 0;
            break;
         }

      switch (seInitReg(DisplayMode, CLEAR_MEM | DISP_BLANK))
         {
         case ERR_OK:
            break;

         case ERR_CLKI_NOT_IN_TABLE:
            printf("WARNING: CLKI frequency not in HAL table.\n"
                   "         Program assumes that external oscillator is used.\n");
            break;

         case ERR_CLKI2_NOT_IN_TABLE:
            printf("WARNING: CLKI2 frequency not in HAL table.\n"
                   "         Program assumes that external oscillator is used.\n");
            break;

         case ERR_NOT_ENOUGH_MEMORY:
            printf("\nERROR: Not enough display buffer memory.\n");
            return 1;
            break;
         }
      }
   else
      {
      LcdOrientation = LANDSCAPE;

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

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


   regDisplayMode = seReadRegByte(REG_DISPLAY_MODE);

   if (LcdOrientation & ROTATE90)
      seWriteRegByte(REG_DISPLAY_MODE, regDisplayMode | 0x40);
   else
      seWriteRegByte(REG_DISPLAY_MODE, regDisplayMode & ~0x40);


   regLcdDisplayMode = seReadRegByte(REG_LCD_DISPLAY_MODE);

   if (LcdOrientation & ROTATE180)
      seWriteRegByte(REG_LCD_DISPLAY_MODE, regLcdDisplayMode | 0x10);
   else
      seWriteRegByte(REG_LCD_DISPLAY_MODE, regLcdDisplayMode & ~0x10);


   regDisplayMode = seReadRegByte(REG_DISPLAY_MODE);

   if (iDisplay == -1)
      {
      ConfiguredBpp = seGetLcdBitsPerPixel();

      if (ConfiguredBpp == 0)
         ConfiguredBpp = seGetCrtBitsPerPixel();

      switch (regDisplayMode & 0x07)
         {
         case LCD:
         default:
            iDisplay = 0;
            break;

         case CRT:
            iDisplay = 1;
            break;

         case TV:
         case (CRT | TV):  // flicker filter on
            iDisplay = 2;
            break;

         case (LCD | CRT):
            iDisplay = 5;  // separate surfaces
            break;

         case (LCD | TV):
         case (LCD | CRT | TV):
            iDisplay = 6;  // separate surfaces
            break;
         }
      }


   if (iDisplay != -1)
      {
      seWriteRegDword(REG_LCD_START_ADDR0, 0);
      seWriteRegDword(REG_CRTTV_START_ADDR0, 0);

      if (CrtTvBitsPerPixel == 0)
         CrtTvBitsPerPixel = seGetCrtBitsPerPixel();

      if (LcdBitsPerPixel == 0)
         LcdBitsPerPixel = seGetLcdBitsPerPixel();

      if (LcdBitsPerPixel != 0)
         ConfiguredBpp = LcdBitsPerPixel;
      else
         ConfiguredBpp = CrtTvBitsPerPixel;