cnfdsp.c

This is Bsl.zip for DSP c6000

    
    if ( temp_read != temp_expected )
    {
      error++;
#if SPECIAL==MEMTST
      if(error<25)
        printf(" Read=0x%08x at Address=0x%08x\n",temp_read,(mem_ptr-1));
#endif
    }
  } 
  
  return error;
}

/*-------------------------------------------------------------------------*/
/* flash_test() - used to test external FLASH                              */
/*-------------------------------------------------------------------------*/
int flash_test( char pattern, int start_address, int size_in_byte)
{
  int i=0, j=0;
  int error = 0;
  int write_size = 0;
  int read_size  = 0;
  
  char *flash_ptr = (char *)start_address;
  char buffer[FLASH_PAGE_SIZE];
  char *buffer_ptr;
  
  /* initialize buffer to write from */
  for (i=0; i<FLASH_PAGE_SIZE;i++)
    buffer[i] = pattern;
    
  i = size_in_byte;
  
  /* write to flash  */
  while (i > 0){
    if (i < FLASH_PAGE_SIZE) write_size = i;
    else write_size = FLASH_PAGE_SIZE;
    FLASH_write((Uint32)buffer, (Uint32)flash_ptr, (Uint32)write_size);
    i = i - FLASH_PAGE_SIZE;
    flash_ptr = flash_ptr + FLASH_PAGE_SIZE;
  }

  flash_ptr = (char *)start_address;
  buffer_ptr = buffer;

  /* read from flash */
  while (i > 0){
    if (i < FLASH_PAGE_SIZE) read_size = i;
    else read_size = FLASH_PAGE_SIZE;
    FLASH_read((Uint32)flash_ptr, (Uint32)buffer, (Uint32)read_size);
    i = i - FLASH_PAGE_SIZE;
    flash_ptr = flash_ptr + FLASH_PAGE_SIZE;
    /* test flash */
    j=0;
    for(j=0;j<read_size;j++){
      if (*buffer_ptr++ != pattern){
        error++;
      #if SPECIAL==FLATST
        if(error<25)
          printf(" Read=0x%08x at Address=0x%08x\n",*flash_ptr,(flash_ptr-1));
      #endif
      }
    }/* END FOR */  
  }/* END WHILE */
  
  return error;
}


/*-------------------------------------------------------------------------*/
/* flash_checksum() - used to test checksum in POST on external FLASH      */
/*-------------------------------------------------------------------------*/
/*int flash_checksum (int start_address, int size_in_byte)
{
  int i = 0, error = 0;
  int checksum,*checksum_ptr;
  char *flash_ptr = (char *)start_address;
  int temp;
  
  i=0;     
  checksum = 0;
  
  while(i < size_in_byte-4)
  {  
    temp = *flash_ptr++;
    temp &= 0xff;
    checksum = checksum + temp;
    i++;
  }
   
  checksum_ptr = (int *)flash_ptr;

  exp_chksum=*checksum_ptr;
  cmp_chksum=checksum;

  if( exp_chksum != cmp_chksum) error = 1;
//  if( *checksum_ptr != checksum) error = 1;
  
  return error;
}
*/

/*-------------------------------------------------------------------------*/
/* mcbsp0_test() - used to test McBSP0                                     */
/*-------------------------------------------------------------------------*/
int mcbsp0_test()
{
  volatile Uint32 temp =0,temp1;
  	
  /* set up McBSP0 */
  MCBSP_configArgs(hMcbsp,
                0x00C1A001, /* SPCR- serial port control reg.              */
                0x00010040, /* RCR - recieve control reg.16 bit data/frame */
                0x00010040, /* XCR - xmit control reg. 16 bit data/frame   */
                0x2014004A, /* SRGR- sample rate generator, baud rate 1MHz */
                0x00000000, /* MCR - multichannel control reg.             */
                0x00000000, /* RCER- recieve channel enable reg.           */
                0x00000000, /* RCER- recieve channel enable reg.           */
                0x00000A00  /* PCR - pin control reg.                      */
               );
  
  MCBSP_write(hMcbsp, 0xAAAA);
  temp1 = MCBSP_read(hMcbsp);
  while(!MCBSP_rrdy(hMcbsp)); 
  temp1 = MCBSP_read(hMcbsp);
  
  MCBSP_write(hMcbsp, 0x5555);
  while(!MCBSP_xrdy(hMcbsp));
  while(!MCBSP_rrdy(hMcbsp)); 
  temp = MCBSP_read(hMcbsp);
  temp &= 0xffff;

  if (temp != 0x5555)
  {
    temp = 1;
    return temp;
  }
    
  MCBSP_write(hMcbsp, 0xAAAA);
  while(!MCBSP_xrdy(hMcbsp));
  while(!MCBSP_rrdy(hMcbsp)); 
  temp = MCBSP_read(hMcbsp);
  temp &= 0xffff;
    
  if (temp != 0xAAAA)
  {
    temp = 1;
    return temp;
  }    
  return 0;
}


