ataiotrc.c

~{S2EL~}wdm~{G}6/~}

      chtDmpNdx ++ ;
      if ( chtDmpNdx >= MAX_CHT )
         chtDmpNdx = 0;
      return trcDmpBuf;
   }
   if ( chtBuf[chtDmpNdx].flg == TRC_FLAG_SRST )
   {
      strcpy( trcDmpBuf, ".. S o f t   R e s e t ............ " );
   }
   else
   {
      sprintf( trcDmpBuf,
               "%02X %02X %02X %02X %02X%02X %02X %02X ",
               chtBuf[chtDmpNdx].cmd, chtBuf[chtDmpNdx].fr1,
               chtBuf[chtDmpNdx].sc1, chtBuf[chtDmpNdx].sn1,
               chtBuf[chtDmpNdx].ch1, chtBuf[chtDmpNdx].cl1,
               chtBuf[chtDmpNdx].dh1, chtBuf[chtDmpNdx].dc1 );
      if ( chtBuf[chtDmpNdx].dh1 & 0x40 )
      {
         lba = chtBuf[chtDmpNdx].dh1 & 0x0f;
         lba = lba << 8;
         lba = lba | chtBuf[chtDmpNdx].ch1;
         lba = lba << 8;
         lba = lba | chtBuf[chtDmpNdx].cl1;
         lba = lba << 8;
         lba = lba | chtBuf[chtDmpNdx].sn1;
         sprintf( prtBuf, "   %9lu ", lba );
      }
      else
      {
         sprintf( prtBuf,
                  "%5u %2u %3u ",
                  (int) ( chtBuf[chtDmpNdx].ch1 << 8 ) | chtBuf[chtDmpNdx].cl1,
                  (int) chtBuf[chtDmpNdx].dh1 & 0x0f,
                  (int) chtBuf[chtDmpNdx].sn1 );
      }
      strcat( trcDmpBuf, prtBuf );
   }
   sprintf( prtBuf,
            "%02X %02X %02X %02X %02X %02X%02X %02X ",
            chtBuf[chtDmpNdx].st2, chtBuf[chtDmpNdx].as2,
            chtBuf[chtDmpNdx].er2, chtBuf[chtDmpNdx].sc2,
            chtBuf[chtDmpNdx].sn2, chtBuf[chtDmpNdx].ch2,
            chtBuf[chtDmpNdx].cl2, chtBuf[chtDmpNdx].dh2 );
   strcat( trcDmpBuf, prtBuf );
   if ( chtBuf[chtDmpNdx].dh2 & 0x40 )
   {
      lba = chtBuf[chtDmpNdx].dh2 & 0x0f;
      lba = lba << 8;
      lba = lba | chtBuf[chtDmpNdx].ch2;
      lba = lba << 8;
      lba = lba | chtBuf[chtDmpNdx].cl2;
      lba = lba << 8;
      lba = lba | chtBuf[chtDmpNdx].sn2;
      sprintf( prtBuf, "   %9lu ", lba );
   }
   else
   {
      sprintf( prtBuf,
               "%5u %2u %3u ",
               (int) ( chtBuf[chtDmpNdx].ch2 << 8 ) | chtBuf[chtDmpNdx].cl2,
               (int) chtBuf[chtDmpNdx].dh2 & 0x0f,
               (int) chtBuf[chtDmpNdx].sn2 );
   }
   strcat( trcDmpBuf, prtBuf );
   sprintf( prtBuf,
            "%2d %2d",
            chtBuf[chtDmpNdx].ec, chtBuf[chtDmpNdx].to );
   strcat( trcDmpBuf, prtBuf );
   chtDmpNdx ++ ;
   if ( chtDmpNdx >= MAX_CHT )
      chtDmpNdx = 0;
   return trcDmpBuf;
}

//**********************************************************

// Low-level trace buffer

#define MAX_LLT 500

static struct
{
   unsigned char addr;
   unsigned char data;
   unsigned char type;
   unsigned char rep;
} lltBuf[MAX_LLT];

static int lltCur = 0;
static int lltDmpLine = 0;
static int lltDmpNdx = 0;

static unsigned char lltAddr = 0;
static unsigned char lltData = 0;
static unsigned char lltType = 0;
static unsigned long lltRep = 0L;

