pci_tests.c

来自「Freescale MCF5445evb 参考测试代码」· C语言 代码 · 共 2,442 行 · 第 1/5 页

    uint32 data8     = 0;
    uint32 data16    = 0;
    uint32 data32    = 0;
    int success, i, run;
    //unsigned int pattern[8];
    uint32 pattern = 0;
    uint32 *buffSrc, *buffDst;
    volatile uint32 *buffPci;


    /* get external address value */
    if(argc > 1)
    {
        startaddr = get_value(argv[1],&success,16);
        if (!success)
        {
            printf(INVALUE,argv[1]);
            return;
        }
    }

    if(argc > 2)
    {
        length = get_value(argv[2],&success,16);
        if (!success)
        {
            printf(INVALUE,argv[2]);
            return;
        }
    }


    /* get iteration value */
    if(argc > 3)
    {
        repeat = get_value(argv[3],&success,10);
        if (!success)
        {
            printf(INVALUE,argv[3]);
            return;
        }
    }
    else
        repeat =1;
    
    /* get pattern to run */
    if (argc > 4)
    {
        pattern = get_value(argv[4],&success,10);
        if (!success)
        {
            printf(INVALUE,argv[4]);
            return;
        }   
    }
    else
        pattern = 0;

    /* set up initiator windows */
    address = startaddr;
    MCF_PCI_PCIIW0BTAR = ((PCI_HOST_MEM & 0xFF000000) | ((address & 0xFF000000) >>16));

    MCF_PCI_PCITBATR0 = 0x80000001; /* SRAM address and enable */

    run = 0;
    while(run < repeat) // DO while still looping or my repeat value is still going
    {
    
 		buffSrc =  (uint32 *)DATA0_BLOCK_START;
 		buffDst =  (uint32 *)DATA1_BLOCK_START;
 		buffPci =  (uint32 *)(PCI_HOST_MEM + (startaddr &0x00FFFFFF));    

        /* setup buffers */
        setupPatBuf(pattern, (uint32 *)DATA0_BLOCK_START , length); /* src */
        for (i = 0; i<length/4; i++) /* dst */
            buffDst[i] = 0;

        for (i = 0; i<length/4; i++) /* pci */
            buffPci[i] = 0;

        /* initialize polling location */
        *(uint32*)(0x80007ff0) = 0;
        
        
        
        /* write out trigger to PCI */
        buffPci[length/4] = 0xdead0000 | (run & 0x0000ffff); /* marker so we know which run */
        buffPci[length/4] = 0xdeadbeef; /* actual trigger */
       
                
        /* poll for done - this will affect the test for now*/
        while (*(uint32*)(0x80007ff0) != 0xdeadbeef);
 				
              
		for (i=0; i< length/4; i++)
		{
			if(buffSrc[i] != buffDst[i])
			{
				printf("memtest error %x %x\n",buffSrc[i], buffDst[i]);
			}
		}       


        /* decrement repeat */
        run++;

    }

    /* we are done! */
    printf("Target test completed...\n");
}

/* Agilent 2928a(unlike the 2925) does not have a way to disable the 
interrupt over the PCI bus, so the interrupt must be disabled manually
through te GUI. Therefore these handlers just disable the interrupt 
at the FPGA level */


/********************************************************************/
/*!
 * \brief   Interrupt handler for IRQ7
 */
__interrupt__
void irq7_handler (void)
{
    printf("IRQ7 %x\n",FPGA_PCI_IRQ_STATUS);

    /* Disable interrupt event */
    FPGA_PCI_IRQ_ENABLE = (~FPGA_PCI_IRQ_STATUS & 0x0000000f);        
}
/********************************************************************/
/*!
 * \brief   Interrupt handler for IRQ4
 */
__interrupt__
void irq4_handler (void)
{
    printf("IRQ4 %x\n",FPGA_PCI_IRQ_STATUS);

    /* Disable interrupt event */
    FPGA_PCI_IRQ_ENABLE = (~FPGA_PCI_IRQ_STATUS & 0x0000000f);        
}
/********************************************************************/
/*!
 * \brief   Interrupt handler for IRQ3
 */
__interrupt__
void irq3_handler (void)
{
    printf("IRQ3 %x\n",FPGA_PCI_IRQ_STATUS);

    /* Disable interrupt event */
    FPGA_PCI_IRQ_ENABLE = (~FPGA_PCI_IRQ_STATUS & 0x0000000f);        
}
/********************************************************************/
/*!
 * \brief   Interrupt handler for IRQ1
 */
