cnfdsp.c

This is Bsl.zip for DSP c6000

#if PRINT
        printf(" Write 5's.\n");
#endif
        if((error=flash_test(0x55,POST_END,FLASH_WRITE_SIZE)) != 0)
        {
          handShakingBuffer[0]=error;
/*          handShakingBuffer[5] |=FLASH_ERR55;    Use When Checksum first */
          handShakingBuffer[5]=FLASH_ERR55;
        }
        else
/*          handShakingBuffer[5] |=FLASH_OK;       Use When Checksum first */ 
          handShakingBuffer[5]=FLASH_OK; 

        /*-----------------------------------------------------------------*/
        /* Attempt to write 0xAAAAAAAA to numerous locations and read same */
        /*-----------------------------------------------------------------*/
#if PRINT
        printf(" Write A's.\n");
#endif
        if((error=flash_test(0xAA,POST_END,FLASH_WRITE_SIZE)) != 0)
        {
          handShakingBuffer[0]=error;
          handShakingBuffer[5] |=FLASH_ERRAA;
        }
        else
          handShakingBuffer[5] |=FLASH_OK;

        /*-----------------------------------------------------------------*/
        /* Example of Status word of hSB - Used when FLASH test turned off */
        /*-----------------------------------------------------------------*/
//        handShakingBuffer[5]=TEST_DISABLED;
        break;

      /*-------------------------------------------------------------------*/
      /* Run the MCBSP test and return information if(error)               */
      /*-------------------------------------------------------------------*/
      case MCBSP:
#if PRINT
        printf("MCBSP\n");
#endif
#if PRINT
        printf(" Digital Loopback Mode.\n");
#endif
        /* open McBSP channel before testing */
        hMcbsp = MCBSP_open(MCBSP_DEV0, MCBSP_OPEN_RESET);

        if((error=mcbsp0_test()) != 0)
        {
          handShakingBuffer[0]=error;
          handShakingBuffer[5]=MCBSP_ERROR;
        }
        else
          handShakingBuffer[5]=MCBSP_OK;
        
        /* close McBSP channel before proceeding */
        MCBSP_close(hMcbsp);
        break;

      /*-------------------------------------------------------------------*/
      /* Run the TIMER test and return status                              */
      /*-------------------------------------------------------------------*/
      case TIMER:
#if PRINT
        printf("TIMER\n");
#endif
        flag = 0;
        /* set up Timer 0 for short period and start timer */
        hTimer = TIMER_open(TIMER_DEV0, TIMER_OPEN_RESET);
        TIMER_config(hTimer, &myTimerConfig);
         
        /* interrupt configuration */
        IRQ_clear(IRQ_EVT_TINT0);    /* clear interrupt 14                    */
        IRQ_enable(IRQ_EVT_TINT0);   /* enable interrupt 14 (TIMER 0) and NMI */
        CHIP_RSET(CSR,CHIP_RGET(CSR) | 1 );  /* enable global interrupts      */

        TIMER_start(hTimer);
        
        /* wait for interrupt 14 to pause timer and toggle flag to 1 */
        while (flag == 0);
        TIMER_resume(hTimer);
        /* wait for interrupt 14 to pause timer and toggle flag to 0 */
        while (flag == 1);
        
        CHIP_RSET(IER,0);             /* disable all interrupts                */   
        handShakingBuffer[5]=TIMER_OK;
        break;

      /*-------------------------------------------------------------------*/
      /* Run the QDMA test and return information if(error)                */
      /*-------------------------------------------------------------------*/
      case QDMA:
#if PRINT
        printf("QDMA\n");
#endif
        IRQ_clear(IRQ_EVT_EDMAINT);  /* clear interrupt 14                    */
        IRQ_enable(IRQ_EVT_EDMAINT); /* enable interrupt 14 (TIMER 0) and NMI */
        CHIP_RSET(CSR,CHIP_RGET(CSR) | 1 );  /* enable global interrupts      */
 
        flag = 0;
        
        src = 0xf000;
        dst = 0x80000000;
        size = 500;
        qdma_start(src,dst,size);
        
        /* wait for interrupt 8 to halt transfer and toggle flag to 1 */
        while (flag == 0)  ;
        error = qdma_check(src,dst,size);
        if(error != 0)
        {
          handShakingBuffer[0]=error;
          handShakingBuffer[5]=QDMA_ERROR;
        }
        else
          handShakingBuffer[5]=QDMA_OK;

        CHIP_RSET(IER,0);          /* disable all interrupts                */   
        break;

      /*-------------------------------------------------------------------*/
      /* Run the LEDS test and return information for debug                */
      /*-------------------------------------------------------------------*/
      case LEDS:
#if PRINT
        printf("LEDS\n");
#endif
        /*-----------------------------------------------------------------*/
        /* Simultaneous menu and debug modes allow user to enter values    */
        /*-----------------------------------------------------------------*/
#if PRINT
        printf(" Flash %d times with %d msec period.\n",
          handShakingBuffer[0],handShakingBuffer[1]);
#endif
        led_blink(handShakingBuffer[0],handShakingBuffer[1],handShakingBuffer[2]);
        handShakingBuffer[5]=LEDS_OK;
        break;

      /*-------------------------------------------------------------------*/
      /* Run the CODEC test and return status                              */
      /*-------------------------------------------------------------------*/
      case CODEC:
#if PRINT
        printf("CODEC\n");
#endif
        hAD535 = AD535_open(AD535_localId);
        AD535_config(hAD535, &myConfig);

