Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
9 | f9daq | 1 | //------------------------------------------------------------------------------------------- |
2 | // pvmon.c - the body of a simple tool to access VME BUS resources |
||
3 | // |
||
4 | // (c) 1999-2002 ARW Elektronik |
||
5 | // |
||
6 | // this source code is published under GPL (Open Source). You can use, redistrubute and |
||
7 | // modify it unless this header is not modified or deleted. No warranty is given that |
||
8 | // this software will work like expected. |
||
9 | // This product is not authorized for use as critical component in life support systems |
||
10 | // wihout the express written approval of ARW Elektronik Germany. |
||
11 | // |
||
12 | // Please announce changes and hints to ARW Elektronik |
||
13 | // |
||
14 | // $Log: pvmon.c,v $ |
||
15 | // Revision 1.6 2002/11/14 19:57:56 klaus |
||
16 | // improvement, still bugs active |
||
17 | // |
||
18 | // Revision 1.5 2002/10/20 18:07:48 klaus |
||
19 | // mostly working alpha version |
||
20 | // |
||
21 | // Revision 1.4 2002/10/20 11:49:33 klaus |
||
22 | // first parts working |
||
23 | // |
||
24 | // Revision 1.3 2002/10/19 09:47:30 klaus |
||
25 | // first success compiling project |
||
26 | // |
||
27 | // Revision 1.2 2002/10/19 09:44:38 klaus |
||
28 | // first success compiling project |
||
29 | // |
||
30 | // Revision 1.1.1.1 2002/10/18 22:14:29 klaus |
||
31 | // |
||
32 | // first parts written and published from |
||
33 | // Sven Hannover, Sven Tuecke, Klaus Hitschler, Ralf Dux 1991 |
||
34 | // |
||
35 | |||
36 | //------------------------------------------------------------------------------------------- |
||
37 | // INCLUDES |
||
38 | // |
||
39 | #include <unistd.h> |
||
40 | #include <sys/types.h> |
||
41 | #include <sys/ioctl.h> |
||
42 | #include <sys/stat.h> |
||
43 | #include <fcntl.h> |
||
44 | #include <errno.h> |
||
45 | |||
46 | #include <setjmp.h> |
||
47 | #include <signal.h> |
||
48 | #include <stdio.h> |
||
49 | #include <stdlib.h> |
||
50 | #include <string.h> |
||
51 | #include <time.h> |
||
52 | |||
53 | #include <slang.h> |
||
54 | |||
55 | #include <../driver/vme.h> /* constants about VME BUS */ |
||
56 | #include <mbuffer.h> /* simple message buffering */ |
||
57 | #include <pcilibLx.h> /* device access functions */ |
||
58 | |||
59 | //------------------------------------------------------------------------------------------- |
||
60 | // DEFINES |
||
61 | // |
||
62 | #define VERSION "6.0Lx" |
||
63 | #define True 1 |
||
64 | #define False 0 |
||
65 | |||
66 | #if !defined(FALSE) || !defined(TRUE) |
||
67 | #define FALSE False |
||
68 | #define TRUE True |
||
69 | #endif |
||
70 | |||
71 | #define DEVPATH " - No input neccessary!" // not used |
||
72 | #define DEFDEVICENAME "/dev/vmemm_1" |
||
73 | #define DEFAULT_ADDRESS 0x00000000 // default VME window base address |
||
74 | #define DEFAULT_MODIFIER Std_NoPriv_Data // default address modifier |
||
75 | #define DEFAULT_TYPE sizeof(char) // default data BUS access width |
||
76 | #define MAX_TIMEOUT_LOOPS 100000 // maximum loops for waiting reset finished |
||
77 | |||
78 | //------------------------------------------------------------------------------------------- |
||
79 | // TYPEDEFS |
||
80 | // |
||
81 | typedef char STRG[BUFFERLENGTH]; /* Allgemeiner Stringtyp */ |
||
82 | |||
83 | //------------------------------------------------------------------------------------------- |
||
84 | // LOCALS |
||
85 | // |
||
86 | static char UpCase(char Zchn); |
||
87 | static char *ParaStr(int Num); |
||
88 | static unsigned long ParaNum(int Num); |
||
89 | static void SetModifier(void); |
||
90 | static void PrintItem(unsigned long Addr, char Mode, unsigned char *Asc); |
||
91 | static char GetZug(char *Zug); |
||
92 | static void Dump(void); |
||
93 | static char GetStrg(STRG Stg, int Len); |
||
94 | static void Examine(void); |
||
95 | static void Move(void); |
||
96 | static void Fill(void); |
||
97 | static void Hilfe(void); |
||
98 | static int InitAt(char *szDevicePath, int *nInterfaceHandle); |
||
99 | static void CfgName(STRG Stg); |
||
100 | static void LoadKonfig(void); |
||
101 | static void Konfig(void); |
||
102 | static void ReadIrqVect(void); |
||
103 | static void JumpToDos(void); |
||
104 | static void Raus(void); |
||
105 | static void SearchPort(char *Art, |
||
106 | int Anz, |
||
107 | unsigned short modf, |
||
108 | void(*SFunc)(int nHandle, unsigned long Adr,unsigned short AModifier)); |
||
109 | static void SearchPorts(void); |
||
110 | static unsigned GibNum(char **PSt,char Anz); |
||
111 | static int _ReadFile(void); |
||
112 | static void SeekPatt(void); |
||
113 | static void TestSet(void); |
||
114 | static void ResetVme(void); |
||
115 | static int OutHex(FILE *OuF, int Siz, unsigned long Adr, int Typ, char Buf[]); |
||
116 | static int _WriteFile(void); |
||
117 | static void ShowModifier(int Mode); |
||
118 | static void ShowRegister(void); |
||
119 | static int HauptMenue(STRG Stg); |
||
120 | static void MyExit(int); |
||
121 | static void SysFail(void); |
||
122 | |||
123 | //------------------------------------------------------------------------------------------- |
||
124 | // EXTERNALS |
||
125 | // |
||
126 | |||
127 | //------------------------------------------------------------------------------------------- |
||
128 | // GLOBALS |
||
129 | // |
||
130 | static unsigned short AdrMode = Short_NoPriv; /* Mein initialer Adressmodifier */ |
||
131 | static char DefZug = 'B'; /* Default Zugriff */ |
||
132 | static char DefVec = 'B'; /* Default Zugriff IrqVecs */ |
||
133 | static char **ArgV; /* ArgV aus main() */ |
||
134 | static STRG InStg; /* Allgemeiner Eingabestring */ |
||
135 | |||
136 | static char *TsT; |
||
137 | static char Abbruch = 0; /* verzweig wg. SIGINT */ |
||
138 | |||
139 | static int nInterfaceHandle; /* handle of device */ |
||
140 | static char *cszDevicePath; /* path of device */ |
||
141 | static int WordMode; /* mode of VME path operation */ |
||
142 | |||
143 | static char localBuffer[BUFFERLENGTH] = DEFDEVICENAME; |
||
144 | |||
145 | //------------------------------------------------------------------------------------------- |
||
146 | // FUNCTIONS |
||
147 | // |
||
148 | //----------------------------------------------------------------------------- |
||
149 | // functions to emulate for this platform |
||
150 | static int getch(void) |
||
151 | { |
||
152 | return SLang_getkey(); |
||
153 | } |
||
154 | |||
155 | |||
156 | static void strlwr(char *str) |
||
157 | { |
||
158 | int i; |
||
159 | char *ptr = str; |
||
160 | |||
161 | for (i = 0; ((i < BUFFERLENGTH) && (*ptr)); i++) |
||
162 | { |
||
163 | *ptr = tolower(*ptr); |
||
164 | ptr++; |
||
165 | } |
||
166 | } |
||
167 | |||
168 | static int _gets(char *str) |
||
169 | { |
||
170 | if (fgets(str, BUFFERLENGTH, (FILE *)stdin) == NULL) |
||
171 | return EINVAL; |
||
172 | else |
||
173 | { |
||
174 | // remove '\n' from string |
||
175 | int i; |
||
176 | char *ptr = str; |
||
177 | |||
178 | for (i = 0; i < BUFFERLENGTH; i++, ptr++) |
||
179 | { |
||
180 | if (*ptr == '\n') |
||
181 | { |
||
182 | *ptr = 0; |
||
183 | break; |
||
184 | } |
||
185 | } |
||
186 | return 0; |
||
187 | } |
||
188 | } |
||
189 | |||
190 | //----------------------------------------------------------------------------- |
||
191 | // get out of here |
||
192 | static void Raus(void) |
||
193 | { |
||
194 | DeInit_Interface(nInterfaceHandle); |
||
195 | exit(0); |
||
196 | } |
||
197 | |||
198 | //----------------------------------------------------------------------------- |
||
199 | // return the uppercase char |
||
200 | static char UpCase(char Zchn) /* Upcase eines Zeichens */ |
||
201 | { |
||
202 | return((Zchn >= 'a' && Zchn <= 'z') ? Zchn - 0x20 : Zchn); |
||
203 | } |
||
204 | |||
205 | //----------------------------------------------------------------------------- |
||
206 | // get the n-th parameter as string |
||
207 | static char *ParaStr(int Num) /* Hole n-ten Parameter */ |
||
208 | { /* als String aus InStg */ |
||
209 | char *PSt; /* Evt. Ergebnis NULL bei (Num>1) */ |
||
210 | |||
211 | PSt=InStg; /* Fange bei InStg[0] an */ |
||
212 | if (Num > 1) |
||
213 | { /* Folgeparameter: suche Anfang */ |
||
214 | if (*PSt!='\0') |
||
215 | { /* Leerstring ignorieren */ |
||
216 | PSt++; |
||
217 | switch (*PSt) |
||
218 | { /* Teste evt. Modusparameter */ |
||
219 | case 'L': |
||
220 | case 'W': |
||
221 | case 'B': |
||
222 | case 'X': |
||
223 | case 'H':PSt++; |
||
224 | } |
||
225 | |||
226 | if (*PSt==' ') PSt++; /* Evt. Delimiter ueberspringen */ |
||
227 | } |
||
228 | |||
229 | if (*PSt=='\0') PSt=NULL; /* Kein weiterer Parameter da */ |
||
230 | else |
||
231 | { |
||
232 | while (PSt!=NULL && Num>2) |
||
233 | { |
||
234 | PSt=strchr(PSt, ' '); /* Suche nach Delimiter */ |
||
235 | if (PSt!=NULL) PSt++; /* Delimiter ueberspringen */ |
||
236 | Num--; /* Naechster Parameter da */ |
||
237 | } /* while */ |
||
238 | } /* else */ |
||
239 | } /* if */ |
||
240 | return(PSt); |
||
241 | } |
||
242 | |||
243 | //----------------------------------------------------------------------------- |
||
244 | // get the n-th parameter as unsigned long |
||
245 | static unsigned long ParaNum(int Num) /* Hole n-ten Parameter */ |
||
246 | { /* als Zahl aus InStg */ |
||
247 | unsigned long Erg; |
||
248 | char *PSt; |
||
249 | |||
250 | PSt=ParaStr(Num); /* Hole Parameterstring */ |
||
251 | Erg=0; /* Hole Word aus String */ |
||
252 | if (PSt!=NULL) sscanf(PSt, "%lx", &Erg); |
||
253 | return(Erg); |
||
254 | } |
||
255 | |||
256 | //----------------------------------------------------------------------------- |
||
257 | // set the address modifier for following accesses |
||
258 | static void SetModifier(void) /* Neuen Adressmodifier setzen */ |
||
259 | { |
||
260 | int Idx; |
||
261 | |||
262 | if (ParaStr(1)[1]=='H') |
||
263 | { /* Wenn Hilfsfunktion gewuenscht */ |
||
264 | if (ParaStr(2)==NULL) |
||
265 | { /* Noch ein Parameter da? */ |
||
266 | for (Idx=0; Idx<0x40; Idx++) |
||
267 | { /* Nein: Liste ausgeben */ |
||
268 | ShowModifier(Idx); |
||
269 | if ((Idx == 0x10) || (Idx == 0x20) || (Idx == 0x30)) |
||
270 | { |
||
271 | printf("\n go on ?\r"); |
||
272 | getch(); |
||
273 | } |
||
274 | } |
||
275 | printf("\n"); |
||
276 | } |
||
277 | else ShowModifier((int)ParaNum(2)); /* Nur gewuenschten Mode anzeigen */ |
||
278 | } |
||
279 | else |
||
280 | { |
||
281 | if (ParaStr(2) != NULL) |
||
282 | { |
||
283 | if (ParaStr(1)[1] == 'M') |
||
284 | { |
||
285 | AdrMode=(int)ParaNum(3) & 0x3f; |
||
286 | } |
||
287 | else |
||
288 | { |
||
289 | AdrMode=(int)ParaNum(2) & 0x3f; /* Adressmodifier merken */ |
||
290 | } |
||
291 | } |
||
292 | ShowModifier(AdrMode); /* Status Adressmodifier zeigen */ |
||
293 | } /* else */ |
||
294 | } |
||
295 | |||
296 | //----------------------------------------------------------------------------- |
||
297 | // print out an item |
||
298 | static void PrintItem(unsigned long Addr, char Mode, unsigned char *Asc) |
||
299 | { |
||
300 | unsigned long xl; |
||
301 | unsigned int xi; |
||
302 | unsigned char xc; |
||
303 | |||
304 | switch (Mode) |
||
305 | { |
||
306 | case 'L': xl=ReadLong(nInterfaceHandle, Addr, AdrMode); |
||
307 | if (GetError(nInterfaceHandle)) |
||
308 | { |
||
309 | ClearError(nInterfaceHandle); printf("******** "); |
||
310 | } |
||
311 | else |
||
312 | { |
||
313 | printf("%08lx ", xl); |
||
314 | if (Asc != NULL) *(unsigned long *)Asc=xl; |
||
315 | } |
||
316 | break; |
||
317 | case 'W': xi=ReadWord(nInterfaceHandle, Addr, AdrMode); |
||
318 | if (GetError(nInterfaceHandle)) |
||
319 | { |
||
320 | ClearError(nInterfaceHandle); printf("**** "); |
||
321 | } |
||
322 | else |
||
323 | { |
||
324 | printf("%04hx ", xi); |
||
325 | if (Asc != NULL) *(unsigned short *)Asc=xi; |
||
326 | } |
||
327 | break; |
||
328 | case 'B': xc=ReadByte(nInterfaceHandle, Addr, AdrMode); |
||
329 | if (GetError(nInterfaceHandle)) |
||
330 | { |
||
331 | ClearError(nInterfaceHandle); printf("**"); |
||
332 | } |
||
333 | else |
||
334 | { |
||
335 | printf("%02hx", xc); |
||
336 | if (Asc != NULL) *Asc=xc; |
||
337 | } |
||
338 | break; |
||
339 | }; /* switch */ |
||
340 | } |
||
341 | |||
342 | //----------------------------------------------------------------------------- |
||
343 | // test whether byte word or long access |
||
344 | static char GetZug(char *Zug) /* Moduszeichen feststellen */ |
||
345 | { |
||
346 | switch (ParaStr(1)[1]) |
||
347 | { /* Moduszchn ist angegeben */ |
||
348 | case 'L': |
||
349 | case 'W': |
||
350 | case 'B':*Zug = ParaStr(1)[1]; /* Neues Moduszchn festlegen */ |
||
351 | } |
||
352 | return(*Zug); |
||
353 | } |
||
354 | |||
355 | //----------------------------------------------------------------------------- |
||
356 | // get or set SYSFAIL |
||
357 | static void SysFail(void) |
||
358 | { |
||
359 | if (ParaStr(2) != NULL) |
||
360 | { |
||
361 | if (ParaNum(2) > 0) |
||
362 | SetSfail(nInterfaceHandle); |
||
363 | else |
||
364 | ClrSfail(nInterfaceHandle); |
||
365 | } |
||
366 | |||
367 | if (PollSfail(nInterfaceHandle)) |
||
368 | printf("SYSFAIL deasserted\n"); |
||
369 | else |
||
370 | printf("SYSFAIL asserted\n"); |
||
371 | } |
||
372 | |||
373 | |||
374 | //----------------------------------------------------------------------------- |
||
375 | // dump a range of memory |
||
376 | static void Dump(void) /* Ausgabe eines Bereichs */ |
||
377 | { |
||
378 | static unsigned long DefVon=0; /* Default Addr fuer Dump */ |
||
379 | |||
380 | unsigned long Bis; /* Bis wohin ausgeben */ |
||
381 | unsigned int Len; /* Wieviel Bytes/Ausgabe */ |
||
382 | unsigned int Idx; /* Index */ |
||
383 | char Asc[16]; /* ohne static gehts bei dw nicht */ |
||
384 | |||
385 | if (ParaStr(2) != NULL) /* Von-Adresse angegeben? */ |
||
386 | DefVon=ParaNum(2); |
||
387 | Len=1; |
||
388 | |||
389 | switch (GetZug(&DefZug)) |
||
390 | { /* Zugriffsmodus festlegen */ |
||
391 | case 'L':Len+=2; /* Auf Long-Adresse biegen */ |
||
392 | case 'W':Len++; /* Auf Wort-Adresse biegen */ |
||
393 | } |
||
394 | |||
395 | DefVon&=-(long)Len; /* Adressen geradebiegen */ |
||
396 | if (ParaStr(3) != NULL) |
||
397 | { /* Bis-Adresse angegeben? */ |
||
398 | Bis=ParaNum(3); |
||
399 | } |
||
400 | else |
||
401 | Bis=(DefVon+0x7f) | 0x0f; /* Default fuer Bis errechnen */ |
||
402 | |||
403 | printf("%08lx: ", DefVon); |
||
404 | for (Idx=0; Idx < (DefVon & 0x0f)/Len*(2*Len+1); Idx++) |
||
405 | printf(" "); |
||
406 | |||
407 | memset(Asc, ' ', sizeof(Asc)); /* Initialize String to Spaces */ |
||
408 | while ((True) && (!Abbruch)) |
||
409 | { |
||
410 | PrintItem(DefVon, DefZug, /* Gebe eine Speicherstelle aus */ |
||
411 | &Asc[DefVon & 0x0f]); /* Merke Zeichen in Asc */ |
||
412 | DefVon+=Len; /* Zaehler erhoehen */ |
||
413 | |||
414 | if ((DefVon > Bis) || (!(DefVon & 0x0f))) |
||
415 | { |
||
416 | printf(" "); |
||
417 | for (Idx=0; Idx < sizeof(Asc); Idx++) |
||
418 | { |
||
419 | if (Asc[Idx] < ' ') printf("."); /* Ascii-String ausgeben */ |
||
420 | else printf("%c", Asc[Idx]); /* Ctrl-Zeichen als Punkte */ |
||
421 | } |
||
422 | |||
423 | printf("\n"); |
||
424 | if (DefVon <= Bis) |
||
425 | { |
||
426 | printf("%08lx: ", DefVon); /* Neue Zeile bei 16er-Grenze */ |
||
427 | memset(Asc, ' ', sizeof(Asc)); /* Init String */ |
||
428 | } |
||
429 | else return; /* Ausstieg */ |
||
430 | } |
||
431 | else |
||
432 | { /* Sonst Leerzeichen ausgeben */ |
||
433 | printf(((DefVon & 0x0f) == 0x08) ? "|":" "); |
||
434 | } |
||
435 | } /* while */ |
||
436 | } |
||
437 | |||
438 | //----------------------------------------------------------------------------- |
||
439 | // read a string with editing functions |
||
440 | static char GetStrg(STRG Stg, int Len) /* Lese String ein bis Spc */ |
||
441 | { |
||
442 | int Idx; /* Zugriffsindex */ |
||
443 | char Zch; /* Eingabezeichen */ |
||
444 | |||
445 | Idx=0; /* Vorne anfangen */ |
||
446 | do |
||
447 | { |
||
448 | Zch=(char)getch(); /* Hole ein Zeichen */ |
||
449 | if ((unsigned char)Zch >' ' && Zch!='\t') |
||
450 | { |
||
451 | if (Idx<Len) |
||
452 | { |
||
453 | printf("%c",Zch); /* Zeichen ok, Ausgeben */ |
||
454 | Stg[Idx++]=Zch; /* Zeichen ablegen */ |
||
455 | } |
||
456 | } |
||
457 | else |
||
458 | { |
||
459 | switch (Zch) |
||
460 | { |
||
461 | case '\b':if (Idx) |
||
462 | { /* Backspace=Delete? */ |
||
463 | Idx--; /* Loesche Zeichen aus String */ |
||
464 | printf("\b \b"); /* und vom Bildschirm */ |
||
465 | } |
||
466 | case '\t': |
||
467 | case '\r':break; /* Return? Endezeichen 13 */ |
||
468 | default:Zch=0; /* Ende mit Endezeichen 0 */ |
||
469 | } /* switch */ |
||
470 | } /* else */ |
||
471 | } while (Zch && Zch!='\r' && Zch!='\n'); |
||
472 | |||
473 | Stg[Idx]='\0'; /* Stringende eintragen */ |
||
474 | return(Zch); /* Returncode = Abschlusstaste */ |
||
475 | } |
||
476 | |||
477 | //----------------------------------------------------------------------------- |
||
478 | // examine a memory location |
||
479 | static void Examine(void) /* Speicherbereich aendern */ |
||
480 | { |
||
481 | unsigned long DefVon; /* Anfangsadresse */ |
||
482 | unsigned long Inh; /* Neuer Inhalt */ |
||
483 | int Len; /* Item-Laenge */ |
||
484 | int Idx; /* Index */ |
||
485 | char End; /* Endmodus */ |
||
486 | STRG Stg; /* Eingabestring */ |
||
487 | |||
488 | if (ParaStr(2)!=NULL) |
||
489 | { /* Adresse benoetigt */ |
||
490 | Len=1; |
||
491 | switch (GetZug(&DefZug)) |
||
492 | { /* Zugriffsmodus festlegen */ |
||
493 | case 'L':Len+=2; /* Auf Long-Adresse biegen */ |
||
494 | case 'W':Len++; /* Auf Wort-Adresse biegen */ |
||
495 | } |
||
496 | DefVon=ParaNum(2) & -(long)Len; /* Adressen geradebiegen */ |
||
497 | if (ParaStr(3)!=NULL) |
||
498 | { /* Wert angegeben? */ |
||
499 | Inh=ParaNum(3); /* Hole auszugebenden Wert */ |
||
500 | switch (DefZug) |
||
501 | { |
||
502 | case 'L': WriteLong(nInterfaceHandle, DefVon,Inh,AdrMode); |
||
503 | break; |
||
504 | case 'W': WriteWord(nInterfaceHandle, DefVon,(short)Inh,AdrMode); |
||
505 | break; |
||
506 | case 'B': WriteByte(nInterfaceHandle, DefVon,(char)Inh,AdrMode); |
||
507 | break; |
||
508 | }; /* switch */ |
||
509 | |||
510 | if (GetError(nInterfaceHandle)) |
||
511 | { /* Fehlerpruefung: VME-Transfer ok? */ |
||
512 | ClearError(nInterfaceHandle); /* Zuruecksetzen Fehlerflag */ |
||
513 | printf("Error\n"); /* Zugriff gescheitert */ |
||
514 | } |
||
515 | } |
||
516 | else |
||
517 | { |
||
518 | SLang_init_tty(-1, 0, 1); |
||
519 | SLtt_get_terminfo(); |
||
520 | |||
521 | End='\n'; /* Bei Einstieg drucke Adresse */ |
||
522 | do |
||
523 | { |
||
524 | if (End=='\n' || End=='\177' || !(DefVon % 8)) |
||
525 | { |
||
526 | if (End!='\n') printf("\n"); /* Bei Einstieg nicht <CRLF> */ |
||
527 | printf("%08lx: ", DefVon); /* Adresse ausgeben */ |
||
528 | } |
||
529 | |||
530 | PrintItem(DefVon,DefZug,NULL); /* Gebe eine Speicherstelle aus */ |
||
531 | printf("."); |
||
532 | SLtt_flush_output(); |
||
533 | |||
534 | End=GetStrg(Stg,Len << 1); /* Hole begrenzte Eingabezeile */ |
||
535 | |||
536 | for (Idx=strlen(Stg); Idx<2+(Len << 1); Idx++) |
||
537 | printf(" "); |
||
538 | if (sscanf(Stg,"%lx",&Inh)>0) |
||
539 | { /* Hexzahl rausholen und ausgeben */ |
||
540 | switch (DefZug) |
||
541 | { |
||
542 | case 'L': WriteLong(nInterfaceHandle, DefVon,Inh,AdrMode); |
||
543 | break; |
||
544 | case 'W': WriteWord(nInterfaceHandle, DefVon,(short)Inh,AdrMode); |
||
545 | break; |
||
546 | case 'B': WriteByte(nInterfaceHandle, DefVon,(char)Inh,AdrMode); |
||
547 | break; |
||
548 | }; /* switch */ |
||
549 | |||
550 | if (GetError(nInterfaceHandle)) |
||
551 | ClearError(nInterfaceHandle);/* Fehlerpruefung: VME-Transfer ok? */ |
||
552 | } /* if sscanf */ |
||
553 | |||
554 | if (End == '\177') DefVon-=Len;/* Naechste Speicherzelle ansteuern */ |
||
555 | else DefVon+=Len; |
||
556 | } while (End!='\r'); |
||
557 | /* Ende bei <CR> */ |
||
558 | printf("\n"); |
||
559 | |||
560 | SLang_reset_tty(); |
||
561 | } /* else */ |
||
562 | } /* if */ |
||
563 | else printf("\a"); /* Fehler: zuwenig Parameter */ |
||
564 | } |
||
565 | |||
566 | //----------------------------------------------------------------------------- |
||
567 | // fill a range of memory |
||
568 | static void Fill(void) /* Fuellt Speicherbereich mit Wert */ |
||
569 | { |
||
570 | char DefZug; /* Zugriffsart */ |
||
571 | int Len; /* Item Laenge */ |
||
572 | unsigned long Idx; /* Index */ |
||
573 | unsigned long End; /* Endadresse */ |
||
574 | unsigned long Patt; /* Fuellmuster */ |
||
575 | unsigned char Merk_error = 0; /* Haelt error flag */ |
||
576 | |||
577 | DefZug=' '; /* Modus muss angeben werden */ |
||
578 | if (GetZug(&DefZug)!=' ' && ParaStr(4)!=NULL) |
||
579 | { |
||
580 | Len=1; |
||
581 | switch (GetZug(&DefZug)) |
||
582 | { /* Zugriffsmodus festlegen */ |
||
583 | case 'L':Len+=2; /* Auf Long-Adresse biegen */ |
||
584 | case 'W':Len++; /* Auf Wort-Adresse biegen */ |
||
585 | } |
||
586 | Idx=ParaNum(2) & -(long)Len; /* Adressen geradebiegen */ |
||
587 | End=ParaNum(3); /* Endadresse festlegen */ |
||
588 | Patt=ParaNum(4); /* Pattern merken (geht schneller) */ |
||
589 | |||
590 | while ((Idx<=End) && (!Abbruch)) |
||
591 | { |
||
592 | switch (DefZug) |
||
593 | { |
||
594 | case 'L':WriteLong(nInterfaceHandle, Idx, Patt, AdrMode); |
||
595 | break; |
||
596 | case 'W':WriteWord(nInterfaceHandle, Idx, (short)Patt, AdrMode); |
||
597 | break; |
||
598 | case 'B':WriteByte(nInterfaceHandle, Idx, (char)Patt, AdrMode); |
||
599 | break; |
||
600 | } /* switch */ |
||
601 | |||
602 | if (GetError(nInterfaceHandle)) |
||
603 | { |
||
604 | ClearError(nInterfaceHandle); /* Fehler abfangen */ |
||
605 | Merk_error = 1; |
||
606 | } |
||
607 | if ((Idx & 0xffl)==0) |
||
608 | { /* Ermoegliche Ctrl-C */ |
||
609 | printf("\r"); |
||
610 | } |
||
611 | Idx+=Len; |
||
612 | } /* while */ |
||
613 | if (Merk_error) printf("--> Memory fill failed\a\n"); |
||
614 | } |
||
615 | else printf("\a"); |
||
616 | } |
||
617 | |||
618 | //----------------------------------------------------------------------------- |
||
619 | // moves a range of memory |
||
620 | static void Move(void) /* Schiebt Speicherbereich */ |
||
621 | { |
||
622 | char DefZug; /* Zugriffsart */ |
||
623 | int Len; /* Item Laenge */ |
||
624 | unsigned long Idx; /* Index */ |
||
625 | unsigned long End; /* Endadresse */ |
||
626 | unsigned long Dest; /* Zieladresse */ |
||
627 | unsigned long Wert; /* Kopiewert */ |
||
628 | unsigned char Merk_error = 0; /* Haelt error flag */ |
||
629 | |||
630 | |||
631 | DefZug=' '; /* Modus muss angeben werden */ |
||
632 | if (GetZug(&DefZug)!=' ' && ParaStr(4)!=NULL) |
||
633 | { |
||
634 | Len=1; |
||
635 | switch (GetZug(&DefZug)) |
||
636 | { /* Zugriffsmodus festlegen */ |
||
637 | case 'L':Len+=2; /* Auf Long-Adresse biegen */ |
||
638 | case 'W':Len++; /* Auf Wort-Adresse biegen */ |
||
639 | } |
||
640 | Idx=ParaNum(2) & -(long)Len; /* Adressen geradebiegen */ |
||
641 | End=ParaNum(3); /* Endadresse festlegen */ |
||
642 | Dest=ParaNum(4); /* Zieladresse setzen */ |
||
643 | |||
644 | while ((Idx<=End) && (!Abbruch)) |
||
645 | { |
||
646 | switch (DefZug) |
||
647 | { |
||
648 | case 'L': { |
||
649 | Wert = ReadLong(nInterfaceHandle, Idx, AdrMode); |
||
650 | WriteLong(nInterfaceHandle, Dest, Wert, AdrMode); |
||
651 | } |
||
652 | break; |
||
653 | case 'W': { |
||
654 | Wert = ReadWord(nInterfaceHandle, Idx, AdrMode); |
||
655 | WriteWord(nInterfaceHandle, Dest, (short)Wert, AdrMode); |
||
656 | } |
||
657 | break; |
||
658 | case 'B': { |
||
659 | Wert = ReadByte(nInterfaceHandle, Idx, AdrMode); |
||
660 | WriteByte(nInterfaceHandle, Dest, (char)Wert, AdrMode); |
||
661 | } |
||
662 | break; |
||
663 | } /* switch */ |
||
664 | |||
665 | if (GetError(nInterfaceHandle)) |
||
666 | { |
||
667 | ClearError(nInterfaceHandle); /* Fehler abfangen */ |
||
668 | Merk_error = 1; |
||
669 | } |
||
670 | |||
671 | if ((Idx & 0xffl)==0) |
||
672 | { /* Ermoegliche Ctrl-C */ |
||
673 | printf("\r"); |
||
674 | } |
||
675 | |||
676 | Idx+=Len; |
||
677 | Dest+=Len; |
||
678 | } /* while */ |
||
679 | if (Merk_error) printf("--> Memory move failed\a\n"); |
||
680 | } |
||
681 | else printf("\a"); |
||
682 | } |
||
683 | |||
684 | //----------------------------------------------------------------------------- |
||
685 | // print out help to user |
||
686 | static void Hilfe(void) |
||
687 | { |
||
688 | printf("a[h] [adrmode]\t\t: Change address modifiers, h=help\n"); |
||
689 | printf("c\t\t\t: Configure interface\n"); |
||
690 | printf("d[m] [start] [end]\t: Dump memory area\n"); |
||
691 | printf("e[m] <start> [value]\t: Examine or change memory area\n"); |
||
692 | printf("f<m> <start> <end> <x>\t: Fill memory from <start> til <end> with <x>\n"); |
||
693 | printf("g<m> <st> <en> [l] [x]\t: Generate random memory test. (loop l, seed x)\n"); |
||
694 | printf("h\t\t\t: This help\n"); |
||
695 | printf("i\t\t\t: Interface init\n"); |
||
696 | printf("l[m]\t\t\t: Get VME interrupt status/ID\n"); |
||
697 | printf("m<m> <src> <end> <dest>\t: Move memory area\n"); |
||
698 | printf("o\t\t\t: Jump to OS\n"); |
||
699 | printf("p[adrmode]\t\t: Port search\n"); |
||
700 | printf("q\t\t\t: Quit program\n"); |
||
701 | printf("r[x] <f> <start> [end]\t: Read file <f> to VME, x= x or s (HEX)\n"); |
||
702 | printf("s[m] <start> <end> <p>\t: Search pattern <p>=different Items\n"); |
||
703 | printf("t <start>\t\t: TAS emulation, 'Test and Set' bit 7\n"); |
||
704 | printf("v\t\t\t: Generate VME SYSRESET\n"); |
||
705 | printf("w[x] <f> <start> <end>\t: Write VME into file <f>, h=Intel Hex\n"); |
||
706 | printf("x <start> [val]\t\t: Read/Write to interface register @ start\n"); |
||
707 | printf("y[1/0]\t\t\t: Read/set/clear SYSFAIL\n"); |
||
708 | printf("z[0..2]\t\t\t: Show interface internals\n"); |
||
709 | printf("\n"); |
||
710 | printf("m = mode, e.g. b=byte, w=word, l=long (double) word; h = help, x= hex\n"); |
||
711 | printf("start(address), end(address), src=source, dest=destination, []=option\n"); |
||
712 | } |
||
713 | |||
714 | //----------------------------------------------------------------------------- |
||
715 | // initialize the interface to VME |
||
716 | static int InitAt(char *szDevicePath, int *nIfcNum) /* Gibt bei Fehler False aus */ |
||
717 | { |
||
718 | int result; |
||
719 | |||
720 | if (result = Init_Interface(szDevicePath, AdrMode, nIfcNum)) /* Pruefung des Interfaces */ |
||
721 | { |
||
722 | printf("\n"); |
||
723 | switch (result) |
||
724 | { |
||
725 | case ENXIO: |
||
726 | printf("Can't find interface driver path!\n"); |
||
727 | printf("Please <q>uit or <c>onfigure interface!\n"); |
||
728 | return FALSE; |
||
729 | case ENOENT: |
||
730 | printf("Can't find interface driver!\n"); |
||
731 | printf("Please <q>uit or <c>onfigure interface!\n"); |
||
732 | return FALSE; |
||
733 | case ENODEV: |
||
734 | printf("VMEMM #%d not connected or VME crate switched off!\n", nInterfaceHandle); |
||
735 | printf("Please check connection or switch VME crate on or <c>onfigure.\n"); |
||
736 | printf("Then <q>uit and restart again.\n"); |
||
737 | return FALSE; |
||
738 | |||
739 | default: |
||
740 | printf("Unknown error '%d' occured!\n", result); |
||
741 | printf("Please check the hardware and software setup and restart again.\n"); |
||
742 | return FALSE; |
||
743 | |||
744 | } |
||
745 | } |
||
746 | |||
747 | return(True); /* Kein Fehler */ |
||
748 | } |
||
749 | |||
750 | //----------------------------------------------------------------------------- |
||
751 | // get the name of the configuration file |
||
752 | static void CfgName(STRG Stg) /* Ermittelt Namen Config-File */ |
||
753 | { |
||
754 | Stg[0]='\0'; |
||
755 | if (ArgV[0] != NULL) |
||
756 | { |
||
757 | strcpy(Stg,ArgV[0]); |
||
758 | if (strrchr(Stg,'/')!=NULL) /* Versuche Dateinamen abzutrennen */ |
||
759 | *(strrchr(Stg,'/')+1)='\0'; /* So daß nur Pfad uebrigbleibt */ |
||
760 | else Stg[0]='\0'; /* Kein Pfad: String ist leer */ |
||
761 | } |
||
762 | strcat(Stg,"pvmon.cfg"); /* Mache einen Dateinamen */ |
||
763 | } |
||
764 | |||
765 | //----------------------------------------------------------------------------- |
||
766 | // read in contents of configuration file |
||
767 | static void LoadKonfig(void) /* Wenn Config-Datei da, lese ein */ |
||
768 | { |
||
769 | STRG Stg; |
||
770 | FILE *InF; |
||
771 | char c; |
||
772 | __u32 dwLocalAdrMode; |
||
773 | |||
774 | CfgName(Stg); /* Hole Dateinamen nach InS */ |
||
775 | if ((InF=fopen(Stg,"rt"))!=NULL) |
||
776 | { /* Wenn das oeffnen geklappt hat */ |
||
777 | fscanf(InF,"%*[^=]%*1s%s",Stg); |
||
778 | fscanf(InF,"%*[^=]%*1s%s",cszDevicePath); |
||
779 | fscanf(InF,"%*[^=]%*1s%x",&dwLocalAdrMode); |
||
780 | AdrMode = (__u8)dwLocalAdrMode; |
||
781 | fscanf(InF,"%*[^=]%*1s%c",&c); |
||
782 | fclose(InF); /* Datei wieder schließen */ |
||
783 | |||
784 | c = tolower(c); |
||
785 | if (c == 'y') |
||
786 | WordMode = setWordMode(1); |
||
787 | else |
||
788 | WordMode = setWordMode(0); |
||
789 | |||
790 | } /* if */ |
||
791 | } |
||
792 | |||
793 | //----------------------------------------------------------------------------- |
||
794 | // provides configuration functionality to user |
||
795 | static void Konfig(void) /* Konfiguration einstellen */ |
||
796 | { |
||
797 | STRG InS; /* Eingabestring */ |
||
798 | FILE *OuF; /* Ausgabedatei */ |
||
799 | short change = 0; |
||
800 | char c; |
||
801 | |||
802 | InS[0] = 0; |
||
803 | printf("Pathname of device (%s):",cszDevicePath); /* erfrage den Pfad zum Treiber */ |
||
804 | _gets(InS); |
||
805 | if ((InS[0] != '\n') && (InS[0])) |
||
806 | { |
||
807 | strcpy(cszDevicePath, InS); |
||
808 | change |= 1; |
||
809 | } |
||
810 | |||
811 | InS[0] = 0; |
||
812 | printf("Default address modifier (%02x):",AdrMode); /* und den default Modifier */ |
||
813 | _gets(InS); |
||
814 | if ((InS[0] != '\n') && (InS[0])) |
||
815 | { |
||
816 | sscanf(InS,"%x",&AdrMode); |
||
817 | change |= 4; |
||
818 | } |
||
819 | |||
820 | if (WordMode) |
||
821 | c = 'y'; |
||
822 | else |
||
823 | c = 'n'; |
||
824 | InS[0] = 0; |
||
825 | printf("16 bit VME BUS data path (%c) :", c); |
||
826 | _gets(InS); |
||
827 | if ((InS[0] != '\n') && (InS[0])) |
||
828 | { |
||
829 | sscanf(InS,"%c",&c); |
||
830 | change |= 8; |
||
831 | } |
||
832 | c = tolower(c); |
||
833 | if (c == 'y') |
||
834 | WordMode = setWordMode(1); |
||
835 | else |
||
836 | WordMode = setWordMode(0); |
||
837 | |||
838 | if (change) |
||
839 | { |
||
840 | do |
||
841 | { |
||
842 | printf("Save (y/n):"); /* Wiederhole diese Frage bis */ |
||
843 | _gets(InS); /* sie ordentlich beantwortet wurde */ |
||
844 | strlwr(InS); /* DownCase String */ |
||
845 | } while (InS[0]!='y' && InS[0]!='n'); |
||
846 | |||
847 | if (InS[0]=='y') |
||
848 | { |
||
849 | CfgName(InS); /* Hole Dateinamen nach InS */ |
||
850 | if ((OuF=fopen(InS,"wt"))!=NULL) |
||
851 | { |
||
852 | if (WordMode) |
||
853 | c = 'y'; |
||
854 | else |
||
855 | c = 'n'; |
||
856 | |||
857 | fprintf(OuF,"Configuration=%s\n",__DATE__); |
||
858 | fprintf(OuF,"DevicePath=%s\n",cszDevicePath); /* Wenn das oeffnen geklappt hat */ |
||
859 | fprintf(OuF,"AddressModifier=%x\n",AdrMode); |
||
860 | fprintf(OuF,"WordMode=%c\n", c); |
||
861 | fclose(OuF); /* Datei schliessen */ |
||
862 | |||
863 | if (change & 1) |
||
864 | printf("Please restart to put the new driver to work!\n"); |
||
865 | } |
||
866 | else printf("Can't open %s. ",InS); |
||
867 | } |
||
868 | } |
||
869 | } |
||
870 | |||
871 | //----------------------------------------------------------------------------- |
||
872 | // read user initiated interrupt vector from VME BUS |
||
873 | static void ReadIrqVect(void) /* Interrupt-Vektoren lesen */ |
||
874 | { |
||
875 | STRG OSt; /* Ausgabestring */ |
||
876 | short Level = 0; |
||
877 | |||
878 | switch (GetZug(&DefVec)) |
||
879 | { /* Zugriffsmodus festlegen */ |
||
880 | case 'L':sprintf(OSt, "%08hx", ReadVectorLong(nInterfaceHandle)); break; |
||
881 | case 'W':sprintf(OSt, "%04hx", ReadVectorWord(nInterfaceHandle)); break; |
||
882 | case 'B':sprintf(OSt, "%02hx", ReadVectorByte(nInterfaceHandle)); break; |
||
883 | }; |
||
884 | |||
885 | if (GetError(nInterfaceHandle)) |
||
886 | { /* Im Fehlerfalle 'Error' ausgeben */ |
||
887 | ClearError(nInterfaceHandle); /* Fehlerflags zuruecksetzen */ |
||
888 | strcpy(OSt, "Error"); |
||
889 | } |
||
890 | printf("VME status/ID = %s\n", OSt); |
||
891 | } |
||
892 | |||
893 | |||
894 | //----------------------------------------------------------------------------- |
||
895 | // temporary jump to (D)OS |
||
896 | static void JumpToDos() /* (D)OS-Shell aufrufen */ |
||
897 | { |
||
898 | { |
||
899 | if (system("/bin/sh -c $SHELL") != 0) |
||
900 | printf("Fail to launch a new shell.\n"); |
||
901 | } |
||
902 | } |
||
903 | |||
904 | //----------------------------------------------------------------------------- |
||
905 | // search responding ports in VME address range |
||
906 | static void SearchPort(char *Art, int Anz, unsigned short modf, |
||
907 | void (*SFunc)(int, unsigned long, unsigned short)) /* Durchsucht Adressraum */ |
||
908 | { |
||
909 | unsigned long Idx; |
||
910 | unsigned long Fst; /* Erster gefundener Port */ |
||
911 | unsigned long Lst; /* Letzer gefundener Port */ |
||
912 | unsigned long Ende; /* Durchsuch Ende */ |
||
913 | char Found; /* Schon was gefunden? */ |
||
914 | char Sequ; /* Schon eine Portsequenz */ |
||
915 | int Err; /* Fehler dagewesen? */ |
||
916 | int Tab; /* Tabulator-Zaehler */ |
||
917 | unsigned long Step; |
||
918 | |||
919 | printf("%s-accesses valid with address modifier %02x to address: ", Art,modf); |
||
920 | |||
921 | if (modf > 0x2F) |
||
922 | { |
||
923 | Ende = 0x01000000L; /* alle Standards */ |
||
924 | Step = 0x100; /* Stepweite */ |
||
925 | } |
||
926 | |||
927 | if ((modf < 0x30) && (modf > 0x1f)) |
||
928 | { |
||
929 | Ende = 0x00010000L; /* Shorts */ |
||
930 | Step = Anz; |
||
931 | } |
||
932 | |||
933 | if (modf < 0x20) |
||
934 | { |
||
935 | Ende = 0xFFFF0000L; /* alle Extendets, gemogelt */ |
||
936 | Step = 0x10000; /* Step */ |
||
937 | } |
||
938 | |||
939 | Sequ=False; /* Noch keine Sequenz da */ |
||
940 | Found=False; |
||
941 | Tab=0; |
||
942 | Idx=0; |
||
943 | |||
944 | do |
||
945 | { /* do while */ |
||
946 | SFunc(nInterfaceHandle, Idx, modf); /* Lese versuchsweise Port */ |
||
947 | Err=GetError(nInterfaceHandle); /* Fehlerzustand abfragen */ |
||
948 | if (Err) ClearError(nInterfaceHandle); /* Fehler bestaetigen */ |
||
949 | else |
||
950 | { |
||
951 | Lst=Idx; /* Merke Port als gueltig */ |
||
952 | if (!Sequ) |
||
953 | { /* Diese Seqenz faengt an? */ |
||
954 | Fst=Idx; /* Ja, neue Sequenz, merke */ |
||
955 | Sequ=True; /* auch ersten Port */ |
||
956 | } |
||
957 | } |
||
958 | |||
959 | Idx+= Step; /* Erhoehe Adresse */ |
||
960 | |||
961 | if ((Err || !(Idx < Ende)) && Sequ) |
||
962 | { /* Ausgeben bei Sequenzende */ |
||
963 | if (!Found) |
||
964 | { /* oder bei Schleifenende */ |
||
965 | if (Idx < Ende) printf("\n"); /* Kein <CRLF> bei Schleifenende */ |
||
966 | Found=True; |
||
967 | }; |
||
968 | /* Weitere Sequenz: Tab ausgeben */ |
||
969 | if (Fst==Lst) |
||
970 | { /* Sequenz mit nur 1 Element */ |
||
971 | printf("%08lx,\t", Fst); |
||
972 | Tab++; /* Merke Tab-Status */ |
||
973 | } |
||
974 | else |
||
975 | { |
||
976 | Tab=0; /* Tab-Status wieder zuruecksetzen */ |
||
977 | printf("%08lx-%08lx\n", Fst, Lst); /* Sequenz ausgeben */ |
||
978 | } |
||
979 | Sequ=False; /* Sequenz gilt als abgeschlossen */ |
||
980 | } /* if */ |
||
981 | } while ((Idx < Ende) && (!Abbruch)); /* Bis Idx einmal 'rum ist */ |
||
982 | |||
983 | if (!Found) |
||
984 | printf("\nnothing found"); /* Wenn keinen Zugriff gefunden */ |
||
985 | printf("\n"); /* Immer mit <CRLF> abschließen */ |
||
986 | } |
||
987 | |||
988 | //----------------------------------------------------------------------------- |
||
989 | // search responding ports |
||
990 | static void SearchPorts(void) /* Durchsucht Short-Adressraum */ |
||
991 | { /* nach Wort- und Bytes Zugriffen */ |
||
992 | unsigned short modf = AdrMode; |
||
993 | |||
994 | if (ParaStr(2)!=NULL) |
||
995 | modf = (unsigned short)ParaNum(2); /* Anderer Adressmodifier */ |
||
996 | |||
997 | ShowModifier(modf); printf("\n"); |
||
998 | SearchPort("Byte", 1, modf, (void(*)(int, unsigned long, unsigned short))ReadByte); |
||
999 | SearchPort("Word", 2, modf, (void(*)(int, unsigned long, unsigned short))ReadWord); |
||
1000 | SearchPort("Long", 4, modf, (void(*)(int, unsigned long, unsigned short))ReadLong); |
||
1001 | printf("\n"); |
||
1002 | } |
||
1003 | |||
1004 | //----------------------------------------------------------------------------- |
||
1005 | // converts parts of a string to a number |
||
1006 | static unsigned int GibNum(char **PSt, char Anz) |
||
1007 | { |
||
1008 | unsigned int Val; /* Ermittelter Wert */ |
||
1009 | unsigned int Num; /* Wieviel Zeichen genommen */ |
||
1010 | char Frm[6]; /* Formatstring */ |
||
1011 | |||
1012 | Val=0; /* Default setzen */ |
||
1013 | strcpy(Frm,"%nx%n"); /* Default Format setzen */ |
||
1014 | if (*PSt!=NULL) |
||
1015 | { /* Nur wenn String gueltig */ |
||
1016 | Frm[1]=Anz; /* Uebertrage Anzahl-Zeichen */ |
||
1017 | *PSt=(sscanf(*PSt,Frm,&Val, /* Hole Nummer aus String */ |
||
1018 | &Num)!=1) ? NULL : (*PSt)+Num; /* Fehler oder weitersetzen */ |
||
1019 | } /* if */ |
||
1020 | return(Val); |
||
1021 | } |
||
1022 | |||
1023 | //----------------------------------------------------------------------------- |
||
1024 | // read in a file and put the contents to VME |
||
1025 | static int _ReadFile(void) /* Lese eine Datei in VME-Mem ein */ |
||
1026 | { |
||
1027 | unsigned long End; /* Endadresse */ |
||
1028 | unsigned long Idx; /* Laufadresse */ |
||
1029 | unsigned long Cnt; /* Bytezaehler */ |
||
1030 | unsigned Adr; /* Adresse Record ab Start */ |
||
1031 | int Len; /* Recordlaenge */ |
||
1032 | int Ret; /* Returncode */ |
||
1033 | int Hex; /* Intel Hex File? */ |
||
1034 | int Typ; /* Typ des Records */ |
||
1035 | STRG Nam; /* Dateiname */ |
||
1036 | STRG Stg; /* Einlese-String */ |
||
1037 | char *PSt; /* Scanzeiger */ |
||
1038 | FILE *InF; /* Lesedatei */ |
||
1039 | |||
1040 | Ret=1; /* Vorgabe ist Fehler */ |
||
1041 | if (ParaStr(3)!=NULL) |
||
1042 | { /* Startadr ist obligat */ |
||
1043 | Hex=(ParaStr(1)[1]=='X'); /* Intel-Hex gewuenscht? */ |
||
1044 | strcpy(Nam,ParaStr(2)); /* Dateinamen kopieren */ |
||
1045 | *strchr(Nam,' ')='\0'; /* Restparameter abschneiden */ |
||
1046 | Cnt=0; /* Noch nichts gelesen */ |
||
1047 | Idx=ParaNum(3); /* Lege Startadresse fest */ |
||
1048 | End=(ParaStr(4)==NULL) /* Endadr ist optional */ |
||
1049 | ? 0xffffffffl : ParaNum(4); |
||
1050 | |||
1051 | if (Idx<=End) |
||
1052 | { /* Falsche Werte abweisen */ |
||
1053 | if ((InF=fopen(Nam,(Hex) ? "rt":"rb"))!=NULL) |
||
1054 | { |
||
1055 | if (Hex) |
||
1056 | { /* Intel-Hex gewuenscht? */ |
||
1057 | fscanf(InF,"%x",Idx); |
||
1058 | while (!feof(InF)) |
||
1059 | { /* Bis zum Ende lesen */ |
||
1060 | fgets(Stg,sizeof(Stg),InF); |
||
1061 | if (strlen(Stg)>1) |
||
1062 | { /* Ignoriere leere Zeilen */ |
||
1063 | PSt=strchr(Stg,':'); /* Doppelpunkt ist obligat */ |
||
1064 | if (PSt!=NULL) PSt++; /* Hinter ':' stellen */ |
||
1065 | Len=GibNum(&PSt,'2'); /* Hole Recordlaenge */ |
||
1066 | Adr=GibNum(&PSt,'4'); /* Hole Adresse */ |
||
1067 | Typ=GibNum(&PSt,'2'); |
||
1068 | if (!Typ) |
||
1069 | { /* Datencode erkannt? */ |
||
1070 | while (PSt!=NULL && Len) |
||
1071 | { |
||
1072 | WriteByte(nInterfaceHandle, Idx+Adr++,(char)GibNum(&PSt,'2'),AdrMode); |
||
1073 | Cnt++; /* 1 Byte mehr gelesen */ |
||
1074 | Len--; /* Laenge aufaddieren */ |
||
1075 | } /* while */ |
||
1076 | |||
1077 | if (GetError(nInterfaceHandle)) |
||
1078 | { /* Fehlerpruefung: VME-Transfer ok? */ |
||
1079 | ClearError(nInterfaceHandle); /* Fehlerflag zuruecksetzen */ |
||
1080 | printf("--> Bus error: Adr=%08lx. ",Idx+Adr); |
||
1081 | break; /* Abbruch mit Fehler */ |
||
1082 | } /* if */ |
||
1083 | } |
||
1084 | else |
||
1085 | { |
||
1086 | if (Typ==1) |
||
1087 | { /* Endcode erkannt? */ |
||
1088 | Ret=0; /* Fehlerfrei gelesen */ |
||
1089 | break; /* Ende while */ |
||
1090 | } /* Ignoriere andere Typen */ |
||
1091 | } /* else */ |
||
1092 | if (PSt==NULL) |
||
1093 | { |
||
1094 | printf("Format error\n"); |
||
1095 | break; |
||
1096 | } /* if */ |
||
1097 | } /* if len */ |
||
1098 | } /* while */ |
||
1099 | } |
||
1100 | else |
||
1101 | { /* Kein Intel-Hex-Format */ |
||
1102 | do |
||
1103 | { |
||
1104 | if (feof(InF)) Idx=End; /* Ende der Datei erreicht */ |
||
1105 | else |
||
1106 | { |
||
1107 | WriteByte(nInterfaceHandle, Idx,(char)fgetc(InF),AdrMode); |
||
1108 | if (GetError(nInterfaceHandle)) |
||
1109 | { /* Fehlerpruefung: VME-Transfer ok? */ |
||
1110 | ClearError(nInterfaceHandle); /* Fehlerflag zuruecksetzen */ |
||
1111 | printf("--> Bus error: Adr=%08lx. ",Idx); |
||
1112 | break; /* Abbruch mit Fehler */ |
||
1113 | } /* if GetError */ |
||
1114 | |||
1115 | Cnt++; /* Ein Byte mehr gelesen */ |
||
1116 | } /* else */ |
||
1117 | } while (Idx++<End); /* Bis einschliesslich End lesen */ |
||
1118 | fclose(InF); |
||
1119 | if (Idx==End+1) Ret=0; /* Genug Byte geschafft? */ |
||
1120 | } /* else Hex */ |
||
1121 | } /* if fopen */ |
||
1122 | else printf("Can't read file %s. ",Nam); |
||
1123 | } /* if */ |
||
1124 | printf("%lx Byte(s) read\n",Cnt); |
||
1125 | } /* if */ |
||
1126 | else printf("\a"); |
||
1127 | return(Ret); |
||
1128 | } |
||
1129 | |||
1130 | //----------------------------------------------------------------------------- |
||
1131 | // seek for a pattern in VME BUS |
||
1132 | static void SeekPatt(void) /* Suche nach Datenmustern */ |
||
1133 | { |
||
1134 | #define Max 32 /* Wieviele Suchbytes max. */ |
||
1135 | unsigned long DefVon; /* Startadresse */ |
||
1136 | unsigned long End; /* Endadresse */ |
||
1137 | int Idx; /* Index */ |
||
1138 | int Idy; /* Auch Index */ |
||
1139 | int Len; /* Item Laenge */ |
||
1140 | int Ok; /* Flag: gefunden oder nicht? */ |
||
1141 | int Merk_error = 0; /* Fehler Flip-Flop */ |
||
1142 | |||
1143 | union |
||
1144 | { /* Suchmuster */ |
||
1145 | unsigned char xs[Max]; |
||
1146 | unsigned int xw[Max/2]; |
||
1147 | unsigned long xl[Max/4]; |
||
1148 | } Patt; |
||
1149 | |||
1150 | if (ParaStr(4) != NULL) |
||
1151 | { /* Von, Bis und 1 Item obligat */ |
||
1152 | DefVon=ParaNum(2); /* Startadresse festlegen */ |
||
1153 | End=ParaNum(3); /* Endadresse festlegen */ |
||
1154 | Len=1; |
||
1155 | switch (GetZug(&DefZug)) |
||
1156 | { /* Zugriffsmodus festlegen */ |
||
1157 | case 'L':Len+=2; /* Auf Long-Adresse biegen */ |
||
1158 | case 'W':Len++; /* Auf Wort-Adresse biegen */ |
||
1159 | } |
||
1160 | |||
1161 | DefVon&=-(long)Len; /* Adressen geradebiegen */ |
||
1162 | Idx=0; /* Suchmuster sammeln */ |
||
1163 | while (Idx<Max/Len && ParaStr(Idx+4)!=NULL) |
||
1164 | { |
||
1165 | switch (DefZug) |
||
1166 | { |
||
1167 | case 'L':Patt.xl[Idx]=ParaNum(Idx+4); break; |
||
1168 | case 'W':Patt.xw[Idx]=(unsigned)ParaNum(Idx+4); break; |
||
1169 | case 'B':Patt.xs[Idx]=(unsigned char)ParaNum(Idx+4); break; |
||
1170 | } /* switch */ |
||
1171 | Idx++; /* Ein Item mehr da */ |
||
1172 | } /* while */ |
||
1173 | |||
1174 | while ((DefVon<=End) && (!Abbruch)) |
||
1175 | { /* Suche nun den Bereich ab */ |
||
1176 | Ok=True; /* Pattern an dieser Adresse? */ |
||
1177 | for (Idy=0; Idy<Idx && Ok; Idy++) |
||
1178 | { |
||
1179 | switch (DefZug) |
||
1180 | { |
||
1181 | case 'L':if (Patt.xl[Idy] != (unsigned long)ReadLong(nInterfaceHandle, DefVon+(Idy<<2),AdrMode)) |
||
1182 | Ok=False; |
||
1183 | break; |
||
1184 | case 'W':if (Patt.xw[Idy] != (unsigned short)ReadWord(nInterfaceHandle, DefVon+(Idy<<1),AdrMode)) |
||
1185 | Ok=False; |
||
1186 | break; |
||
1187 | case 'B':if (Patt.xs[Idy] != (unsigned char)ReadByte(nInterfaceHandle, DefVon+Idy,AdrMode)) |
||
1188 | Ok=False; |
||
1189 | break; |
||
1190 | } /* switch */ |
||
1191 | |||
1192 | if (GetError(nInterfaceHandle)) |
||
1193 | { /* Busfehler aufgetreten? */ |
||
1194 | ClearError(nInterfaceHandle); /* Fehlerflags zuruecksetzen */ |
||
1195 | Ok=False; /* Gefunden wurde auch nichts */ |
||
1196 | Merk_error = 1; /* Setze Flip-Flop */ |
||
1197 | } |
||
1198 | } /* for */ |
||
1199 | if (Ok) printf("%08lx\n",DefVon);/* Was gefunden: Adresse ausgeben */ |
||
1200 | DefVon+=Len; |
||
1201 | |||
1202 | if ((DefVon & 0xffl)==0) |
||
1203 | { /* Ermoegliche Abbruch mit Ctrl-C */ |
||
1204 | printf("\r"); |
||
1205 | } |
||
1206 | } /* while */ |
||
1207 | if (Merk_error) printf("--> Failed to search\n"); |
||
1208 | } |
||
1209 | else printf("\a"); |
||
1210 | } |
||
1211 | |||
1212 | //----------------------------------------------------------------------------- |
||
1213 | // emulate a 68K test and set instruction |
||
1214 | static void TestSet() /* Fuehre ein Test and Set auf */ |
||
1215 | { /* Bit #7 eines Byte-Ports aus. */ |
||
1216 | char Erg; |
||
1217 | |||
1218 | if (ParaStr(2)!=NULL) |
||
1219 | { /* Adresse ist obligat */ |
||
1220 | Erg=TAS(nInterfaceHandle, ParaNum(2),AdrMode); /* Ergebnis merken, damit ein */ |
||
1221 | if (GetError(nInterfaceHandle)) |
||
1222 | { /* Fehler ausgegeben werden kann */ |
||
1223 | ClearError(nInterfaceHandle); |
||
1224 | printf("--> Failed to 'Test and Set'\n"); /* Zugriff gescheitert */ |
||
1225 | } |
||
1226 | else printf("Semafore @ 0x%08lx was%s set before.\n", |
||
1227 | ParaNum(2),(Erg) ? "" : " not"); |
||
1228 | } |
||
1229 | else printf("\a"); |
||
1230 | } |
||
1231 | |||
1232 | //----------------------------------------------------------------------------- |
||
1233 | // raise a VME SYSRESET |
||
1234 | static void ResetVme(void) /* Generiere SysReset auf VME-Bus */ |
||
1235 | { /* Interrupt bei MailBox beachten */ |
||
1236 | printf("Reset to VME raised.\n"); |
||
1237 | Reset_VME(nInterfaceHandle); |
||
1238 | } |
||
1239 | |||
1240 | //----------------------------------------------------------------------------- |
||
1241 | // print out a line in HEX format |
||
1242 | static int OutHex(FILE *OuF, int Siz, unsigned long Adr,int Typ, char Buf[]) |
||
1243 | { |
||
1244 | int Chk; /* Pruefsumme */ |
||
1245 | int Idx; /* Laufindex */ |
||
1246 | |||
1247 | fprintf(OuF,":%02X%04X%02X",Siz,Adr,Typ); |
||
1248 | Chk=Siz+(Adr & 0xff)+(Adr>>8)+Typ; |
||
1249 | for (Idx=0; Idx<Siz; Idx++) |
||
1250 | { /* Pufferinhalt ausgeben */ |
||
1251 | fprintf(OuF,"%02X",(unsigned char)Buf[Idx]); |
||
1252 | Chk+=Buf[Idx]; /* Pruefsumme mitrechnen */ |
||
1253 | } |
||
1254 | fprintf(OuF,"%02X\n",(unsigned char)-Chk); /* Pruefsumme ausgeben */ |
||
1255 | if (ferror(OuF)) |
||
1256 | { /* Irgend ein Schreibfehler? */ |
||
1257 | printf("Failed to write. "); |
||
1258 | return(False); |
||
1259 | } |
||
1260 | else return(True); /* Fehlerfrei ausgefuehrt */ |
||
1261 | } |
||
1262 | |||
1263 | //----------------------------------------------------------------------------- |
||
1264 | // write a file in HEX and get the data from VME |
||
1265 | static int _WriteFile() /* Schreibt eine Datei aus VME */ |
||
1266 | { |
||
1267 | unsigned long End; /* Endadresse */ |
||
1268 | unsigned long Idx; /* Laufadresse */ |
||
1269 | unsigned long Cnt; /* Bytezaehler */ |
||
1270 | int Ret; /* Returncode */ |
||
1271 | int Adr; /* Adresse Record ab Start */ |
||
1272 | int Hex; /* Intel Hex File? */ |
||
1273 | char Buf[16]; /* Output-Puffer */ |
||
1274 | STRG Nam; /* Dateiname */ |
||
1275 | FILE *OuF; /* Lesedatei */ |
||
1276 | |||
1277 | Ret=1; /* Vorgabe ist Fehler */ |
||
1278 | if (ParaStr(4)!=NULL) |
||
1279 | { /* Start & Endadr sind obligat */ |
||
1280 | Hex=(ParaStr(1)[1]=='X'); /* Intel-Hex gewuenscht? */ |
||
1281 | strcpy(Nam,ParaStr(2)); /* Dateinamen kopieren */ |
||
1282 | *strchr(Nam,' ')='\0'; /* Restparameter abschneiden */ |
||
1283 | Cnt=0; /* Noch nichts gelesen */ |
||
1284 | Idx=ParaNum(3); /* Lege Startadresse fest */ |
||
1285 | End=ParaNum(4); /* Lege Endadresse fest */ |
||
1286 | if (Idx<=End) |
||
1287 | { /* Falsche Werte abweisen */ |
||
1288 | if ((OuF=fopen(Nam,(Hex) ? "wt":"wb"))!=NULL) |
||
1289 | { |
||
1290 | if (Hex) |
||
1291 | { /* Intel-Hex gewuenscht? */ |
||
1292 | Buf[0]=0 >> 0x8; /* HighByte Segmentadresse */ |
||
1293 | Buf[1]=0 & 0xff; /* LowByte Segmentadresse */ |
||
1294 | Adr=0; /* Offset grundsaetzlich bei 0 */ |
||
1295 | if (OutHex(OuF,2,Adr,2,Buf)) |
||
1296 | { |
||
1297 | do |
||
1298 | { |
||
1299 | Buf[(int)Cnt & 0xf]=ReadByte(nInterfaceHandle, Idx,AdrMode); |
||
1300 | if (GetError(nInterfaceHandle)) |
||
1301 | { /* Fehlerpruefung: VME-Transfer ok? */ |
||
1302 | ClearError(nInterfaceHandle); /* Fehlerflag zuruecksetzen */ |
||
1303 | printf("--> Bus error: Adr=%08lx. ",Idx); |
||
1304 | break; /* Abbruch */ |
||
1305 | } /* if GetError */ |
||
1306 | if (!((int)++Cnt & 0xf)) |
||
1307 | { |
||
1308 | if (OutHex(OuF,16,Adr,0,Buf)) Adr+=16; |
||
1309 | else break; /* Zwischendurch Puffer schreiben */ |
||
1310 | } |
||
1311 | } while (Idx++<End); /* Bis einschließlich End schreiben */ |
||
1312 | |||
1313 | if ((Idx==End+1) && /* Noch Rest im Puffer? */ |
||
1314 | (!((int)Cnt & 0xf) || |
||
1315 | OutHex(OuF,(int)Cnt & 0xf,Adr,0,Buf)) |
||
1316 | && OutHex(OuF,0,0,1,NULL)) Ret=0; |
||
1317 | } /* if */ /* Wenn Eof ausgegeben, Returns ok */ |
||
1318 | } /* if Hex */ |
||
1319 | else |
||
1320 | do |
||
1321 | { /* Nicht Intel-Hex */ |
||
1322 | fputc(ReadByte(nInterfaceHandle, Idx,AdrMode),OuF); |
||
1323 | if (GetError(nInterfaceHandle)) |
||
1324 | { /* Fehlerpruefung: VME-Transfer ok? */ |
||
1325 | ClearError(nInterfaceHandle); /* Fehlerflag zuruecksetzen */ |
||
1326 | printf("--> Bus error: Adr=%08lx. ",Idx); |
||
1327 | break; /* Abbruch */ |
||
1328 | } /* if GetError */ |
||
1329 | if (ferror(OuF)) |
||
1330 | { |
||
1331 | printf("Failed to write. "); |
||
1332 | break; /* Abbruch */ |
||
1333 | } /* if ferror */ |
||
1334 | Cnt++; /* Ein Byte mehr geschrieben */ |
||
1335 | } while (Idx++<End); /* Bis einschließlich End schreiben */ |
||
1336 | |||
1337 | if (Idx==End+1) Ret=0; /* Genug Byte geschafft? */ |
||
1338 | fclose(OuF); |
||
1339 | } /* if fopen */ |
||
1340 | else |
||
1341 | printf("Can' open file %s. ",Nam); |
||
1342 | } /* if */ |
||
1343 | printf("%lx Byte(s) written.\n",Cnt); |
||
1344 | } /* if */ |
||
1345 | else |
||
1346 | printf("\a"); |
||
1347 | return(Ret); |
||
1348 | } |
||
1349 | |||
1350 | |||
1351 | //----------------------------------------------------------------------------- |
||
1352 | // show and provide help about the VME address modifiers |
||
1353 | static void ShowModifier(int Mode) /* Klartext fuer Adressmodifier */ |
||
1354 | { |
||
1355 | printf("Address modifier:\t%02x [", Mode); |
||
1356 | if ((Mode & 0x3b) > 0x38) printf("standard"); |
||
1357 | else if ((Mode & 0x3b)==0x29) printf("short"); |
||
1358 | else if ((Mode & 0x3b)>=0x09 && (Mode & 0x3b)<=0x0b) printf("extendet"); |
||
1359 | else if (Mode>=0x20 || Mode<=0x0f) |
||
1360 | { |
||
1361 | printf("reserved]\n"); return; |
||
1362 | } |
||
1363 | else |
||
1364 | { |
||
1365 | printf("user defined]\n"); return; |
||
1366 | } |
||
1367 | printf(((Mode & 0x0f)>=0x0c) ? " supervisory":" non-privileged"); |
||
1368 | switch (Mode & 0x03) |
||
1369 | { |
||
1370 | case 1:printf(" data access"); break; |
||
1371 | case 2:printf(" code access"); break; |
||
1372 | case 3:printf(" block transfer"); break; |
||
1373 | } |
||
1374 | printf("]\n"); |
||
1375 | } |
||
1376 | |||
1377 | //----------------------------------------------------------------------------- |
||
1378 | // provides some diagnostic information abot interface registers |
||
1379 | static void ShowRegister(void) /* Zeige Inhalt von ? */ |
||
1380 | { |
||
1381 | char *szInstg; |
||
1382 | char type; |
||
1383 | |||
1384 | if ((szInstg = ParaStr(1)) == NULL) |
||
1385 | type = '0'; |
||
1386 | else |
||
1387 | type = szInstg[1]; |
||
1388 | |||
1389 | if (type == 0) |
||
1390 | type = '0'; |
||
1391 | |||
1392 | GetInterfaceInfo(nInterfaceHandle, type); |
||
1393 | } |
||
1394 | |||
1395 | //----------------------------------------------------------------------------- |
||
1396 | // make a random memory test to VME |
||
1397 | static void RandomTest(void) |
||
1398 | { |
||
1399 | char DefZug = ' '; /* Zugriffsart */ |
||
1400 | int Len; /* Item Laenge */ |
||
1401 | unsigned long Idx; /* Index */ |
||
1402 | unsigned long End; /* Endadresse */ |
||
1403 | unsigned long Seed; /* initial seed */ |
||
1404 | unsigned char Merk_error = 0; /* Haelt error flag */ |
||
1405 | int Patt; |
||
1406 | unsigned long i; |
||
1407 | |||
1408 | unsigned long lResult; |
||
1409 | unsigned short wResult; |
||
1410 | unsigned char bResult; |
||
1411 | int repeats = 0; |
||
1412 | int Loop = 0; |
||
1413 | |||
1414 | if (GetZug(&DefZug)!=' ') |
||
1415 | { |
||
1416 | Len=1; |
||
1417 | switch (GetZug(&DefZug)) /* Zugriffsmodus festlegen */ |
||
1418 | { |
||
1419 | case 'L':Len += 2; /* Auf Long-Adresse biegen */ |
||
1420 | case 'W':Len++; /* Auf Wort-Adresse biegen */ |
||
1421 | } |
||
1422 | Idx=ParaNum(2) & -(long)Len; /* Adressen geradebiegen */ |
||
1423 | End=ParaNum(3); /* Endadresse festlegen */ |
||
1424 | if (ParaStr(4) == NULL) |
||
1425 | Loop = 1; |
||
1426 | else |
||
1427 | Loop=ParaNum(4); |
||
1428 | if (ParaStr(5) == NULL) |
||
1429 | Seed = 0x1234; |
||
1430 | else |
||
1431 | Seed=ParaNum(5); |
||
1432 | |||
1433 | do |
||
1434 | { |
||
1435 | srand(Seed + repeats); |
||
1436 | i = Idx; |
||
1437 | while ((i <= End) && (!Abbruch)) |
||
1438 | { |
||
1439 | Patt = rand(); |
||
1440 | |||
1441 | switch (DefZug) |
||
1442 | { |
||
1443 | case 'L':Patt <<= 16; |
||
1444 | Patt |= rand(); |
||
1445 | WriteLong(nInterfaceHandle, i, Patt, AdrMode); |
||
1446 | break; |
||
1447 | case 'W':WriteWord(nInterfaceHandle, i, (short)Patt, AdrMode); |
||
1448 | break; |
||
1449 | case 'B':WriteByte(nInterfaceHandle, i, (char)Patt, AdrMode); |
||
1450 | break; |
||
1451 | } /* switch */ |
||
1452 | |||
1453 | if (GetError(nInterfaceHandle)) |
||
1454 | { |
||
1455 | ClearError(nInterfaceHandle); /* Fehler abfangen */ |
||
1456 | Merk_error |= 2; |
||
1457 | } |
||
1458 | |||
1459 | if ((i & 0xffl)==0) |
||
1460 | { /* Ermoegliche Ctrl-C */ |
||
1461 | printf("\r"); |
||
1462 | } |
||
1463 | |||
1464 | i += Len; |
||
1465 | } /* while */ |
||
1466 | |||
1467 | // read and compare |
||
1468 | srand(Seed + repeats); |
||
1469 | i = Idx; |
||
1470 | while ((i <= End) && (!Abbruch)) |
||
1471 | { |
||
1472 | Patt = rand(); |
||
1473 | |||
1474 | switch (DefZug) |
||
1475 | { |
||
1476 | case 'L':lResult = ReadLong(nInterfaceHandle, i, AdrMode); |
||
1477 | Patt <<= 16; |
||
1478 | Patt |= rand(); |
||
1479 | if (lResult != (unsigned long)Patt) |
||
1480 | { |
||
1481 | printf("Compare Fail 0x%08x w=0x%08lx r=0x%08lx\n", i, Patt, lResult); |
||
1482 | Merk_error |= 1; |
||
1483 | } |
||
1484 | break; |
||
1485 | case 'W':wResult = ReadWord(nInterfaceHandle, i, AdrMode); |
||
1486 | if (wResult != (unsigned short)Patt) |
||
1487 | { |
||
1488 | printf("Compare Fail 0x%08x w=0x%04x r=0x%04x\n", i, Patt & 0xFFFF, wResult); |
||
1489 | Merk_error |= 1; |
||
1490 | } |
||
1491 | break; |
||
1492 | case 'B':bResult = ReadByte(nInterfaceHandle, i, AdrMode); |
||
1493 | if (bResult != (unsigned char)Patt) |
||
1494 | { |
||
1495 | printf("Compare Fail 0x%08x w=0x%02x r=0x%02x\n", i, Patt & 0xFF, bResult); |
||
1496 | Merk_error |= 1; |
||
1497 | } |
||
1498 | break; |
||
1499 | } /* switch */ |
||
1500 | |||
1501 | if (GetError(nInterfaceHandle)) |
||
1502 | { |
||
1503 | ClearError(nInterfaceHandle); /* Fehler abfangen */ |
||
1504 | Merk_error |= 2; |
||
1505 | } |
||
1506 | |||
1507 | if ((i & 0xffl)==0) |
||
1508 | { /* Ermoegliche Ctrl-C */ |
||
1509 | printf("\r"); |
||
1510 | } |
||
1511 | |||
1512 | i += Len; |
||
1513 | } /* while */ |
||
1514 | |||
1515 | if (Loop) |
||
1516 | printf("\rRepeats: 0x%x\r", repeats); |
||
1517 | repeats++; |
||
1518 | } while ((Loop--) && !(Merk_error)); |
||
1519 | |||
1520 | if (Merk_error) |
||
1521 | printf("--> Compare failed %s\a\n", (Merk_error & 2) ? "with Bus Error" : ""); |
||
1522 | else |
||
1523 | printf("--> Compare successfull\n"); |
||
1524 | |||
1525 | } |
||
1526 | else printf("\a"); |
||
1527 | |||
1528 | } |
||
1529 | |||
1530 | //----------------------------------------------------------------------------- |
||
1531 | // modify interface registers |
||
1532 | static void ModifyRegister(void) |
||
1533 | { |
||
1534 | __u32 Erg; |
||
1535 | |||
1536 | if (ParaStr(2) != NULL) |
||
1537 | { |
||
1538 | if (ParaStr(3) != NULL) |
||
1539 | { |
||
1540 | Erg = _SetRegister(nInterfaceHandle, ParaNum(2),ParaNum(3)); |
||
1541 | printf("Interface register @ 0x%08lx set: 0x%02x, get: 0x%02x\n", |
||
1542 | ParaNum(2), ParaNum(3), Erg); |
||
1543 | } |
||
1544 | else |
||
1545 | { |
||
1546 | Erg = _GetRegister(nInterfaceHandle, ParaNum(2)); |
||
1547 | printf("Interface register @ 0x%08lx get: 0x%02x\n", ParaNum(2), Erg); |
||
1548 | } |
||
1549 | } |
||
1550 | else |
||
1551 | printf("\a"); |
||
1552 | } |
||
1553 | |||
1554 | //----------------------------------------------------------------------------- |
||
1555 | // the main menu |
||
1556 | static int HauptMenue(STRG Stg) /* Eingabe & Dispatcher */ |
||
1557 | { |
||
1558 | char *SSt; /* Sourcezeiger */ |
||
1559 | char *DSt; /* Destzeiger */ |
||
1560 | char Del; /* Delimiter vorhanden? */ |
||
1561 | int Ret; /* Returncode fuer Auto-Mode */ |
||
1562 | char loop; /* irgedwie war baengg fuer loop */ |
||
1563 | |||
1564 | |||
1565 | if (Stg == NULL) |
||
1566 | loop = 1; |
||
1567 | else |
||
1568 | loop = 0; |
||
1569 | |||
1570 | do |
||
1571 | { |
||
1572 | if (loop) |
||
1573 | { /* Auto-Modus? */ |
||
1574 | if (Abbruch) |
||
1575 | { |
||
1576 | printf("\n"); |
||
1577 | Abbruch = 0; |
||
1578 | } |
||
1579 | |||
1580 | printf("pv: "); /* Nein, Prompt ausgeben und */ |
||
1581 | if (*ReadMessageBuffer()) |
||
1582 | { |
||
1583 | printf("%s\n", ReadMessageBuffer()); |
||
1584 | printf("pv: "); |
||
1585 | InitMessageBuffer(); |
||
1586 | } |
||
1587 | _gets(InStg); /* Eingabestring holen */ |
||
1588 | // GetError(nInterfaceHandle); /* because of interrupts */ |
||
1589 | SSt=InStg; /* Init Sourcezeiger */ |
||
1590 | } |
||
1591 | else |
||
1592 | SSt=Stg; /* Uebernehme Parameter aus Stg */ |
||
1593 | |||
1594 | DSt=InStg; /* Init Destzeiger */ |
||
1595 | Del=True; /* Weitere Delimiter raus */ |
||
1596 | Ret=0; /* Keine Fehler bis jetzt */ |
||
1597 | |||
1598 | while (*SSt) |
||
1599 | { /* Arbeite String ab */ |
||
1600 | if (UpCase(*SSt) >= 'A' && /* Filtern gueltiger Zeichen */ |
||
1601 | UpCase(*SSt) <= 'Z' || |
||
1602 | *SSt >= '0' && *SSt <= '9' || |
||
1603 | *SSt == ':' || *SSt == '.' || |
||
1604 | *SSt == '\\' || *SSt == '?') |
||
1605 | { |
||
1606 | *DSt=UpCase(*SSt); |
||
1607 | Del=False; |
||
1608 | DSt++; |
||
1609 | } |
||
1610 | else |
||
1611 | { |
||
1612 | if (!Del) |
||
1613 | { |
||
1614 | *DSt=' '; |
||
1615 | DSt++; |
||
1616 | } /* Mehrere Delimiter raus */ |
||
1617 | Del=True; /* und durch ' ' ersetzen */ |
||
1618 | } |
||
1619 | SSt++; |
||
1620 | } /* while (*SSt) */ |
||
1621 | *DSt=*SSt; /* 0 auch uebertragen */ |
||
1622 | |||
1623 | switch (*ParaStr(1)) |
||
1624 | { |
||
1625 | case 'A': SetModifier(); break; |
||
1626 | case 'D': Dump(); break; |
||
1627 | case 'E': Examine(); break; /* Speicherbereich aendern */ |
||
1628 | case 'F': Fill(); break; /* Speicherbereich fuellen */ |
||
1629 | case 'G': RandomTest(); break; /* random test of memory */ |
||
1630 | case 'H': |
||
1631 | case '?': Hilfe(); break; /* Hilf mir mal */ |
||
1632 | case 'I': DeInit_Interface(nInterfaceHandle); |
||
1633 | InitAt(cszDevicePath, &nInterfaceHandle); |
||
1634 | break; /* Nochmals initialisieren */ |
||
1635 | case 'C': Konfig(); break; /* Konfiguration */ |
||
1636 | case 'L': ReadIrqVect(); break; /* Interrupt-Vektoren lesen */ |
||
1637 | case 'M': Move(); break; /* Move Funktion */ |
||
1638 | case 'O': JumpToDos(); break; /* DOS Ausgang */ |
||
1639 | case 'P': SearchPorts(); break; /* Ports suchen */ |
||
1640 | case 'Q': Raus();return(0); /* Ende des Debuggers */ |
||
1641 | case 'R': Ret=_ReadFile(); break; /* Eine Datei nach VME lesen */ |
||
1642 | case 'S': SeekPatt(); break; /* Suche nach Datenmustern */ |
||
1643 | case 'T': TestSet(); break; /* Fuehre ein TAS aus */ |
||
1644 | case 'V': ResetVme(); break; /* Erzeuge VME-Reset */ |
||
1645 | case 'W': Ret=_WriteFile(); break;/* Eine Datei von VME schreiben */ |
||
1646 | case 'Y': SysFail(); break; /* read, set Sysfail */ |
||
1647 | case 'X': ModifyRegister(); break; /* modify register of the interface */ |
||
1648 | case 'Z': ShowRegister(); break; /* Register ausgeben */ |
||
1649 | default : |
||
1650 | { |
||
1651 | Ret=2; /* Fehlercode zurueck fuer Auto */ |
||
1652 | if (!loop) |
||
1653 | { /* Wenn Auto: Hilfsmessage */ |
||
1654 | Hilfe(); |
||
1655 | printf("\nSplit commands with \"/\" ,e.g. \"a39/d1000\""); |
||
1656 | } |
||
1657 | } |
||
1658 | } /* switch */ |
||
1659 | } while (loop); /* Hier raus bei Auto-Mode */ |
||
1660 | return(Ret); |
||
1661 | } |
||
1662 | |||
1663 | //------------------------------------------------------------------------------------- |
||
1664 | // the exit entry |
||
1665 | static void MyExit(int bla) /* Wird im Ctrl-C-Falle aufgerufen */ |
||
1666 | { |
||
1667 | Abbruch = 1; |
||
1668 | } |
||
1669 | |||
1670 | //------------------------------------------------------------------------------------- |
||
1671 | // where all starts |
||
1672 | int main(int argc, char **argv, char *envp[]) |
||
1673 | { |
||
1674 | static STRG Stg; /* Zum zusammenlegen Parameter */ |
||
1675 | char *PSt; /* Arbeitszeiger Multicommands */ |
||
1676 | char *SSt; /* Quellzeiger Multicommands */ |
||
1677 | int Idx; /* Index */ |
||
1678 | int Ret; /* Returncode */ |
||
1679 | |||
1680 | InitMessageBuffer(); |
||
1681 | |||
1682 | cszDevicePath = &localBuffer[0]; |
||
1683 | |||
1684 | Ret=1; /* Returncode auf Fehler setzen */ |
||
1685 | ArgV=argv; /* Uebertrage argv fuer LoadKonfig */ |
||
1686 | LoadKonfig(); /* Versuchen Konfigdatei zu lesen */ |
||
1687 | |||
1688 | if (argc > 1) |
||
1689 | { /* Kommandozeilenparameter da? */ |
||
1690 | if (InitAt(cszDevicePath, &nInterfaceHandle)) |
||
1691 | { /* Aufsetzen Interface */ |
||
1692 | *Stg='\0'; /* Stg auf nix setzen */ |
||
1693 | for (Idx=1; Idx < argc; Idx++) |
||
1694 | { |
||
1695 | strcat(Stg,argv[Idx]); /* Haenge Parameter hintereinander */ |
||
1696 | strcat(Stg," "); /* Trenne mit Leerzeichen */ |
||
1697 | } |
||
1698 | |||
1699 | SSt=Stg; /* Saubloedes (*Zeug) mit den ARRAYS! */ |
||
1700 | do |
||
1701 | { |
||
1702 | if ((PSt=strchr(SSt,'/'))!=NULL) *PSt='\0'; |
||
1703 | Ret=HauptMenue(SSt); /* Hauptmenue automatisch aufrufen */ |
||
1704 | SSt=PSt+1; /* SSt auf den Reststring setzen */ |
||
1705 | } |
||
1706 | |||
1707 | while (PSt!=NULL && !Ret); /* Bis Fehler oder Fertig */ |
||
1708 | } |
||
1709 | } |
||
1710 | else |
||
1711 | { |
||
1712 | printf("Provided under GPL - version %s of pvmon of %s \n\n", VERSION, __DATE__); |
||
1713 | printf("This program is free software; you can redistribute it and/or modify it\n"); |
||
1714 | printf("under the terms of the GPL as published by the FSF (version 2 or later).\n"); |
||
1715 | printf("Copyright: Ralf Dux, Sven Hannover, Klaus Hitschler, Sven Tuecke, AR\n"); |
||
1716 | |||
1717 | InitAt(cszDevicePath, &nInterfaceHandle); /* Aufsetzen Interface */ |
||
1718 | signal(SIGINT, MyExit); /* Eigenen Handler einklinken */ |
||
1719 | Ret=HauptMenue(NULL); /* Hauptmenue manuell aufrufen */ |
||
1720 | } /* else */ |
||
1721 | DeInit_Interface(nInterfaceHandle); /* Interface ausschalten */ |
||
1722 | |||
1723 | return(Ret); /* Fehlercode fuer ErrorLevel */ |
||
1724 | } |
||
1725 | |||
1726 | //------------------------------------------------------------------------------------------- |
||
1727 | //------------------------------------------------------------------------------------------- |
||
1728 | //------------------------------------------------------------------------------------------- |