pci_tests.c

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

/*
 * File:        main.c
 * Purpose:     Main process
 *
 */

/*#define PCI_TEST_SMALL*/
#include "common.h"
#include "uif.h"
#include "pci/pci.h"
/*#include "dma/dma.h"*/
#include "pci_tests.h"

char targ0;
char targ1;
char targ2;
char targ3;
char targ4;
char targ5;

char loop = 0;

void test1 (int, char**);
asm void asm_memcpy32(void *source, void *dest, uint32 num);
void writembst (int argc, char **argv);
void memtestbst (int argc, char **argv);
void memtestbstdma (int argc, char **argv);
int setupPatBuf(uint8 pattern, uint32 *src, uint32 size);
void target (int argc, char **argv);
void target2 (int argc, char **argv);
void dma_memcpy32(void *source, void *dest, uint32 num);
void interruptTest();

/*********/
/*  offsets to internal arbitration stuff ? */

#if 0
/********************************************************************/
/* The command table entry data structure */
typedef const struct
{
    char *  cmd;                    /* command name user types, ie. GO  */
    int     min_args;               /* min num of args command accepts  */
    int     max_args;               /* max num of args command accepts  */
    void    (*func)(int, char **);  /* actual function to call          */
    char *  description;            /* brief description of command     */
    char *  syntax;                 /* syntax of command                */
} CMD;

/********************************************************************/
static char input[MAX_LINE];
static const char PROMPT[] = "dPCI> ";
#ifndef PCI_TEST_SMALL
static const char BANNER[] = "\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n.                                       .\n.                ~dPCI~                 .\n.                                       .\n.     PCI Test program for M54x5EVB     .\n.                                       .\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
#else
static const char BANNER[] = "\n PCI Tests\n";
#endif
static const char HELPMSG[] = "Enter 'help' for help.\n\n";
static const char SYNTAX[] = "Error: Invalid syntax for: %s\n";
static const char INVCMD[] = "Error: No such command: %s\n";
static const char INVALUE[] = "Error: Invalid value: %s\n";
static const char HELPFORMAT[] = "    %-10s %-22s %s %s\n";

CMD CMDTAB[] =
{
    {"help",    0, 0, help,    "Display this message", ""},
    {"show",    0, 1, show,    "Show PCI devices",    "<targ#>"},
    {"readm",   2, 3, readm,   "Read PCI Mem space",  "<size> <add h> <len h>"},
    {"readio",  2, 3, readio,  "Read PCI I/O space",  "<size> <add h> <len h>"},
    {"writem",  3, 4, writem,  "Write PCI Mem space", "<size> <add h> <data h> <len h>"},
    {"writeio", 3, 4, writeio, "Write PCI I/O space", "<size> <add h> <data h> <len h>"},
    {"memtest", 3, 4, memtest, "Test Memory space",   "<size> <start h> <end h> <loop h>"},
    {"memcmp",  3, 3, memcmp,  "Compare Memory",      "<src1 h> <src2 h> <len h>"},
    {"writemb",  3, 4, writembst,  "Write PCI Mem space burst", "<size> <add h> <data h> <len h>"},
    {"memtestb", 3, 5, memtestbst, "Test Memory space burst",   "<size> <start h> <end h> <loop h> <pattern d>"},
    {"memtestd", 3, 5, memtestbstdma, "Test Memory space dma",   "<size> <start h> <end h> <loop h> <pattern d>"},    
    {"target1", 3, 5, target, "Test as target",   "<size> <start h> <end h> <loop h>"},
    {"target2", 3, 5, target2, "Test as target2",   "<addr h> <length h> <loop> <pattern>"},
    {"interrupt", 0,0,interruptTest, "Test PCI FPGA ints", ""},    
#if 0
    {"dmatx",   3, 3, dmatx,   "DMA tx test",         "<MEM src h> <PCI dest h> <len h>"},
    {"dmarx",   3, 3, dmarx,   "DMA rx test",         "<PCI src h> <MEM dest h> <len h>"},
    {"dmastat", 0, 0, dmastat, "DMA status",          ""},
    {"fifotx",  3, 3, fifotx,  "FIFO tx test",        "<src h> <dest h> <len h>"},
    {"fiforx",  3, 3, fiforx,  "<not implemented>",   "<src h> <dest h> <len h>"},
    {"fifostat",0, 0, fifostat,"FIFO status",         ""},    
    {"test1",   0, 0, test1,   "Loop writes to PCI",  ""},
#endif    
    {"quit",    0, 0, quit,    "Exit", " "}
};

const int NUM_CMD = sizeof(CMDTAB)/sizeof(CMD);
#endif

const char PROMPT[] = "dPCI> ";

