Subversion Repositories f9daq

//****************************************************************************

// Copyright (C) 2000-2004  ARW Elektronik Germany

//

// This program is free software; you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation; either version 2 of the License, or

// (at your option) any later version.

//

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with this program; if not, write to the Free Software

// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

//

// This product is not authorized for use as critical component in 

// life support systems without the express written approval of 

// ARW Elektronik Germany.

//  

// Please announce changes and hints to ARW Elektronik

//

// Maintainer(s): Klaus Hitschler (klaus.hitschler@gmx.de)

//

//****************************************************************************

//****************************************************************************

//

// simpleTest.c -- a simple test program for the PCIVME PCI to VME Interface

//

// $Log: simpleTest.c,v $

// Revision 1.4  2004/08/13 19:23:55  klaus

// conversion to kernel-version 2.6, released version 3.0

//

// Revision 1.3  2002/10/17 19:05:03  klaus

// VME access is working through test to lib to driver

//

// Revision 1.2  2002/10/12 22:12:19  klaus

// simple change

//

// Revision 1.1.1.1  2002/10/09 19:36:29  klaus

// initial import

//

//

//****************************************************************************

/*--- INCLUDES -----------------------------------------------------------------------------------*/

#include <stdio.h>

#include <stdlib.h>

#include <limits.h>  // rand()

#include <string.h>

#include <unistd.h>

#include <sys/mman.h>

#include <linux/types.h>

#include <errno.h>

#include <ctype.h>

#include <../driver/pcivme.h>

#include <../lib/pcivme_ni.h>

/*--- DEFINES ------------------------------------------------------------------------------------*/

#define DEVICE_NAME   "/dev/vmemm_1"

#define DEFAULT_WIDTH BYTE_ACCESS

#define DEFAULT_MODIFIER 0x39 

#define BUFFER_SIZE   0x10000            // local buffer for temporary use

/*--- TYPEDEFS -----------------------------------------------------------------------------------*/

/*--- GLOBALS ------------------------------------------------------------------------------------*/

char *cszPrgName;

/*--- FUNCTIONS ----------------------------------------------------------------------------------*/

void hlpMsg(void)

{

    printf("simpleTest - a program to do a RAM test with help of the PCIVME interface of ARW Elektronik Germany.\n");

    printf("Copyright: see the GPL of the free software foundation. K.Hitschler, %s.\n", __DATE__);

    printf("usage: simpleTest [-d=DeviceName] -s=StartAddress [-l=Length] [-m=AddressModifier] [-w=AccessWidth] [-?]\n");

    printf("                   -d - choose a device to use. (Default: %s)\n", DEVICE_NAME);

    printf("                   -s=StartAddress - address to start the test, mandatory.\n");

    printf("                   -w=AccessWidth  - data element width, 1,2 or 4. (Default: %d)\n", DEFAULT_WIDTH);

    printf("                   -l=Length       - area length to test in bytes. (Default: equal AccessWidth)\n");

    printf("                   -m=AddressModifier - VME address modifier for accesses. (Default: 0x%02x)\n", DEFAULT_MODIFIER);

    printf("                   -? - this help.\n");

}

/*--- TEST RAM LOOP ------------------------------------------------------------------------------*/

__u32 SimpleRamTest(int handle, __u32 start, __u32 length, __u8 accessWidth)

{

    int  error = 0;

    __u32 r, w;

    __u32 dwErrorCount = 0;

    while (length >= accessWidth)

    {

        w = rand();

        error = VMEwrite(handle, start, accessWidth, 1, &w);

        if (error)

        {

            dwErrorCount++;

            printf("%s : Can't write @ adr: 0x%08x  AM 0x%0x %d(%s)\n", cszPrgName, start, accessWidth,error, strerror(error));

        }

        else

        {

            error = VMEread(handle, start, accessWidth, 1, &r);

            if (error)

            {

                dwErrorCount++;

                printf("%s : Can't read @ adr: 0x%08x (%s)\n", cszPrgName, start, strerror(error));

            }

            else

            {

                error = ENOANO;

                switch (accessWidth)

                {

                    case BYTE_ACCESS:

                        if ((w & 0xff) != (r & 0xff))

                        {

                            dwErrorCount++;

                            printf("%s : Compare failed @ adr:0x%08x w:0x%02x r:0x%02x\n",cszPrgName, start, w & 0xff, r & 0xff);

                        }

                        break;

                    case WORD_ACCESS:

                        if ((w & 0xffff) != (r & 0xffff))

                        {

                            dwErrorCount++;

                            printf("%s : Compare failed @ adr:0x%08x w:0x%04x r:0x%04x\n",cszPrgName, start, w & 0xffff, r & 0xffff);

                        }

                        break;

                    case LONG_ACCESS:

                        if (w != r)

                        {

                            dwErrorCount++;

                            printf("%s : Compare failed @ adr:0x%08x w:0x%08x r:0x%08x\n",cszPrgName, start, w, r);

                        }

                        break;

                }

            }

        }

        length -= accessWidth;

        start  += accessWidth;

    }

    return dwErrorCount;

}