__interrupt__
void irq1_handler (void)
{
    printf("IRQ1 %x\n",FPGA_PCI_IRQ_STATUS);

    /* Disable interrupt event */
    FPGA_PCI_IRQ_ENABLE = (~FPGA_PCI_IRQ_STATUS & 0x0000000f);        
}
/********************************************************************/

void interruptTest()
{
    /* Install handlers */
    mcf5xxx_set_handler (64 + 1, (ADDRESS) irq1_handler);
    mcf5xxx_set_handler (64 + 3, (ADDRESS) irq3_handler);
    mcf5xxx_set_handler (64 + 4, (ADDRESS) irq4_handler);
    mcf5xxx_set_handler (64 + 7, (ADDRESS) irq7_handler);

    /* Enable interrupts in the Edge Port */
    MCF_EPORT_EPPAR = 0
        | MCF_EPORT_EPPAR_EPPA1_LEVEL
        | MCF_EPORT_EPPAR_EPPA3_LEVEL
        | MCF_EPORT_EPPAR_EPPA4_LEVEL
        | MCF_EPORT_EPPAR_EPPA7_LEVEL;
    MCF_EPORT_EPIER = 0
        | MCF_EPORT_EPIER_EPIE1
        | MCF_EPORT_EPIER_EPIE3
        | MCF_EPORT_EPIER_EPIE4
        | MCF_EPORT_EPIER_EPIE7;
         
    /* Enable interrupts in the interrupt controller */
    MCF_INTC0_CIMR = MCF_INTC0_ICR1 = 1;
    MCF_INTC0_CIMR = MCF_INTC0_ICR3 = 3;
    MCF_INTC0_CIMR = MCF_INTC0_ICR4 = 4;
    MCF_INTC0_CIMR = MCF_INTC0_ICR7 = 7;
    


    /* Enable interrupts in the core */
    mcf5xxx_irq_enable();
    
    FPGA_PCI_IRQ_ENABLE = 0x0000000f;
}


/********************************************************************/
/********************************************************************/
void
memcmp (int argc, char **argv)
{
    uint32 src1   = 0;
    uint32 src2   = 0;
    uint32 length = 0;

    int success, i;


    /* get source addres value */
    if(argc > 1)
    {
        src1 = get_value(argv[1],&success,16);
        if (!success)
        {
            printf(INVALUE,argv[1]);
            return;
        }
    }

    /* get destination value */
    if(argc > 2)
    {
        src2 = get_value(argv[2],&success,16);
        if (!success)
        {
            printf(INVALUE,argv[2]);
            return;
        }
    }

    /* get length value */
    if(argc > 3)
    {
        length = get_value(argv[3],&success,16);
        if (!success)
        {
            printf(INVALUE,argv[3]);
            return;
        }
    }

    /* Test Memory */
    for(i=0;i<length;i=i+4)
    {

        if( (*(uint32*)(src1+i)) != (*(uint32*)(src2+i)) )
        {
            printf("\nmemcmp failed: src1 @ 0x%08X=0x%08X : src2 @ 0x%08X=0x%08X\n",src1+i,*(uint32*)(src1+i),src2+i,*(uint32*)(src2+i));
            printf("exiting...\n");
            return;
        }

    }

    printf("\nmemtest: passed\n");

}