UIF_CMD UIF_CMDTAB[] =
{
    UIF_CMDS_ALL
    {"showdev",  0,1,0, show,    "Show PCI devices",    "<targ#>"},
    {"readm",    2,3,0, readm,   "Read PCI Mem space",  "<size> <add h> <len h>"},
    {"readio",   2,3,0, readio,  "Read PCI I/O space",  "<size> <add h> <len h>"},
    {"writem",   3,4,0, writem,  "Write PCI Mem space", "<size> <add h> <data h> <len h>"},
    {"writeio",  3,4,0, writeio, "Write PCI I/O space", "<size> <add h> <data h> <len h>"},
    {"memtest",  3,4,0, memtest, "Test Memory space",   "<size> <start h> <end h> <loop h>"},
    {"memcmp",   3,3,0, memcmp,  "Compare Memory",      "<src1 h> <src2 h> <len h>"},
    {"writemb",  3,4,0, writembst,  "Write PCI Mem space burst", "<size> <add h> <data h> <len h>"},
    {"memtestb", 3,5,0, memtestbst, "Test Memory space burst",   "<size> <start h> <end h> <loop h> <pattern d>"},
    {"memtestd", 3,5,0, memtestbstdma, "Test Memory space dma",   "<size> <start h> <end h> <loop h> <pattern d>"},    
    {"target1",  3,5,0, target, "Test as target",   "<size> <start h> <end h> <loop h>"},
    {"target2",  3,5,0, target2, "Test as target2",   "<addr h> <length h> <loop> <pattern>"},
    {"interrupt",0,0,0, interruptTest, "Test PCI FPGA ints", ""},
};
const int UIF_NUM_CMD = UIF_CMDTAB_SIZE;

UIF_SETCMD UIF_SETCMDTAB[] = {"",0,0,NULL,""};
const int UIF_NUM_SETCMD = 0;


#define DATA_BLOCK_SIZE         (256 * 1024)
//#define DATA0_BLOCK_START       (0x100000)
//#define DATA0_BLOCK_START       (SDRAM_ADDRESS + 0x100000) /* dram + 1MB */
#define DATA0_BLOCK_START       (SDRAM_ADDRESS + 0x1000000) /* dram + 16MB */
//#define DATA0_BLOCK_START       (SDRAM_ADDRESS + 0x40000) /* dram + 256KB  for testing BAR1*/
#define DATA1_BLOCK_START       (DATA0_BLOCK_START + DATA_BLOCK_SIZE)
#define DELAY_BETWEEN_WRITES    (1)  /* usec */

/*******************************************************************/
void
main (void)
{
    char ch;
    int i, *datablock;

    targ1 = PCI_NO_DEV;
    targ2 = PCI_NO_DEV;
    targ3 = PCI_NO_DEV;
    targ4 = PCI_NO_DEV;
    targ5 = PCI_NO_DEV;

    /*
     * Allow interrupts from IRQ7 (black button)
     */

#if 0 /*rtmtbd*/
    /* Set IRQ7 to be rising edge triggered */
    MCF_EPORT_EPPAR = MCF_EPORT_EPPAR_EPPA7(MCF_EPORT_EPPAR_EPPAx_RISING);

    /* Enable EPORT interrupt 7 requests */
    MCF_EPORT_EPIER = MCF_EPORT_EPIER_EPIE7;

    /* Enable IRQ7 in the IMR */
    MCF_INTC_IMRL &= ~(MCF_INTC_INTFRCL_INT7 | MCF_INTC_IMRL_MASKALL);
#endif
    /*
     * Enable the instruction and branch caches
     */
#if 0 
    mcf5xxx_wr_cacr(0
        | MCF5XXX_CACR_BCINVA
        | MCF5XXX_CACR_ICINVA);

    
    mcf5xxx_wr_cacr(0
        /*| MCF5XXX_CACR_BEC*/
        | MCF5XXX_CACR_IEC);
#endif
#if 1 /* enable caching for code instruction and data space, pci data space is
uncached due to difficulty managing cached space */
    /* SDRAM will be copy-back cacheable */ 
    mcf5xxx_wr_acr0(0
        | MCF5XXX_ACR_AB(SDRAM_ADDRESS)
        | MCF5XXX_ACR_AM_16M
        | MCF5XXX_ACR_EN
        | MCF5XXX_ACR_SM_IGNORE
        | MCF5XXX_ACR_DCM_CB);  

    mcf5xxx_wr_acr2(0
        | MCF5XXX_ACR_AB(SDRAM_ADDRESS)
        | MCF5XXX_ACR_AM_16M
        | MCF5XXX_ACR_EN
        | MCF5XXX_ACR_SM_IGNORE
        | MCF5XXX_ACR_DCM_CB);  

    mcf5xxx_wr_cacr(0
        | MCF5XXX_CACR_DEC
        | MCF5XXX_CACR_DDCM_IP
        | MCF5XXX_CACR_DCINVA
        | MCF5XXX_CACR_IEC
        | MCF5XXX_CACR_ICINVA);
        
  
#endif        
    /* Enable interrupts (set interrupt priority level to 0) */
//    asm_set_ipl(0);

	printf("0xfc0a8000 %x 0xfc0a8060 %x\n", *(unsigned long*)0xfc0a8000,*(unsigned long*)0xfc0a8060 );
    printf("Initialization Complete\n");

    /* init PCI */
    initPci();


    /* Set device parameters */
    pciInitDevices();

    /* Display banner */
    //printf(BANNER);
    //printf(HELPMSG);

    /* Allocate a block of data and initialize it */
    datablock = (int *)DATA0_BLOCK_START;
    datablock[0] = swap32(0xDEADBEEF);
    for (i = 1; i < (DATA_BLOCK_SIZE / 4); i++)
        datablock[i] = swap32(i);

    /* Start command loop */
    while (1)
    {
        printf(PROMPT);
        run_cmd();
    }

    return;
}