int main(int argc, char **argv)

{

    char *fname = DEVICE_NAME;

    char *ptr;

    char ch;

    int  i;

    int  error = 0;

    int  handle;

    __u8 bAddressModifier = DEFAULT_MODIFIER;

    __u8 bAccessWidth     = DEFAULT_WIDTH;

    __u32 dwStartAddress  = -1;

    __u32 dwLength        = -1;

    //-----------------------------------------------------------------------------------

    // scan command line

    cszPrgName = argv[0];

    for (i = 1; i < argc; i++)

    {

        ptr = argv[i];

        if (*ptr == '-')

            ptr++;

        ch = *ptr;

        ptr++;

        if (*ptr == '=')

            ptr++;

        switch (tolower(ch))

        {

            case 'h':

            case '?': hlpMsg(); exit(0);

            case 'd': fname = ptr; break;

            case 's': dwStartAddress = strtoul(ptr, NULL, 16); break;

            case 'w': bAccessWidth = (__u8)atoi(ptr); break;

            case 'l': dwLength = strtoul(ptr, NULL, 16); break;

            case 'm': bAddressModifier = (__u8)strtoul(ptr, NULL, 16); break;

            default:  printf("%s : Unknown command \"%c\"!\n", cszPrgName, ch); exit(0);    

        }

    }

    //-----------------------------------------------------------------------------------

    // test for correct parameters

    if (!fname)

    {

        printf("%s : Must have devicename!\n", cszPrgName);

        exit(EINVAL);

    }

    if (dwStartAddress == -1)

    {

        printf("%s : Must have a start address!\n", cszPrgName);

        exit(EINVAL);

    }

    if ((bAccessWidth > 4) || (bAccessWidth == 3))

    {

        printf("%s : Illegal AccessWidth (%d)!\n", cszPrgName, bAccessWidth);

        exit(EINVAL);

    }

    if (bAddressModifier > 0x3F)

    {

        printf("%s : Illegal VME AddressModifer (0x%02x)!\n", cszPrgName, bAddressModifier);

        exit(EINVAL);

    }

    if (dwLength == -1)

        dwLength = bAccessWidth;

    printf("%s: Testing %s from 0x%08x to 0x%08x with Modifier 0x%02x.\n",

           cszPrgName,

           (bAccessWidth == BYTE_ACCESS) ? "bytes" : ((bAccessWidth == WORD_ACCESS) ? "words" : "longs"),

           dwStartAddress, dwStartAddress + dwLength, bAddressModifier);

    //-----------------------------------------------------------------------------------

    // open the path to device

    error = VMEopen(fname, bAddressModifier, &handle);

    if (error)

    {

        printf("%s : Can't open path to %s! (%s)\n", cszPrgName, fname, strerror(error));

        exit(error);

    }

    //-----------------------------------------------------------------------------------

    // loop until error

    error = SimpleRamTest(handle, dwStartAddress, dwLength, bAccessWidth);

    if (error)

        printf("%s: %d test errors!\n", cszPrgName, error);

    else

        printf("%s: No test errors.\n", cszPrgName);

    //-----------------------------------------------------------------------------------

    // close the path to device

    error = VMEclose(handle);

    if (!error)

        printf("%s: Close OK.\n", cszPrgName);

    else

        printf("%s: Close with error, %s!\n", cszPrgName, strerror(error));

    return error;

}