static struct
{
   unsigned char typeId;      // trace entry type
   unsigned char * typeNm;    // trace entry name
} type_nm[]
   =
   {
                     //<opr> <--register---> <data - note>
      TRC_LLT_INB   , "INB   " ,
      TRC_LLT_OUTB  , "OUTB  " ,
      TRC_LLT_INW   , "INW   " ,
      TRC_LLT_OUTW  , "OUTW  " ,
      TRC_LLT_INSB  , "INSB  " ,
      TRC_LLT_OUTSB , "OUTSB " ,
      TRC_LLT_INSW  , "INSW  " ,
      TRC_LLT_OUTSW , "OUTSW " ,
      TRC_LLT_INSD  , "INSD  " ,
      TRC_LLT_OUTSD , "OUTSD " ,
      TRC_LLT_S_CFG , "===== Start Dev Cnfg  ",
      TRC_LLT_S_RST , "===== Start Reset     ",
      TRC_LLT_S_ND  , "===== Start ND cmd    ",
      TRC_LLT_S_PDI , "===== Start PDI cmd   ",
      TRC_LLT_S_PDO , "===== Start PDO cmd   ",
      TRC_LLT_S_PI  , "===== Start PI cmd    ",
      TRC_LLT_S_RWD , "===== Start R/W DMA   ",
      TRC_LLT_S_PID , "===== Start PI DMA    ",
      TRC_LLT_WINT  , "..... Wait for INTRQ  ",
      TRC_LLT_PNBSY , "..... Poll for BSY=0  ",
      TRC_LLT_PRDY  , "..... Poll for DRDY=1 ",
      TRC_LLT_TOUT  , "..... T I M E O U T   ",
      TRC_LLT_ERROR , "..... E R R O R       ",
      TRC_LLT_P_CMD , "..... ATAPI Cmd Code  ",
      TRC_LLT_DELAY , "..... DELAY ~100ms    ",
      TRC_LLT_DEBUG , "..... DEBUG           ",
      TRC_LLT_DELAY2, "..... DELAY 0-55ms    ",
      TRC_LLT_E_CFG , "===== End Dev Cnfg    ",
      TRC_LLT_E_RST , "===== End Reset       ",
      TRC_LLT_E_ND  , "===== End ND cmd      ",
      TRC_LLT_E_PDI , "===== End PDI cmd     ",
      TRC_LLT_E_PDO , "===== End PDO cmd     ",
      TRC_LLT_E_PI  , "===== End PI cmd      ",
      TRC_LLT_E_RWD , "===== End R/W DMA     ",
      TRC_LLT_E_PID , "===== End PI DMA      ",
      TRC_LLT_DMA1  , "..... Enable DMA Ch   ",
      TRC_LLT_DMA2  , "..... Poll DMA TC bit ",
      TRC_LLT_DMA3  , "..... Disable DMA Ch  ",
      TRC_LLT_PSERV , "..... Poll for SERV=1 ",
      0             , "????? " ,
   } ;

static unsigned char * reg_nm[]  // register names for trace
   =
   {
  //<opr> <--register---> <data - note>
         "Data            " , // 0 data reg
         "Error/Feature   " , // 1 error & feature
         "SectorCount     " , // 2 sector count
         "SectorNumber    " , // 3 sector number
         "CylinderLow     " , // 4 cylinder low
         "CylinderHigh    " , // 5 cylinder high
         "DeviceHead      " , // 6 device head
         "Status/Cmd      " , // 7 primary status & command
         "AltStat/DevCtrl " , // 8 alternate status & device control
         "DevAddr         " , // 9 device address
   } ;

//*********************************************************

// place an entry into the low level trace buffer

void trc_llt( unsigned char addr,
              unsigned char data,
              unsigned char type )

{

   if ( ( addr == lltAddr )
        &&
        ( data == lltData )
        &&
        ( type == lltType )
      )
   {
      lltRep ++ ;
      return;
   }
   lltBuf[lltCur].addr = lltAddr;
   lltBuf[lltCur].data = lltData;
   lltBuf[lltCur].type = lltType;
   lltBuf[lltCur].rep = lltRep > 255L ? 255 : lltRep;
   lltRep = 0L;
   lltCur ++ ;
   if ( lltCur >= MAX_LLT )
      lltCur = 0;
   lltBuf[lltCur].addr = lltAddr = addr;
   lltBuf[lltCur].data = lltData = data;
   lltBuf[lltCur].type = lltType = type;
   lltBuf[lltCur].rep  = 0;
}

//**************************************************************

// clear the low level trace buffer

void trc_llt_dump0( void )

{

   for ( lltCur = 0; lltCur < MAX_LLT; lltCur ++ )
      lltBuf[lltCur].type = 0;
   lltCur = 0;
}

//**************************************************************

// start a dump of the low level trace buffer

void trc_llt_dump1( void )

{

   trc_llt( 0, 0, TRC_LLT_NONE );
   lltDmpLine = 0;
   lltDmpNdx = lltCur + 1;
   if ( lltDmpNdx >= MAX_LLT )
      lltDmpNdx = 0;
}

//**************************************************************

// return one line of the low level trace,
// returns NULL at end.

unsigned char * trc_llt_dump2( void )

