modeset.c

epson 13506 driver code

         }


      if (FindNextArg( &szArg ) != TRUE)
         {
         DISPLAY_WHAT;
         return;
         }


      bpp = atoi(szArg);

      if ((bpp != 4) && (bpp != 8) && (bpp != 15) && (bpp != 16))
         {
         DISPLAY_WHAT;
         return;
         }


      seGetResolution(&nWidth, &nHeight);

#ifdef INTEL_DOS
      if ((*pSetBitsPerPixel)(bpp) == -1)
#else
      if ((*pSetBitsPerPixel)(bpp) == 0)
#endif
         {
         printf("ERROR: Not enough memory for ");

         SurfaceDisplayMode = seGetSurfaceDisplayMode();

         if (SurfaceDisplayMode & LCD)
            printf("LCD");
         else
            printf("CRT/TV");

         printf(" in %d bits-per-pixel.\n", bpp);
         return;
         }

      return;
      }


   if (GotMCCommand)
      return;


   /*
   ** Read and interpret registers.
   */

   printf("\n");

   /*
   ** "Disp Surface:   0=LCD, 1=CRT"
   */
   ShowCurrentDisplaySurface();


   /*
   ** "LCD Orientation:  LANDSCAPE, SWIVELVIEW 90, SWIVELVIEW 180, SWIVELVIEW 270"
   */
   printf("\nLCD Orientation: ");

   val = LANDSCAPE;


   if (regDisplayMode & 0x40)
      val |= ROTATE90;

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

   switch (val)
      {
      case LANDSCAPE:
      default:
         printf("LANDSCAPE\n");
         break;

      case ROTATE90:
         printf("SWIVELVIEW 90 DEGREES\n");
         break;

      case ROTATE180:
         printf("SWIVELVIEW 180 DEGREES\n");
         break;

      case ROTATE270:
         printf("SWIVELVIEW 270 DEGREES\n");
         break;
      }


   /*
   ** "MCLK Source:     CLKI=25.175 MHz"
   */
   printf("MCLK Source:     ");

   if (seReadRegByte(REG_MEM_CLOCK_CFG) & 0x01)
      {
      printf("BUSCLK");
      MClkUsingBusClk = TRUE;
      dwMClkFreq = dwBusClkFreq;
      }
   else
      {
      printf("CLKI");
      MClkUsingBusClk = FALSE;
      dwMClkFreq = dwClkiFreq;
      }


   if (seReadRegByte(REG_MEM_CLOCK_CFG) & 0x10)
      {
      printf("/2");
      dwMClkFreq /= 2;
      }
   else
      printf("/1");

   wMClk_Int = (WORD) (dwMClkFreq / 1000);
   wMClk_Frac = (WORD) (dwMClkFreq - (wMClk_Int * 1000));
   printf("=%u.%03u MHz", wMClk_Int, wMClk_Frac);


   /*
   ** "Mem Wait State:  NO RESTRICTIONS"
   */
   printf("\nMem Wait State:  ");

   switch (seReadRegByte(REG_CPU2MEM_WAIT_SEL) & 0x03)
      {
      case 0x00:
         printf("NO RESTRICTIONS");
         break;

      case 0x01:
         printf("2*period(MCLK) - 4ns > period(BUSCLK)  [WAIT STATE ");

         PeriodMClk   = 1000000L / dwMClkFreq;   // (ns)
         PeriodBusClk = 1000000L / dwBusClkFreq; // (ns)

         if (2*PeriodMClk - 4 > PeriodBusClk)
            printf("OK");
         else
            printf("*BAD*");

         printf("]");
         break;

      case 0x02:
         printf("period(MCLK) - 4ns > period(BUSCLK)  [WAIT STATE ");

         PeriodMClk   = 1000000L / dwMClkFreq;   // (ns)
         PeriodBusClk = 1000000L / dwBusClkFreq; // (ns)

         if (PeriodMClk - 4 > PeriodBusClk)
            printf("OK");
         else
            printf("*BAD*");

         printf("]");
         break;

      case 0x03:
         printf("MCLK = BUSCLK, no skew  [WAIT STATE ");

         if ((dwMClkFreq == dwBusClkFreq) && MClkUsingBusClk)
            printf("OK");
         else
            printf("*BAD*");

         printf("]");
         break;

      default:
         printf("*ERROR*");
         break;
      }


   /*
   ** "CLKI:            25.175 MHz"
   */
   wSrcClk_Int = (WORD) (dwClkiFreq / 1000);
   wSrcClk_Frac = (WORD) (dwClkiFreq - (wSrcClk_Int * 1000));
   printf("\nCLKI:            %u.%03u MHz", wSrcClk_Int, wSrcClk_Frac);


   /*
   ** "CLKI2:           17.734 MHz"
   */
   wSrcClk_Int = (WORD) (dwClki2Freq / 1000);
   wSrcClk_Frac = (WORD) (dwClki2Freq - (wSrcClk_Int * 1000));
   printf("\nCLKI2:           %u.%03u MHz", wSrcClk_Int, wSrcClk_Frac);


   /*
   ** "BUSCLK:          8.000 MHz"
   */
   wSrcClk_Int = (WORD) (dwBusClkFreq / 1000);
   wSrcClk_Frac = (WORD) (dwBusClkFreq - (wSrcClk_Int * 1000));
   printf("\nBUSCLK:          %u.%03u MHz", wSrcClk_Int, wSrcClk_Frac);


   printf("\n\n"
          "                 LCD Parameters           CRT/TV Parameters\n"
          "-----------------------------------------------------------\n");


   /*
   ** "Type:            SINGLE 8-BIT COLOR TFT   ---"
   */
   printf("Type:            ");

   /*
   ** SINGLE 8-BIT COLOR TFT
   ** DUAL 16-BIT MONO STN
   */
   if (regPanelType & 1)
      pWidth = szWidthTFT[(regPanelType >> 4) & 3];
   else
      pWidth = szWidthSTN[(regPanelType >> 4) & 3];

   sprintf(str, "%s %s-BIT %s %s",
           szSnglDual[(regPanelType >> 1) & 1],
           pWidth,
           szMonoColor[(regPanelType >> 2) & 1],
           szSTNTFT[regPanelType & 1]);

   printf("%-24s ---\n", str);


   /*
   ** "Resolution:      640 x 480 x 8 bpp        640 x 480 x 8 bpp"
   */
   printf("Resolution:      ");
   
   sprintf(str, "%u x %u x %u bpp", LcdWidth, LcdHeight, LcdBpp);
   printf("%-23s  ", str);
   
   sprintf(str, "%u x %u x %u bpp", CrtTvWidth, CrtTvHeight, CrtTvBpp);
   printf("%s\n", str);
   

   /*
   ** "Display:         LCD ENABLED              CRT ENABLED"
   */
   printf("Display:         ");

   if (regDisplayMode & LCD)
      printf("LCD ENABLED ");
   else
      printf("LCD DISABLED");

   printf("             ");

   switch (regDisplayMode & (CRT | TV))
      {
      case CRT:
         printf("CRT ENABLED\n");
         break;

      case TV:
         printf("TV ENABLED (FLICKER FILTER OFF)\n");
         break;

      case (CRT | TV):
         printf("TV ENABLED (FLICKER FILTER ON)\n");
         break;

      default:
         printf("CRT/TV DISABLED\n");
         break;
      }


   /*
   ** "Dithering:       NO DITHERING             --"
   */
   printf("Dithering:       ");

   if (seReadRegByte(REG_LCD_MISC) & 0x02)
      printf("DITHERING DISABLED       ---\n");
   else
      printf("DITHERING ENABLED        ---\n");


   /*
   ** "Dual Buffer:     DUAL BUFFER DISABLED     --"
   */
   printf("Dual Buffer:     ");

   if (seReadRegByte(REG_LCD_MISC) & 0x01)
      printf("DUAL BUFFER DISABLED     ---\n");
   else
      printf("DUAL BUFFER ENABLED      ---\n");


   /*
   ** "Display Blank:   NOT BLANKED              NOT BLANKED"
   */
   printf("Display Blank:   ");

   if (seReadRegByte(REG_LCD_DISPLAY_MODE) & 0x80)
      printf("BLANKED    ");
   else
      printf("NOT BLANKED");

   printf("              ");

   if (seReadRegByte(REG_CRTTV_DISPLAY_MODE) & 0x80)
      printf("BLANKED\n");
   else
      printf("NOT BLANKED\n");


   /*
   ** "PCLK Source:     CLKI                     CLKI2"
   */
   printf("PCLK Source:     ");

   switch (regLcdPClkCfg & 0x03)
      {
      /*
      ** CLKI
      */
      case 0x00:
      default:
         dwLcdPClkFreq = dwClkiFreq;
         break;

      /*
      ** BUSCLK
      */
      case 0x01:
         dwLcdPClkFreq = dwBusClkFreq;
         break;

      /*
      ** CLKI2
      */
      case 0x02:
         dwLcdPClkFreq = dwClki2Freq;
         break;

      /*
      ** MCLK
      */
      case 0x03:
         dwLcdPClkFreq = dwMClkFreq;
         break;
      }

   sprintf(str, "%s/%u", szSource[regLcdPClkCfg & 0x03],
           ((regLcdPClkCfg >> 4) & 0x03) + 1);

   printf("%-10s               ", str);

   switch (regCrtTvPClkCfg & 0x03)
      {
      /*
      ** CLKI
      */
      case 0x00:
      default:
         dwCrtTvPClkFreq = dwClkiFreq;
         break;

      /*
      ** BUSCLK
      */
      case 0x01:
         dwCrtTvPClkFreq = dwBusClkFreq;
         break;

      /*
      ** CLKI2
      */
      case 0x02:
         dwCrtTvPClkFreq = dwClki2Freq;
         break;

      /*
      ** MCLK
      */
      case 0x03:
         dwCrtTvPClkFreq = dwMClkFreq;
         break;
      }


   printf("%s/%u *", szSource[regCrtTvPClkCfg & 0x03],
          ((regCrtTvPClkCfg >> 4) & 0x03) + 1);

   if (regCrtTvPClkCfg & 0x80)
      {
      printf("2");
      dwCrtTvPClkFreq *= 2;
      }
   else
      printf("1");

   dwLcdPClkFreq /= (((regLcdPClkCfg >> 4) & 0x03) + 1);
   dwCrtTvPClkFreq /= (((regCrtTvPClkCfg >> 4) & 0x03) + 1);


   /*
   ** The flicker filter halves PCLK
   */
   if ((regDisplayMode & (CRT | TV)) == (CRT | TV))  /* FLICKER FILTER ON */
      {
      dwCrtTvPClkFreq /= 2;
      printf(" (FF ON)\n");
      }
   else
      printf(" (FF OFF)\n");


   /*
   ** "PCLK:           40.000 MHz               40.000 MHz"
   */
   wLcdPClk_Int = (WORD) (dwLcdPClkFreq / 1000);
   wLcdPClk_Frac = (WORD) (dwLcdPClkFreq - (wLcdPClk_Int * 1000));

   wCrtTvPClk_Int = (WORD) (dwCrtTvPClkFreq / 1000);
   wCrtTvPClk_Frac = (WORD) (dwCrtTvPClkFreq - (wCrtTvPClk_Int * 1000));

   printf("PCLK:            ");
   sprintf(str, "%u.%03u MHz", wLcdPClk_Int, wLcdPClk_Frac);
   printf("%-15s          ", str);
   printf("%u.%03u MHz\n", wCrtTvPClk_Int, wCrtTvPClk_Frac);


   /*
   ** "Frame Rate:     75.0 Hz                  75.0 Hz"
   */
   if (regPanelType & 0x02)
      n = 2;  /* Dual panel */
   else
      n = 1;  /* Single panel */

   dwLcdFrameRate = ((DWORD) dwLcdPClkFreq * 10000L) /
      (((DWORD) LcdHDP + LcdHNDP) * (((DWORD) LcdVDP / n) + LcdVNDP));

   if ((n == 2) && !(regLcdMisc & 0x01))   /* if dual panel and dual panel buffer enabled */
      dwLcdFrameRate /= 2;

   wLcdFrameRate_Int = (WORD) (dwLcdFrameRate / 10);
   wLcdFrameRate_Frac = (WORD) (dwLcdFrameRate - (wLcdFrameRate_Int * 10));


   dwCrtTvFrameRate = ((DWORD) dwCrtTvPClkFreq * 10000L) /
      (((DWORD) CrtTvHDP + CrtTvHNDP) * ((DWORD) CrtTvVDP + CrtTvVNDP));

   wCrtTvFrameRate_Int = (WORD) (dwCrtTvFrameRate / 10);
   wCrtTvFrameRate_Frac = (WORD) (dwCrtTvFrameRate - (wCrtTvFrameRate_Int * 10));

   printf("Frame Rate:      ");
   sprintf(str, "%u.%01u Hz", wLcdFrameRate_Int, wLcdFrameRate_Frac);
   printf("%-15s          ", str);
   printf("%u.%01u Hz", wCrtTvFrameRate_Int, wCrtTvFrameRate_Frac);
}

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