#if PRINT
        printf(" Play 1KHz tone.\n");
#endif
        if((errortone=play_codec(handShakingBuffer[0], 1)) != 0)
        {
          handShakingBuffer[0]=errortone;
          handShakingBuffer[5]=CODEC_ERRTN;
        }
        else
          handShakingBuffer[5] =CODEC_OK;

#if PRINT
        printf(" Play CD/MIC input.\n");
#endif
        if((error=play_codec(handShakingBuffer[1], 0)) != 0)
        {
          handShakingBuffer[1]=error;
          handShakingBuffer[5] |=CODEC_ERRCD;
        }
        else
          handShakingBuffer[5] |=CODEC_OK;
				break;

      /*-------------------------------------------------------------------*/
      /* Run the PGMEM test and return information for debug               */
      /*-------------------------------------------------------------------*/
 			case PGMEM:
#if PRINT
        printf("PGMEM\n");
#endif
        /*-----------------------------------------------------------------*/
        /* Simultaneous menu and debug modes allow user to enter values    */
        /*-----------------------------------------------------------------*/
#if PRINT
        printf(" Write 0x%08x to 0x%08x for 0x%08x words.\n",
          handShakingBuffer[0],(EXTERNAL_MEM_START+handShakingBuffer[1]),
          handShakingBuffer[2]);
#endif
        if((error=mem_test(handShakingBuffer[0],(EXTERNAL_MEM_START+handShakingBuffer[1]),
          handShakingBuffer[2])) != 0)
        {
          handShakingBuffer[0]=error;
          handShakingBuffer[5]=PGMEM_ERROR;
        }
        else
        {
          handShakingBuffer[1]+=EXTERNAL_MEM_START;
          handShakingBuffer[5]=PGMEM_OK;
        }
				break;

      /*-------------------------------------------------------------------*/
      /* If user adds new command with out a case ... it winds up here     */
      /*-------------------------------------------------------------------*/
      default:
#if PRINT
        printf("ERROR\n");
#endif
        handShakingBuffer[5]=DEFAULT_ERROR;
				break;
		}

    /*---------------------------------------------------------------------*/
    /* Tell the HOST that DSP processing is done for this command          */
    /*---------------------------------------------------------------------*/
		handShakingBuffer[4] = DSP_STATUS_OUTPUT_READY;
  }

  /*-----------------------------------------------------------------------*/
  /* Wrap it up                                                            */
  /*-----------------------------------------------------------------------*/
#if PRINT
  printf("\nThat's All Folks!\n");
#endif

  TIMER_close(hTimer);
  AD535_close(hAD535);

  return(0);
}

/*-------------------------------------------------------------------------*/
/* mem_test() - used to test internal SRAM and external SDRAM              */
/*-------------------------------------------------------------------------*/
int mem_test (int pattern, int start_address, int size_in_word )
{
  int i;
  int temp;
  int error = 0;
  int *mem_ptr = (int *)start_address;
  
  for(i=0;i<size_in_word;i++)    /* write pattern to the memory */
  {
    *mem_ptr++ = pattern;
  }

  mem_ptr = (int *)start_address;
  
  for(i=0;i<size_in_word;i++)  /* read data back from memory */
  {
    temp = *mem_ptr++;
    
#if SPECIAL==ENDPNT
    if(i==0)
      printf(" Read=0x%08x at Address=0x%08x\n",temp,(mem_ptr-1));
    else if((i==size_in_word-1))
      printf(" Read=0x%08x at Address=0x%08x\n",temp,(mem_ptr-1));
#endif    

#if SPECIAL==INTERV
    if(!(i%(1024*256)))
      printf(" Read=0x%08x at Address=0x%08x\n",temp,(mem_ptr-1));
#endif    
    
    if ( temp != pattern)
    {
      error++;
#if SPECIAL==MEMTST
      if(error<25)
        printf(" Read=0x%08x at Address=0x%08x\n",temp,(mem_ptr-1));
#endif
    }
  } 
  
  return error;
}

/*-------------------------------------------------------------------------*/
/* mem_test_alt() - used to test internal SRAM and external SDRAM          */
/*-------------------------------------------------------------------------*/
int mem_test_alt (int pattern, int start_address, int size_in_word )
{
  int i;
  int temp_read,temp_expected;
  int error = 0;
  int *mem_ptr = (int *)start_address;
  
  for(i=0;i<size_in_word;i++)    /* write pattern to the memory */
  {
    if(i%2)
      *mem_ptr++ = ~pattern;     /* flip alternating bits       */
    else
      *mem_ptr++ = pattern;
  }

  mem_ptr = (int *)start_address;
  
  for(i=0;i<size_in_word;i++)    /* read data back from memory  */
  {
    temp_read = *mem_ptr++;
    
#if SPECIAL==ENDPNT
    if(i==0)
      printf(" Read=0x%08x at Address=0x%08x\n",temp_read,(mem_ptr-1));
    else if((i==size_in_word-1))
      printf(" Read=0x%08x at Address=0x%08x\n",temp_read,(mem_ptr-1));
#endif    

#if SPECIAL==INTERV
    if(!(i%(1024*256)))
      printf(" Read=0x%08x at Address=0x%08x\n",temp_read,(mem_ptr-1));
#endif    
    
    if(i%2)
    {
      temp_expected = ~pattern;  /* flip alternating bits       */
    }
    else
    {
      temp_expected = pattern;
    }