{
   int ndx;

   lltDmpLine ++ ;
   if ( lltDmpLine == 1 )     // 1st line is heading
   {
                        //0        1         2         3
                        //123456789012345678901234567890123456
      strcpy( trcDmpBuf, "<opr> <--register---> <data - note>" );
      return trcDmpBuf;
   }
   while ( 1 )
   {
      if ( lltDmpNdx == lltCur )
         return NULL;
      if ( lltBuf[lltDmpNdx].type != 0 )
         break;
      lltDmpNdx ++ ;
      if ( lltDmpNdx >= MAX_LLT )
         lltDmpNdx = 0;
   }
   ndx = 0;
   while ( type_nm[ndx].typeId )
   {
      if ( lltBuf[lltDmpNdx].type == type_nm[ndx].typeId )
         break;
      ndx ++ ;
   }
   strcpy( trcDmpBuf, type_nm[ ndx ].typeNm );
   if ( lltBuf[lltDmpNdx].type < TRC_LLT_S_CFG )
   {
      strcat( trcDmpBuf, reg_nm[ lltBuf[lltDmpNdx].addr ] );
      if ( lltBuf[lltDmpNdx].addr == CB_DATA )
         strcpy( prtBuf, "-- " );
      else
         sprintf( prtBuf, "%02X ", lltBuf[lltDmpNdx].data );
      strcat( trcDmpBuf, prtBuf );
      if (    ( lltBuf[lltDmpNdx].addr == CB_DC )
           && ( lltBuf[lltDmpNdx].type == TRC_LLT_OUTB )
         )
      {
         if ( lltBuf[lltDmpNdx].data & CB_DC_SRST )
         {
            strcat( trcDmpBuf, "START COMMAND: " );
            strcat( trcDmpBuf, trc_get_cmd_name( TRC_FLAG_SRST, 0 ) );
         }
         strcat( trcDmpBuf, ( lltBuf[lltDmpNdx].data & CB_DC_NIEN )
                       ? " nIEN=1" : " nIEN=0" );
      }
      if (    ( lltBuf[lltDmpNdx].addr == CB_CMD )
           && ( lltBuf[lltDmpNdx].type == TRC_LLT_OUTB )
         )
      {
         strcat( trcDmpBuf, "START COMMAND: " );
         strcat( trcDmpBuf, trc_get_cmd_name( TRC_FLAG_CMD, lltBuf[lltDmpNdx].data ) );
      }
      if (    ( lltBuf[lltDmpNdx].addr == CB_DH )
           && ( lltBuf[lltDmpNdx].type == TRC_LLT_OUTB )
         )
      {
         strcat( trcDmpBuf, ( lltBuf[lltDmpNdx].data & 0x10 )
                       ? "DEV=1" : "DEV=0" );
         strcat( trcDmpBuf, ( lltBuf[lltDmpNdx].data & 0x40 )
                       ? " LBA=1" : " LBA=0" );
      }
      if (    (    ( lltBuf[lltDmpNdx].addr == CB_STAT )
                || ( lltBuf[lltDmpNdx].addr == CB_ASTAT )
              )
           && ( lltBuf[lltDmpNdx].type == TRC_LLT_INB )
         )
         strcat( trcDmpBuf, trc_get_st_bit_name( lltBuf[lltDmpNdx].data ) );
      if (    ( lltBuf[lltDmpNdx].addr == CB_ERR )
           && ( lltBuf[lltDmpNdx].type == TRC_LLT_INB )
         )
         strcat( trcDmpBuf, trc_get_er_bit_name( lltBuf[lltDmpNdx].data ) );
   }
   if ( lltBuf[lltDmpNdx].type == TRC_LLT_ERROR )
      strcat( trcDmpBuf, trc_get_err_name( lltBuf[lltDmpNdx].data ) );
   if ( ( lltBuf[lltDmpNdx].type == TRC_LLT_DEBUG )
        ||
        ( lltBuf[lltDmpNdx].type == TRC_LLT_P_CMD )
      )
   {
      sprintf( prtBuf, "%02X ", lltBuf[lltDmpNdx].data );
      strcat( trcDmpBuf, prtBuf );
   }
   if ( lltBuf[lltDmpNdx].rep )
   {
      if ( lltBuf[lltDmpNdx].rep == 255 )
         strcpy( prtBuf, "repeated 255 or more times " );
      else
         sprintf( prtBuf, "repeated %u more times ", lltBuf[lltDmpNdx].rep );
      strcat( trcDmpBuf, prtBuf );
   }
   lltDmpNdx ++ ;
   if ( lltDmpNdx >= MAX_LLT )
      lltDmpNdx = 0;
   return trcDmpBuf;
}

// end ataiotrc.c