play.c

epson 13506 driver code

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

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

/*
** Display: 0 == LCD, 1 == CRT, 2 == TV
** type:    0 == cursor, 1 == ink layer
*/
void DisplayNotEnoughMemory(int Display, int type)
{
   char *DispArray[3] = { "LCD", "CRT", "TV" };
   char *TypeArray[2] = { "cursor", "ink layer" };

   if ((Display < 0) || (Display > 2))
      Display = 0;

   if ((type < 0) || (type > 1))
      type = 0;

   printf("ERROR: Not enough display buffer memory for %s %s.\n", DispArray[Display], TypeArray[type]);
}

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

void HandleInit( PCHAR szArg )
{
   unsigned regTvOutputCtrl;
   unsigned regDisplayMode;
   unsigned DisplayMode;
   int  TvOutput;
   int  val;
   int  iCrtTv;
   int  UseFlickerFilter;
   int  NoArguments;
   char *szTmp;
   defReg *ptr;
   int iArray;

   /*
   ** Definitions for TvOutput
   */
   enum
      {
      TV_COMPOSITE = 0,
      TV_SVIDEO
      };


   /*
   ** Check for default for TV composite/S-Video
   */
   TvOutput = TV_COMPOSITE;

   if (_FindReg(REG_TV_OUTPUT_CTRL, &regTvOutputCtrl, &iArray) == ERR_OK)
      {
      if (regTvOutputCtrl & 0x02)
         TvOutput = TV_SVIDEO;
      }

   iCrtTv = -1;
   UseFlickerFilter = HalInfo.wTVFlickerFilter;

   szTmp = szArg;
   if (FALSE == FindNextArg( &szTmp ))
      NoArguments = TRUE;
   else
      NoArguments = FALSE;

   DisplayMode = 0;

   /*
   ** Check if init is for hardware cursor or ink layer.
   ** If not, then just initialize with defaults.
   */
   AscToUpper(szArg);

   if (szArg[1] == 'C')  // cursor
      {
      if (NoArguments)
         {
         DISPLAY_WHAT;
         return;
         }
      else if (!strncmp(szTmp, "LCD", 3))
         {
         if (!(HalInfo.dwFlags & fVALID_LCD))
            {
            DisplayBadConfiguration(LCD);
            return;
            }

         if (seInitLcdCursor() > 0)
            printf("Initialized LCD cursor.\n");
         else
            DisplayNotEnoughMemory(0, 0);  // LCD, cursor
         return;
         }
      else if (!strncmp(szTmp, "CRT", 3))
         {
         if (!(HalInfo.dwFlags & fVALID_CRT))
            {
            DisplayBadConfiguration(CRT);
            return;
            }

         if (seInitCrtCursor() > 0)
            printf("Initialized CRT cursor.\n");
         else
            DisplayNotEnoughMemory(1, 0);  // CRT, cursor
         return;
         }
      else if (!strncmp(szTmp, "TV", 3))
         {
         if (!(HalInfo.dwFlags & fVALID_TV))
            {
            DisplayBadConfiguration(TV);
            return;
            }

         if (seInitTvCursor() > 0)
            printf("Initialized TV cursor.\n");
         else
            DisplayNotEnoughMemory(2, 0);  // TV, cursor
         return;
         }
      else
         {
         DISPLAY_WHAT;
         return;
         }
      }
   else if (szArg[1] == 'I')   // ink layer
      {
      if (NoArguments)
         {
         DISPLAY_WHAT;
         return;
         }
      else if (!strncmp(szTmp, "LCD", 3))
         {
         if (!(HalInfo.dwFlags & fVALID_LCD))
            {
            DisplayBadConfiguration(LCD);
            return;
            }

         if (seInitLcdInk() > 0)
            printf("Initialized LCD ink layer.\n");
         else
            DisplayNotEnoughMemory(0, 1);  // LCD, ink layer
         return;
         }
      else if (!strncmp(szTmp, "CRT", 3))
         {
         if (!(HalInfo.dwFlags & fVALID_CRT))
            {
            DisplayBadConfiguration(CRT);
            return;
            }

         if (seInitCrtInk() > 0)
            printf("Initialized CRT ink layer.\n");
         else
            DisplayNotEnoughMemory(1, 1);  // CRT, ink layer
         return;
         }
      else if (!strncmp(szTmp, "TV", 3))
         {
         if (!(HalInfo.dwFlags & fVALID_TV))
            {
            DisplayBadConfiguration(TV);
            return;
            }

         if (seInitTvInk() > 0)
            printf("Initialized TV ink layer.\n");
         else
            DisplayNotEnoughMemory(2, 1);  // TV, ink layer
         return;
         }
      else
         {
         DISPLAY_WHAT;
         return;
         }
      }


   while (FALSE != FindNextArg(&szArg))
      {
      AscToUpper(szArg);

      if (szArg[0] == '?')
         {
         DisplayHelpForRegInit();
         return;
         }


      /*
      ** szArg is either iCrtTv or COMP or SVIDEO
      */
      if (!strncmp(szArg, "COMP", 4))
         TvOutput = TV_COMPOSITE;
      else if (!strncmp(szArg, "SVIDEO", 6))
         TvOutput = TV_SVIDEO;
      else if (!strncmp(szArg, "FLICKER=ON", 10))
         UseFlickerFilter = TRUE;
      else if (!strncmp(szArg, "FLICKER=OFF", 11))
         UseFlickerFilter = FALSE;
      else if (!strncmp(szArg, "LCD", 3))
         {
         DisplayMode |= LCD;

         if (!(HalInfo.dwFlags & fVALID_LCD))
            {
            DisplayBadConfiguration(LCD);
            return;
            }
         }
      else if (!strncmp(szArg, "CRT", 3))
         {
         DisplayMode |= CRT;

         if (!(HalInfo.dwFlags & fVALID_CRT))
            {
            DisplayBadConfiguration(CRT);
            return;
            }
         }
      else if (!strncmp(szArg, "TV", 2))
         {
         DisplayMode |= TV;

         if (!(HalInfo.dwFlags & fVALID_TV))
            {
            DisplayBadConfiguration(TV);
            return;
            }
         }
      else if (!strncmp(szArg, "D=", 2))
         {
         val = (int) AscToLong(&szArg[2]);

         if ((val < 0) || (val > 8))
            {
            DISPLAY_WHAT;
            return;
            }
         else
            iCrtTv = val;
         }
      else
         {
         DISPLAY_WHAT;
         return;
         }
      }

   if ((DisplayMode & TV) && UseFlickerFilter)
      DisplayMode |= (TV | CRT);

   switch (seInitReg(DisplayMode, 0))
      {
      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;
         break;
      }



   if ((iCrtTv >= 0) && (iCrtTv <= 8))
      {
      ptr = Reg[iCrtTv];

      while (ptr->index != FINISHED_REG_CFG)
         {
         /*
         ** Change only bit 0 in REG_TV_OUTPUT_CTRL.
         ** Update bit 1 according to user setting.
         */
         if (ptr->index == REG_TV_OUTPUT_CTRL)
            {
            regTvOutputCtrl = seReadRegByte(REG_TV_OUTPUT_CTRL);
            regTvOutputCtrl &= ~0x01;
            regTvOutputCtrl |= (ptr->val & 0x01);

            if (TvOutput == TV_SVIDEO)
               regTvOutputCtrl |= 0x02;
            else if (TvOutput == TV_COMPOSITE)
               regTvOutputCtrl &= ~0x02;

            seWriteRegByte(REG_TV_OUTPUT_CTRL, regTvOutputCtrl);
            }
         /*
         ** Change only bits 2-0 in REG_DISPLAY_MODE
         */
         else if (ptr->index == REG_DISPLAY_MODE)
            {
            regDisplayMode = seReadRegByte(REG_DISPLAY_MODE);
            regDisplayMode &= ~0x07;
            regDisplayMode |= (ptr->val & 0x07);

            if (UseFlickerFilter && (regDisplayMode & 0x04))
               regDisplayMode |= 0x02;

            if (regDisplayMode & 0x01)
               seLcdDisplayEnable(TRUE);
            else
               seLcdDisplayEnable(FALSE);

            seWriteRegByte(REG_DISPLAY_MODE, regDisplayMode);
            }
         else
            seWriteRegByte(ptr->index, ptr->val);

         ++ptr;
         }
      }

   regTvOutputCtrl = seReadRegByte(REG_TV_OUTPUT_CTRL);

   if (TvOutput & TV_COMPOSITE)
      regTvOutputCtrl &= ~0x02;
   else if (TvOutput & TV_SVIDEO)
      regTvOutputCtrl |= 0x02;

   seWriteRegByte(REG_TV_OUTPUT_CTRL, regTvOutputCtrl);
}

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

