pci_tests.c

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

                break;
            case 16:
                *(uint16*)(PCI_HOST_MEM + (address &0x00FFFFFF)) = swap16((uint16)data);
                printf("write addr 0x%08x = 0x%04X\n",address,data);
                address = address +2;
                break;
            case 32:
                /**(uint32*)(PCI_HOST_MEM + (address &0x00FFFFFF)) = swap32((uint32)data);*/
                *(uint32*)(PCI_HOST_MEM + (address &0x00FFFFFF)) = swap32((uint32)data);
                printf("write addr 0x%08x = 0x%08X\n",address,data);
                address = address +4;
                break;
            default:
                printf("Invalid size: pick 8, 16, or 32\n");
                return;
        }
    }
}
/********************************************************************/
/********************************************************************/
void
writembst (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;
                printf("size 8 not supported\n");
                break;
            case 16:
                //*(uint16*)(PCI_HOST_MEM + (address &0x00FFFFFF)) = swap16((uint16)data);
                //printf("write addr 0x%08x = 0x%04X\n",address,data);
                //address = address +2;
                printf("size 16 not supported\n");
                break;
            case 32:
                //*(uint32*)(PCI_HOST_MEM + (address &0x00FFFFFF)) = swap32((uint32)data);
                asm_memcpy32((void *)DATA0_BLOCK_START, (void*)(PCI_HOST_MEM + (address &0x00FFFFFF)), length);
                //printf("write addr 0x%08x = 0x%08X\n",address,data);
                //address = address +4;
                break;
            default:
                printf("Invalid size: pick 8, 16, or 32\n");
                return;
        }
    }
}

/********************************************************************/
/********************************************************************/
#if 0
#define PCI_AG_MEM	0xa9000000
#define PCI_ISP_MEM 0xa0000000
void
test1 (int argc, char **argv)
{
    int i, data, success, *datablock;
    
    printf("Loop write - press any key to stop\n");
    
    /* set up initiator windows */
    MCF_PCI_PCIIW0BTAR = ((PCI_HOST_MEM & 0xFF000000) | ((0xA0000000 & 0xFF000000) >>16));

    *(uint32*)(PCI_HOST_MEM) = swap32((uint32)0xDEADBEEF);
    //cpu_pause(DELAY_BETWEEN_WRITES);
    
    for (i = 0; i < 20; i++)
        nop();

/*
    for (i = 0; i < 1000; i++)
    {
        *(uint32*)(PCI_HOST_MEM) = 0xAA556699;
        nop();
    }
*/    
    while(!(MCF_PSC_SR(TERMINAL_PORT) & MCF_PSC_SR_RXRDY))
    {
        *(uint32*)(PCI_HOST_MEM+0x0c) = 0x00000000;        
        *(uint32*)(PCI_HOST_MEM+0x0c) = 0x00000000;        
        *(uint32*)(PCI_HOST_MEM+0x0c) = 0x00000000;
        *(uint32*)(PCI_HOST_MEM+0x14) = 0xffffffff;
        *(uint32*)(PCI_HOST_MEM+0x10) = 0x00000000;
        //cpu_pause(DELAY_BETWEEN_WRITES);
        for (i = 0; i < 4; i++)
            nop();
    }
    in_char();
    
    /* 
     * Read block from Agilent card and compare to original buffer 
     */
     
    /* set up initiator windows */
    MCF_PCI_PCIIW0BTAR = ((PCI_HOST_MEM & 0xFF000000) | ((0xA8000000 & 0xFF000000) >>16));

    success = TRUE;
    datablock = (int *)DATA0_BLOCK_START;
    for (i = 0; i < (DATA_BLOCK_SIZE / 4); i++)
    {
        data = (*(uint32*)(PCI_HOST_MEM + (i*4)));
        if (datablock[i] != data)
        {
            printf("Error! lw%d - src: %#08X, dst: %#08X\n",i,datablock[i],data);
            success = FALSE;
            break;
        }
    }
    if (success)
        printf("Test passed\n");
    else
        printf("Test failed\n");
}
#endif
/********************************************************************/
/********************************************************************/
void
writeio (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_PCIIW1BTAR = ((PCI_HOST_IO & 0xFF000000) | ((address & 0xFF000000) >>16));

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


}
/********************************************************************/
/********************************************************************/
void
memtest (int argc, char **argv)
{
    uint32 size      = 0;
    uint32 startaddr = 0;
    uint32 address   = 0;
    uint32 endaddr   = 0;
    uint32 repeat    = 0;
    uint32 data8     = 0;
    uint32 data16    = 0;
    uint32 data32    = 0;
    int success, i;
    unsigned int pattern[8];

    pattern[0] = 0xa5a5a5a5;
    pattern[1] = 0x5a5a5a5a;
    pattern[2] = 0x69696969;
    pattern[3] = 0x96969696;
    pattern[4] = 0xdeadbeef;
    pattern[5] = 0xbabeface;
    pattern[6] = 0xabbafeed;
    pattern[7] = 0x96969696;

    /* 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)
    {
        startaddr = get_value(argv[2],&success,16);
        if (!success)
        {
            printf(INVALUE,argv[2]);
            return;
        }
    }

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

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

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

    loop = 1;
    i = 0;


    while(loop && (repeat > 0)) // DO while still looping or my repeat value is still going
    {

        while((address < endaddr)&& loop)
        {

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

            /* increment pattern */
            i++;
            if(i >= 8)
                i=0;

        }


        /* reset start address */
        address = startaddr;

        /* decrement repeat */
        repeat = repeat -1;

    }

    /* we are done! */
    if(loop == 0)
        printf("Memtest aborted...\n");
    else
        printf("Memtest passed...\n");
}