#if 0
/********************************************************************/
/********************************************************************/
void
dmatx (int argc, char **argv)
{
    uint32 src   = 0;
    uint32 dest  = 0;
    uint32 length = 0;

    int success, i;


    /* get source addres value */
    if(argc > 1)
    {
        src = get_value(argv[1],&success,16);
        if (!success)
        {
            printf(INVALUE,argv[1]);
            return;
        }
    }

    /* get destination value */
    if(argc > 2)
    {
        dest = get_value(argv[2],&success,16);
        if (!success)
        {
            printf(INVALUE,argv[2]);
            return;
        }
    }

    /* get length value */
    if(argc > 3)
    {
        length = get_value(argv[3],&success,16);
        if (!success)
        {
            printf(INVALUE,argv[3]);
            return;
        }
    }


    /* Check for longword Alignment */
    if((src&0x00000003)!= 0)
    {
        printf("Source address must be longword aligned\n");
        return;
    }
    if((dest&0x00000003)!= 0)
    {
        printf("Destination address must be longword aligned\n");
        return;
    }
    if((length&0x00000003)!= 0)
    {
        printf("Length must be longword aligned\n");
        return;
    }

    init_pci_dma();
    pci_start_dma_tx((uint8*)src,(uint8*)dest, length);

}
/********************************************************************/
/********************************************************************/
void
dmarx (int argc, char **argv)
{
    uint32 src   = 0;
    uint32 dest  = 0;
    uint32 length = 0;

    int success, i;


    /* get source addres value */
    if(argc > 1)
    {
        src = get_value(argv[1],&success,16);
        if (!success)
        {
            printf(INVALUE,argv[1]);
            return;
        }
    }

    /* get destination value */
    if(argc > 2)
    {
        dest = get_value(argv[2],&success,16);
        if (!success)
        {
            printf(INVALUE,argv[2]);
            return;
        }
    }

    /* get length value */
    if(argc > 3)
    {
        length = get_value(argv[3],&success,16);
        if (!success)
        {
            printf(INVALUE,argv[3]);
            return;
        }
    }

    /* Check for longword Alignment */
    if((src&0x00000003)!= 0)
    {
        printf("Source address must be longword aligned\n");
        return;
    }
    if((dest&0x00000003)!= 0)
    {
        printf("Destination address must be longword aligned\n");
        return;
    }
    if((length&0x00000003)!= 0)
    {
        printf("Length must be longword aligned\n");
        return;
    }

    init_pci_dma();
    pci_start_dma_rx((uint8*)src,(uint8*)dest, length);

}
/********************************************************************/
/********************************************************************/
void
dmastat (int argc, char **argv)
{
    int txstatus, rxstatus;

    txstatus = MCD_dmaStatus(dma_get_channel(DMA_PCI_TX));
    printf("DMA_PCITX_CH = 0x%08X\n",txstatus);

    if(txstatus == MCD_NO_DMA)
        printf("    MCD_NO_DMA\n");
    if(txstatus == MCD_IDLE)
        printf("    MCD_IDLE\n");
    if(txstatus == MCD_RUNNING)
        printf("    MCD_RUNNING\n");
    if(txstatus == MCD_PAUSED)
        printf("    MCD_PAUSED\n");
    if(txstatus == MCD_HALTED)
        printf("    MCD_HALTED\n");
    if(txstatus == MCD_DONE)
        printf("    MCD_DONE\n");
    if(txstatus == MCD_CHANNEL_INVALID)
        printf("    MCD_CHANNEL_INVALID\n");

    rxstatus = MCD_dmaStatus(dma_get_channel(DMA_PCI_RX));
    printf("DMA_PCIRX_CH = 0x%08X\n",rxstatus);

    if(rxstatus == MCD_NO_DMA)
        printf("    MCD_NO_DMA\n");
    if(rxstatus == MCD_IDLE)
        printf("    MCD_IDLE\n");
    if(rxstatus == MCD_RUNNING)
        printf("    MCD_RUNNING\n");
    if(rxstatus == MCD_PAUSED)
        printf("    MCD_PAUSED\n");
    if(rxstatus == MCD_HALTED)
        printf("    MCD_HALTED\n");
    if(rxstatus == MCD_DONE)
        printf("    MCD_DONE\n");
    if(rxstatus == MCD_CHANNEL_INVALID)
        printf("    MCD_CHANNEL_INVALID\n");


}
/********************************************************************/
/********************************************************************/
void
fifotx (int argc, char **argv)
{
    uint32 src    = 0;
    uint32 dest   = 0;
    uint32 length = 0;
    uint32 index  = 0;
    int success, i;


    /* get source addres value */
    if(argc > 1)
    {
        src = get_value(argv[1],&success,16);
        if (!success)
        {
            printf(INVALUE,argv[1]);
            return;
        }
    }

    /* get destination value */
    if(argc > 2)
    {
        dest = get_value(argv[2],&success,16);
        if (!success)
        {
            printf(INVALUE,argv[2]);
            return;
        }
    }

    /* get length value */
    if(argc > 3)
    {
        length = get_value(argv[3],&success,16);
        if (!success)
        {
            printf(INVALUE,argv[3]);
            return;
        }
    }