/*-------------------------------------------------------------------------*/
/* qdma_start() - used to start QDMA                                       */
/*-------------------------------------------------------------------------*/
void qdma_start(int src, int dst, int size)
{ 
  /* EDMA_CIER_SET(0x100);
  EDMA_QSRC_SET(src);
  EDMA_QDST_SET(dst);
  EDMA_QIDX_SET(0x00000000); 
  EDMA_QOPT_SET(0x41380001);
  EDMA_QSCNT_SET(size);*/
  
  EDMA_RSET(CIER,0x100);
  EDMA_RSET(QSRC,src);
  EDMA_RSET(QDST,dst);
  EDMA_RSET(QIDX,0x00000000); 
  EDMA_RSET(QOPT,0x41380001);
  EDMA_RSET(QCNT,size);
}
  
/*-------------------------------------------------------------------------*/
/* qdma_check() - used to test QDMA operation                              */
/*-------------------------------------------------------------------------*/
int qdma_check( int src, int dst, int size)
{
  int i,error = 0;
  int *src_ptr = (int *)src;
  int *dst_ptr = (int *)dst;

  for (i=0;i<size;i++)
  {
    if (*src_ptr++ != *dst_ptr++) error++;
  }
  
  return error;
}

/*-------------------------------------------------------------------------*/
/* qdma_isr() - interrupt service routine for qdma                         */
/*-------------------------------------------------------------------------*/
interrupt void qdma_isr()
{
  /* clear pending EDMA interrupt 8 */
  EDMA_RSET(CIPR,EDMA_RGET(CIPR) | 0x0100); 
  flag = 1;
}

/*-------------------------------------------------------------------------*/
/* led_blink() - used to blink all the LEDS on the DSK                     */
/*-------------------------------------------------------------------------*/
void led_blink(int count, int ms_period, Uint32 leds_to_light)
{
  int i;
  volatile int led1=0,led2=0,led3=0;
  
  /* decode the led mask */
  if ((leds_to_light>>24) & 1) led1 = 1;
  if ((leds_to_light>>25) & 1) led2 = 1;
  if ((leds_to_light>>26) & 1) led3 = 1;
  
  /* set up timer to be used for delay_msec() */
  myTimerConfig.ctl = 0x00000300;
  myTimerConfig.prd = 0xFFFFFFFF;
  myTimerConfig.cnt = 0;
  TIMER_config(hTimer, &myTimerConfig);
    
  for (i=0;i<count;i++)
  {
    LED_off(LED_ALL);           /* turn off all three leds    */
    delay_msec((Uint32)ms_period/2);
    if (led1) LED_on(LED_1);    /* turn on leds_to_light      */
    if (led2) LED_on(LED_2);
    if (led3) LED_on(LED_3);
    delay_msec((Uint32)ms_period/2);
  }
  LED_off(LED_ALL);             /* turn off all three leds    */
}


/*-------------------------------------------------------------------------*/
/* get_bdrev() - used to read board revision bits                          */
/*-------------------------------------------------------------------------*/
Uint32 get_bdrev(void) {

  return((BOARD_readReg(BOARD_REG_IOPORT)>>29)&0x7);
}

/*-------------------------------------------------------------------------*/
/* delay_msec() - used to delay DSP by user specified time in msec         */
/*-------------------------------------------------------------------------*/
void delay_msec(Uint32 msec){
  /* Assume 150 MHz CPU, timer peirod = 4/150 MHz */
  Uint32 timer_limit;
  Uint32 timer_start;

  timer_limit = ((Uint32)msec*9375)<<2;
  timer_start = TIMER_getCount(hTimer);
  TIMER_resume(hTimer);
  
  while ( (TIMER_getCount(hTimer) - timer_start) < timer_limit );
  TIMER_pause(hTimer);
}

/*-------------------------------------------------------------------------*/
/* timer0_isr() - interrupt service routine for TIMER0                     */
/*-------------------------------------------------------------------------*/
interrupt void timer0_isr(){

  TIMER_pause(hTimer);
  if(flag == 0) 
    flag = 1;                      /* toggle the flag */
  else 
    flag = 0;
}

/*-------------------------------------------------------------------------*/
/* play_codec() - used to test codec operation                             */
/*-------------------------------------------------------------------------*/
int play_codec(int number, int tone_playbk)
{
  int i,j;

  AD535_reset(hAD535);
  
  AD535_writeReg(hAD535, AD535_REG_CTRL3, 0x06);
  if( AD535_readReg(hAD535, AD535_REG_CTRL3) != 0x06) {
  #if PRINT
    printf ("  Error in setting up control register 3.\n");
  #endif
    return(3);
  }
  
  AD535_writeReg(hAD535, AD535_REG_CTRL4, 0x00);
  if( AD535_readReg(hAD535, AD535_REG_CTRL4) != 0x00) {
  #if PRINT
    printf ("  Error in setting up control register 4.\n");
  #endif
    return(4);
  }
  
  AD535_writeReg(hAD535, AD535_REG_CTRL5, 0x02);
  if( (AD535_readReg(hAD535, AD535_REG_CTRL5) & 0xFE) != 0x02) {
  #if PRINT
    printf ("  Error in setting up control register 5.\n");
  #endif
    return(5);
  }  

  if(tone_playbk) {
    for (i=0;i<number;i++){
      for (j=0;j<8;j++)
        AD535_write(hAD535, (int)sin_table[j]);
    }
  }
  else {
    for (i=0;i<number;i++)
      AD535_write(hAD535, AD535_read(hAD535) );
  }
  return(0);
}