Subversion Repositories f9daq

Rev

Rev 11 | Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
9 f9daq 1
//****************************************************************************
2
// Copyright (C) 2000-2004  ARW Elektronik Germany
3
//
4
// This program is free software; you can redistribute it and/or modify
5
// it under the terms of the GNU General Public License as published by
6
// the Free Software Foundation; either version 2 of the License, or
7
// (at your option) any later version.
8
//
9
// This program is distributed in the hope that it will be useful,
10
// but WITHOUT ANY WARRANTY; without even the implied warranty of
11
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
// GNU General Public License for more details.
13
//
14
// You should have received a copy of the GNU General Public License
15
// along with this program; if not, write to the Free Software
16
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17
//
18
// This product is not authorized for use as critical component in 
19
// life support systems without the express written approval of 
20
// ARW Elektronik Germany.
21
//  
22
// Please announce changes and hints to ARW Elektronik
23
//
24
// Maintainer(s): Klaus Hitschler (klaus.hitschler@gmx.de)
25
//
26
//****************************************************************************
27
 
28
//****************************************************************************
29
//
30
// simpleTest.c -- a simple test program for the PCIVME PCI to VME Interface
31
//
32
// $Log: simpleTest.c,v $
33
// Revision 1.4  2004/08/13 19:23:55  klaus
34
// conversion to kernel-version 2.6, released version 3.0
35
//
36
// Revision 1.3  2002/10/17 19:05:03  klaus
37
// VME access is working through test to lib to driver
38
//
39
// Revision 1.2  2002/10/12 22:12:19  klaus
40
// simple change
41
//
42
// Revision 1.1.1.1  2002/10/09 19:36:29  klaus
43
// initial import
44
//
45
//
46
//****************************************************************************
47
 
48
/*--- INCLUDES -----------------------------------------------------------------------------------*/
49
#include <stdio.h>
50
#include <stdlib.h>
51
#include <limits.h>  // rand()
52
#include <string.h>
53
#include <unistd.h>
54
#include <sys/mman.h>
55
#include <linux/types.h>
56
#include <errno.h>
57
#include <ctype.h>
58
 
59
#include <../driver/pcivme.h>
60
#include <../lib/pcivme_ni.h>
61
 
62
/*--- DEFINES ------------------------------------------------------------------------------------*/
63
#define DEVICE_NAME   "/dev/vmemm_1"
64
#define DEFAULT_WIDTH BYTE_ACCESS
65
#define DEFAULT_MODIFIER 0x39 
66
#define BUFFER_SIZE   0x10000            // local buffer for temporary use
67
 
68
/*--- TYPEDEFS -----------------------------------------------------------------------------------*/
69
 
70
/*--- GLOBALS ------------------------------------------------------------------------------------*/
71
char *cszPrgName;
72
 
73
/*--- FUNCTIONS ----------------------------------------------------------------------------------*/
74
void hlpMsg(void)
75
{
76
    printf("simpleTest - a program to do a RAM test with help of the PCIVME interface of ARW Elektronik Germany.\n");
77
    printf("Copyright: see the GPL of the free software foundation. K.Hitschler, %s.\n", __DATE__);
78
    printf("usage: simpleTest [-d=DeviceName] -s=StartAddress [-l=Length] [-m=AddressModifier] [-w=AccessWidth] [-?]\n");
79
    printf("                   -d - choose a device to use. (Default: %s)\n", DEVICE_NAME);
80
    printf("                   -s=StartAddress - address to start the test, mandatory.\n");
81
    printf("                   -w=AccessWidth  - data element width, 1,2 or 4. (Default: %d)\n", DEFAULT_WIDTH);
82
    printf("                   -l=Length       - area length to test in bytes. (Default: equal AccessWidth)\n");
83
    printf("                   -m=AddressModifier - VME address modifier for accesses. (Default: 0x%02x)\n", DEFAULT_MODIFIER);
84
    printf("                   -? - this help.\n");
85
}
86
 