/*
**
*/
void HandleRead( PCHAR szArg )
{
   int MemSize = 1;  /* 1 == bytes, 2 == words, 4 == dwords */
   DWORD dwOffset;
   DWORD dwLength;
   DWORD count;
   unsigned val;
   DWORD dwVal;
   int NoArguments;
   char *szTmp;
   char str[20];


   AscToUpper(szArg);

   dwLength = 16;
   count = 0;
   memset(str, 0, sizeof(str));

   szTmp = szArg;
   if (FALSE == FindNextArg( &szTmp ))
      NoArguments = TRUE;
   else
      NoArguments = FALSE;

   /*
   ** Check if there is a command modifier for word or dword reads.
   */
   if (szTmp == &szArg[2])
      MemSize = 1;
   else if (('W' == toupper(szArg[1])) && (NoArguments || (szTmp == &szArg[3])))
      MemSize = 2;
   else if (('D' == toupper(szArg[1])) && (NoArguments || (szTmp == &szArg[3])))
      MemSize = 4;
   else
      {
      DISPLAY_WHAT;
      return;
      }


   /*
   ** We MUST have an offset.
   */
   if (FALSE == FindNextArg( &szArg ))
   {
      DISPLAY_WHAT;
      return;
   }
   dwOffset = AscToLong( szArg );

   /*
   ** The next argument, if there is one, is the number of
   ** bytes/words to read. If nothing specified then we
   ** will read our default length (16) bytes.
   */
   if (TRUE == FindNextArg( &szArg ))
      dwLength = AscToLong( szArg );

   while (count < dwLength)
   {
      switch (MemSize)
      {
         /* DWORD */
         case 4:
            if (0 == (count & 0x3))
            {
               if (TRUE == ThrottleDisplay())
                  break;
               printf( "\n %6lX ", dwOffset );
            }
            else
               if (0 == (count & 1))
                  printf( " -" );
         
            dwVal = seReadDisplayDword(dwOffset);

            printf( " %08lX", dwVal );
            dwOffset +=4;
            break;
         
         /* WORD */
         case 2:
            if (0 == (count & 0x7))
            {
               if (TRUE == ThrottleDisplay())
                  break;
               printf( "\n %6lX ", dwOffset );
            }
            else
               if (0 == (count & 3))
                  printf( " -" );

            val = seReadDisplayWord(dwOffset);

            printf( " %04X", val );
            dwOffset +=2;
            break;
         
         /* BYTE */
         default:
         case 1:
            if (0 == (count & 0xF))
            {
               if (TRUE == ThrottleDisplay())
                  break;

               printf("  %s", str);
               str[0] = 0;

               printf( "\n %6lX ", dwOffset );
            }
            else
               {
               if (0 == (count & 7))
                  printf( " -" );
               }
         
            val = seReadDisplayByte(dwOffset);

            if ((val >= ' ') && (val <= 0x80))
               sprintf(&str[count & 0x0f], "%c", val);
            else
               sprintf(&str[count & 0x0f], ".");

            printf( " %02X", val );

            dwOffset++;
            break;
      }
      count++;
   }

   if (MemSize == 1)
      printf("  %s", str);
}

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

void HandleWrite( PCHAR szArg )
{
   int MemSize = 1;  /* 1 == bytes, 2 == words, 4 == dwords */
   DWORD dwOffset;
   unsigned val;
   DWORD dwVal;
   int NoArguments;
   char *szTmp;

   szTmp = szArg;
   if (FALSE == FindNextArg( &szTmp ))
      NoArguments = TRUE;
   else
      NoArguments = FALSE;

   /*
   ** Check if there is a command modifier for Word writes.
   */
   if (szTmp == &szArg[2])
      MemSize = 1;
   else if (('W' == toupper(szArg[1])) && (NoArguments || (szTmp == &szArg[3])))
      MemSize = 2;
   else if (('D' == toupper(szArg[1])) && (NoArguments || (szTmp == &szArg[3])))
      MemSize = 4;
   else
      {
      DISPLAY_WHAT;
      return;
      }

   /*
   ** We MUST have an offset.
   */
   if (FALSE == FindNextArg( &szArg ))
   {
      DISPLAY_WHAT;
      return;
   }
   dwOffset = AscToLong( szArg );

   /*
   ** For as l