/********************************************************************/
/********************************************************************/
void
show (int argc, char **argv)
{
    uint32 arg1=0;
    int success;

    /* turn off initiator abort interrupt */
    MCF_PCI_PCIICR &= ~(MCF_PCI_PCIICR_IAE);

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

        printpciheaderinfo(PCI_TARG1_IDSEL + (arg1-1));

    }
    else
    {
        printpciheaderinfo(PCI_TARG1_IDSEL);
        printpciheaderinfo(PCI_TARG2_IDSEL);
        printpciheaderinfo(PCI_TARG3_IDSEL);
        printpciheaderinfo(PCI_TARG4_IDSEL);        
        /*printpciheaderinfo(PCI_TARG5_IDSEL);*/
    }

    /* turn on initiator abort interrupt */
    MCF_PCI_PCIICR |= MCF_PCI_PCIICR_IAE;


}
/********************************************************************/
/********************************************************************/
void
readm (int argc, char **argv)
{
    uint32 size   = 0;
    uint32 address= 0;
    uint32 length = 0;
    uint32 data8  = 0;
    uint32 data16 = 0;
    uint32 data32 = 0;
    int success, i;


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

    /* get address value */
    if(argc > 2)
    {
        address = 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;
        }
    }
    else
        length =1;

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

    for(i=0;i<length;i++)
    {
        switch(size)
        {
            case 8:
                data8 = *(uint8*)(PCI_HOST_MEM + (address &0x00FFFFFF));
                printf("addr 0x%08x = 0x%02X\n",address,data8);
                address = address +1;
                break;
            case 16:
                data16 = swap16(*(uint16*)(PCI_HOST_MEM + (address &0x00FFFFFF)));
                printf("addr 0x%08x = 0x%04X\n",address,data16);
                address = address +2;
                break;
            case 32:
                data32 = swap32(*(uint32*)(PCI_HOST_MEM + (address &0x00FFFFFF)));
                printf("addr 0x%08x = 0x%08X\n",address,data32);
                address = address +4;
                break;
            default:
                printf("Invalid size: pick 8, 16, or 32\n");
                return;
        }
    }

}
/********************************************************************/
/********************************************************************/
void
readio (int argc, char **argv)
{
    uint32 size   = 0;
    uint32 address= 0;
    uint32 length = 0;
    uint32 data8  = 0;
    uint32 data16 = 0;
    uint32 data32 = 0;
    int success, i;


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

    /* get address value */
    if(argc > 2)
    {
        address = 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;
        }
    }
    else
        length =1;

    /* set up initiator windows */
        MCF_PCI_PCIIW1BTAR = ((PCI_HOST_IO & 0xFF000000) | ((address & 0xFF000000) >>16));

    for(i=0;i<length;i++)
    {
        switch(size)
        {
            case 8:
                data8 = *(uint8*)(PCI_HOST_IO + (address &0x00FFFFFF));
                printf("addr 0x%08x = 0x%02X\n",address,data8);
                address = address +1;
                break;
            case 16:
                data16 = swap16(*(uint16*)(PCI_HOST_IO + (address &0x00FFFFFF)));
                printf("addr 0x%08x = 0x%04X\n",address,data16);
                address = address +2;
                break;
            case 32:
                data32 = swap32(*(uint32*)(PCI_HOST_IO + (address &0x00FFFFFF)));
                printf("addr 0x%08x = 0x%08X\n",address,data32);
                address = address +4;
                break;
            default:
                printf("Invalid size: pick 8, 16, or 32\n");
                return;
        }
    }

}
/********************************************************************/
/********************************************************************/
void
writem (int argc, char **argv)
{
    uint32 size   = 0;
    uint32 address= 0;
    uint32 length = 0;
    uint32 data   = 0;
    int success, i;


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

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

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

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

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

    for(i=0;i<length;i++)
    {
        switch(size)
        {
            case 8:
                *(uint8*)(PCI_HOST_MEM + (address &0x00FFFFFF)) = (uint8)data;
                printf("write addr 0x%08x = 0x%02X\n",address,data);
                address = address +1;