87
/*--- TEST RAM LOOP ------------------------------------------------------------------------------*/
88
__u32 SimpleRamTest(int handle, __u32 start, __u32 length, __u8 accessWidth)
89
{
90
    int  error = 0;
91
    __u32 r, w;
92
    __u32 dwErrorCount = 0;
93
 
94
    while (length >= accessWidth)
95
    {
96
        w = rand();
97
 
98
        error = VMEwrite(handle, start, accessWidth, 1, &w);
99
        if (error)
100
        {
101
            dwErrorCount++;
102
            printf("%s : Can't write @ adr: 0x%08x (%s)\n", cszPrgName, start, strerror(error));
103
        }
104
        else
105
        {
106
            error = VMEread(handle, start, accessWidth, 1, &r);
107
            if (error)
108
            {
109
                dwErrorCount++;
110
                printf("%s : Can't read @ adr: 0x%08x (%s)\n", cszPrgName, start, strerror(error));
111
            }
112
            else
113
            {
114
                error = ENOANO;
115
 
116
                switch (accessWidth)
117
                {
118
                    case BYTE_ACCESS:
119
                        if ((w & 0xff) != (r & 0xff))
120
                        {
121
                            dwErrorCount++;
122
                            printf("%s : Compare failed @ adr:0x%08x w:0x%02x r:0x%02x\n",cszPrgName, start, w & 0xff, r & 0xff);
123
                        }
124
                        break;
125
                    case WORD_ACCESS:
126
                        if ((w & 0xffff) != (r & 0xffff))
127
                        {
128
                            dwErrorCount++;
129
                            printf("%s : Compare failed @ adr:0x%08x w:0x%04x r:0x%04x\n",cszPrgName, start, w & 0xffff, r & 0xffff);
130
                        }
131
                        break;
132
                    case LONG_ACCESS:
133
                        if (w != r)
134
                        {
135
                            dwErrorCount++;
136
                            printf("%s : Compare failed @ adr:0x%08x w:0x%08x r:0x%08x\n",cszPrgName, start, w, r);
137
                        }
138
                        break;
139
                }
140
            }
141
        }
142
        length -= accessWidth;
143
        start  += accessWidth;
144
    }
145
 
146
    return dwErrorCount;
147
}
148
 
149
int main(int argc, char **argv)
150
{
151
    char *fname = DEVICE_NAME;
152
    char *ptr;
153
    char ch;
154
    int  i;
155
    int  error = 0;
156
    int  handle;
157
    __u8 bAddressModifier = DEFAULT_MODIFIER;
158
    __u8 bAccessWidth     = DEFAULT_WIDTH;
159
    __u32 dwStartAddress  = -1;
160
    __u32 dwLength        = -1;
161
 
162
    //-----------------------------------------------------------------------------------
163
    // scan command line
164
    cszPrgName = argv[0];
165
    for (i = 1; i < argc; i++)
166
    {
167
        ptr = argv[i];
168
 
169
        if (*ptr == '-')
170
            ptr++;
171
        ch = *ptr;
172
 
173
        ptr++;
174
        if (*ptr == '=')
175
            ptr++;
176
 
177
        switch (tolower(ch))
178
        {
179
            case 'h':
180
            case '?': hlpMsg(); exit(0);
181
            case 'd': fname = ptr; break;
182
            case 's': dwStartAddress = strtoul(ptr, NULL, 16); break;
183
            case 'w': bAccessWidth = (__u8)atoi(ptr); break;
184
            case 'l': dwLength = strtoul(ptr, NULL, 16); break;
185
            case 'm': bAddressModifier = (__u8)strtoul(ptr, NULL, 16); break;
186
            default:  printf("%s : Unknown command \"%c\"!\n", cszPrgName, ch); exit(0);    
187
        }
188
    }
189
 
190
    //-----------------------------------------------------------------------------------
191
    // test for correct parameters
192
    if (!fname)
193
    {
194
        printf("%s : Must have devicename!\n", cszPrgName);
195
        exit(EINVAL);
196
    }
197
 
198
    if (dwStartAddress == -1)
199
    {
200
        printf("%s : Must have a start address!\n", cszPrgName);
201
        exit(EINVAL);
202
    }
203
 
204
    if ((bAccessWidth > 4) || (bAccessWidth == 3))
205
    {
206
        printf("%s : Illegal AccessWidth (%d)!\n", cszPrgName, bAccessWidth);
207
        exit(EINVAL);
208
    }
209
 
210
    if (bAddressModifier > 0x3F)
211
    {
212
        printf("%s : Illegal VME AddressModifer (0x%02x)!\n", cszPrgName, bAddressModifier);
213
        exit(EINVAL);
214
    }
215
 
216
    if (dwLength == -1)
217
        dwLength = bAccessWidth;
218
 
219
    printf("%s: Testing %s from 0x%08x to 0x%08x with Modifier 0x%02x.\n",
220
           cszPrgName,
221
           (bAccessWidth == BYTE_ACCESS) ? "bytes" : ((bAccessWidth == WORD_ACCESS) ? "words" : "longs"),
222
           dwStartAddress, dwStartAddress + dwLength, bAddressModifier);
223
 
224
    //-----------------------------------------------------------------------------------
225
    // open the path to device
226
    error = VMEopen(fname, bAddressModifier, &handle);
227
    if (error)
228
    {
229
        printf("%s : Can't open path to %s! (%s)\n", cszPrgName, fname, strerror(error));
230
        exit(error);
231
    }
232
 
233
    //-----------------------------------------------------------------------------------
234
    // loop until error
235
    error = SimpleRamTest(handle, dwStartAddress, dwLength, bAccessWidth);
236
    if (error)
237
        printf("%s: %d test errors!\n", cszPrgName, error);
238
    else
239
        printf("%s: No test errors.\n", cszPrgName);
240
 
241
    //-----------------------------------------------------------------------------------
242
    // close the path to device
243
    error = VMEclose(handle);
244
    if (!error)
245
        printf("%s: Close OK.\n", cszPrgName);
246
    else
247
        printf("%s: Close with error, %s!\n", cszPrgName, strerror(error));
248
 
249
    return error;
250
}
251