#define PATTERN_DATA_ADDRESS    0
#define PATTERN_SWITCHING       1   /* 0xaaaaaaa, 0x55555555, ....*/
#define PATTERN_SWITCHING2      5   /* 0x00000000,0xfffffff ...*/
#define PATTERN_BYTE_INC        2   /* 0x00, 0x01, 0x02, ...*/
#define PATTERN_RANDOM          3
#define PATTERN_CHECKER_BYTE    4   /* 0x00ff00ff,0xff00ff00 */
#define PATTERN_CHECKER_BYTE2   6   /* 0xaa55aa55,0x55aa55aa */

int setupPatBuf(uint8 pattern, uint32 *src, uint32 size)
{
    uint32 *p32 = src;
    int j;
    uint8 *p8;
    
    if (size == 0)
        return(-1);    
    /* making some assumptions here about the source buffer and size
        address is longword aligned
        size is divisible by longword */    
    switch(pattern)
    {
        case PATTERN_DATA_ADDRESS:
            for (j = 0; j < size; j+=4)        
            {
                *p32 = (uint32)p32;  
                p32++;
            }
            break;
        case PATTERN_SWITCHING:
            for (j = 0; j < size; j+=8)        
            {
                *p32 = (uint32)0xaa55aa55;
                p32++;
                *p32 = (uint32)0x55aa55aa;
                p32++;        
            }
            break; 
        case PATTERN_BYTE_INC:
            p8 = (uint8*)src;
            for (j = 0; j < size; j++)        
            {
                *p8 = (uint8) (j % 256);
                p8++;
            }
            break;
#if 0            
        case PATTERN_RANDOM:
            for (j = 0; j < size; j+=4)        
            {
                *p32++ =   ((((UINT32)rand()) << 16) & 0xffff0000) | 
                             ((UINT32)rand() & 0x0000ffff);
            }
            break;
#endif            
        case PATTERN_CHECKER_BYTE:            
            for (j = 0; j < size; j+=8)        
            {
                *p32 = (uint32)0x00ff00ff;
                p32++;
                *p32 = (uint32)0xff00ff00;
                p32++;        
            }
            break;            
        case PATTERN_SWITCHING2:            
            for (j = 0; j < size; j+=8)        
            {
                *p32 = (uint32)0x00000000;
                p32++;
                *p32 = (uint32)0xffffffff;
                p32++;        
            }
            break;            
        default:
            return(-1);
            break;
    }
    return(0);            
}


void