OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [utils/] [amd-udi/] [mondfe/] [mini2udi.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 578 markom 
static char _[] = "@(#)mini2udi.c       5.23 93/08/18 13:48:08, Srini, AMD. ";
2 
/******************************************************************************
3 
 * Copyright 1991 Advanced Micro Devices, Inc.
4 
 *
5 
 * This software is the property of Advanced Micro Devices, Inc  (AMD)  which
6 
 * specifically  grants the user the right to modify, use and distribute this
7 
 * software provided this notice is not removed or altered.  All other rights
8 
 * are reserved by AMD.
9 
 *
10 
 * AMD MAKES NO WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, WITH REGARD TO THIS
11 
 * SOFTWARE.  IN NO EVENT SHALL AMD BE LIABLE FOR INCIDENTAL OR CONSEQUENTIAL
12 
 * DAMAGES IN CONNECTION WITH OR ARISING FROM THE FURNISHING, PERFORMANCE, OR
13 
 * USE OF THIS SOFTWARE.
14 
 *
15 
 * So that all may benefit from your experience, please report  any  problems
16 
 * or  suggestions about this software to the 29K Technical Support Center at
17 
 * 800-29-29-AMD (800-292-9263) in the USA, or 0800-89-1131  in  the  UK,  or
18 
 * 0031-11-1129 in Japan, toll free.  The direct dial number is 512-462-4118.
19 
 *
20 
 * Advanced Micro Devices, Inc.
21 
 * 29K Support Products
22 
 * Mail Stop 573
23 
 * 5900 E. Ben White Blvd.
24 
 * Austin, TX 78741
25 
 * 800-292-9263
26 
 *****************************************************************************
27 
 *      Engineer:  Srini Subramanian.
28 
 *****************************************************************************
29 
 * Definitions of the functions that define Minimon's Interface
30 
 * to the UDI
31 
 * interface The minimon functions are declared in miniint.h The UDI
32 
 * functions are declared in udi/udiproc.h
33 
 *****************************************************************************
34 
 */
35 
 
36 
 
37 
#include <stdio.h>
38 
#ifdef  MSDOS
39 
#include <io.h>
40 
#endif
41 
#include <string.h>
42 
#include "main.h"
43 
#include "memspcs.h"
44 
#include "macros.h"
45 
#include "miniint.h"
46 
#include "udiproc.h"
47 
#include "udiids.h"
48 
#include "udiext.h"
49 
#include "versions.h"
50 
 
51 
 
52 
/* Define BreakIdType here to avoid having to change at many places
53 
 * every time it changes.
54 
 */
55 
typedef unsigned int    BreakIdType;
56 
 
57 
/* ABOUT UDI calls:
58 
 * There are three types of return values:
59 
 * < 0: means a TIP failure.
60 
 * = 0: means success.
61 
 * > 0: means a "local" failure.
62 
 */
63 
 
64 
 
65 
 
66 
static  UDISessionId    SessionID;
67 
static  char            MONErrorMsg[MONErrorMsgSize];
68 
static  int             GoForever=0;
69 
 
70 
static  char    *udi_errmsg[] = {
71 
/*
72 
#define UDINoError                      0
73 
*/ "UDIERR: No Error",
74 
/*
75 
#define UDIErrorNoSuchConfiguration     1
76 
*/ "UDIERR: No Such Configuration in Config File.",
77 
/*
78 
#define UDIErrorCantHappen              2
79 
*/ "UDIERR: Cannot Happen With Current Environment Setup.",
80 
/*
81 
#define UDIErrorCantConnect             3
82 
*/ "UDIERR: Cannot Connect to TIP Specified.",
83 
/*
84 
#define UDIErrorNoSuchConnection        4
85 
*/ "UDIERR: No Such Connection Found.",
86 
/*
87 
#define UDIErrorNoConnection            5
88 
*/ "UDIERR: No Connection Occurred.",
89 
/*
90 
#define UDIErrorCantOpenConfigFile      6
91 
*/ "UDIERR: Cannot Open UDI Config File.",
92 
/*
93 
#define UDIErrorCantStartTIP            7
94 
*/ "UDIERR: Cannot Start TIP In Current Environment Setup.",
95 
/*
96 
#define UDIErrorConnectionUnavailable   8
97 
*/ "UDIERR: Requested Connection Unavailable.",
98 
/*
99 
#define UDIErrorTryAnotherTIP           9
100 
*/ "UDIERR: Try Another TIP For Connection.",
101 
/*
102 
#define UDIErrorExecutableNotTIP        10
103 
*/ "UDIERR: TIP Specified in Config File Not An Executable.",
104 
/*
105 
#define UDIErrorInvalidTIPOption        11
106 
*/ "UDIERR: Connection Failed Due To Invalid TIP Options in Config File.",
107 
/*
108 
#define UDIErrorCantDisconnect          12
109 
*/ "UDIERR: Cannot Disconnect TIP",
110 
/*
111 
#define UDIErrorUnknownError            13
112 
*/ "UDIERR: Unknown Error Number Specified.",
113 
/*
114 
#define UDIErrorCantCreateProcess       14
115 
*/ "UDIERR: TIP Cannot Create a New Process.",
116 
/*
117 
#define UDIErrorNoSuchProcess           15
118 
*/ "UDIERR: No Such Process in the Current TIP.",
119 
/*
120 
#define UDIErrorUnknownResourceSpace    16
121 
*/ "UDIERR: Unknown Resource Space Encountered By TIP.",
122 
/*
123 
#define UDIErrorInvalidResource         17
124 
*/ "UDIERR: Invalid Resource Specified To TIP.",
125 
/*
126 
#define UDIErrorUnsupportedStepType     18
127 
*/ "UDIERR: Unsupported Step Type For This TIP Specified.",
128 
/*
129 
#define UDIErrorCantSetBreakpoint       19
130 
*/ "UDIERR: Could Not Set The Breakpoint.",
131 
/*
132 
#define UDIErrorTooManyBreakpoints      20
133 
*/ "UDIERR: Too Many Breakpoints Already In Use.",
134 
/*
135 
#define UDIErrorInvalidBreakId          21
136 
*/ "UDIERR: Breakpoint Does Not Exist For This BreakId.",
137 
/*
138 
#define UDIErrorNoMoreBreakIds          22
139 
*/ "UDIERR: No More Breakpoints. BreakId Too High.",
140 
/*
141 
#define UDIErrorUnsupportedService      23
142 
*/ "UDIERR: TIP Does Not Support The Requested Service.",
143 
/*
144 
#define UDIErrorTryAgain                24
145 
*/ "UDIERR: Error Occurred. Trying Again.",
146 
/*
147 
#define UDIErrorIPCLimitation           25
148 
*/ "UDIERR: IPC Limitation Exceeded.",
149 
/*
150 
#define UDIErrorIncomplete              26
151 
*/ "UDIERR: Service Incomplete.More Data Available.",
152 
/*
153 
#define UDIErrorAborted                 27
154 
*/ "UDIERR: Aborted Requested Service.",
155 
/*
156 
#define UDIErrorTransDone               28
157 
*/ "UDIERR: Transaction Completed.",
158 
/*
159 
#define UDIErrorCantAccept              29
160 
*/ "UDIERR: Cannot Accept.",
161 
/*
162 
#define UDIErrorTransInputNeeded        30
163 
*/ "UDIERR: Transaction Input Needed.",
164 
/*
165 
#define UDIErrorTransModeX              31
166 
*/ "UDIERR: Transaction ModeX",
167 
/*
168 
#define UDIErrorInvalidSize             32
169 
*/ "UDIERR: Invalid Object Size Specified.",
170 
/*
171 
#define UDIErrorBadConfigFileEntry      33
172 
*/ "UDIERR: Bad Entry In UDI Config File Found.",
173 
/*
174 
#define UDIErrorIPCInternal             34
175 
*/ "UDIERR: Internal Error Occurred In IPC Layer."
176 
};
177 
 
178 
static  UDIPId          CurrentPID=(UDIPId) UDIProcessProcessor;
179 
static  void            PrintErrorMessage PARAMS((UDIError num));
180 
static  void            udi_warning PARAMS((int num));
181 
static  CPUSpace        xlate_mspace_mon2udi PARAMS((INT32 mspace));
182 
static  INT32           xlate_mspace_udi2mon PARAMS((CPUSpace mspace));
183 
static UDIError         FillString PARAMS(( UDIResource from,
184 
                                           UDIHostMemPtr pattern,
185 
                                           UDISizeT   pattern_count,
186 
                                           UDICount   fill_count));
187 
static UDIError         FillWords PARAMS(( UDIResource from,
188 
                                           UDIHostMemPtr pattern,
189 
                                           UDISizeT   pattern_count,
190 
                                           UDICount   fill_count));
191 
 
192 
 
193 
INT32
194 
/*********************************************Mini_TIP_init    */
195 
Mini_TIP_init(connect_string, mon_session_id)
196 
  char           *connect_string;
197 
  int            *mon_session_id;
198 
{
199 
  UDIError      UDIretval;
200 
  UDISessionId  session;
201 
 
202 
  /* First connect the target  */
203 
  if ((UDIretval = UDIConnect(connect_string,
204 
                           &session)) <= TIPFAILURE) {
205 
    SessionID = session;
206 
    *mon_session_id = (int) session;
207 
    PrintErrorMessage (UDIretval);
208 
    return ((INT32) UDIretval);
209 
  } else if (UDIretval == SUCCESS) {
210 
     SessionID = session;
211 
    *mon_session_id = (int) session;
212 
     return (SUCCESS);
213 
  } else {
214 
     SessionID = session;
215 
    *mon_session_id = (int) session;
216 
     udi_warning(UDIretval);
217 
     return((INT32) UDIretval);
218 
  };
219 
}
220 
 
221 
INT32
222 
Mini_TIP_Capabilities()
223 
{
224 
  UDIError      UDIretval;
225 
  UDIUInt32     TIPId;                  /* Out */
226 
  UDIUInt32     TargetId;               /* Out */
227 
  UDIUInt32     DFEId;                  /* In */
228 
  UDIUInt32     DFE;                    /* In */
229 
  UDIUInt32     TIP;                    /* Out */
230 
  UDIUInt32     DFEIPCId;               /* Out */
231 
  UDIUInt32     TIPIPCId;               /* Out */
232 
  char          TIPString[80];          /* Out */
233 
 
234 
    (void) strcpy (TIPString,"");
235 
    DFEId = (UDIUInt32) UDIID (UDIProductCode_Mondfe, MONDFERev, MONDFESubRev, MONDFESubSubRev);
236 
    DFE = (UDIUInt32) MONDFEUDIVers;
237 
    if ((UDIretval = UDICapabilities ( &TIPId,
238 
                                       &TargetId,
239 
                                       DFEId,
240 
                                       DFE,
241 
                                       &TIP,
242 
                                       &DFEIPCId,
243 
                                       &TIPIPCId,
244 
                                       &TIPString[0])) <= TIPFAILURE) {
245 
       PrintErrorMessage (UDIretval);
246 
       return (FAILURE);
247 
     } else if (UDIretval == SUCCESS) {
248 
       if (!QuietMode) {
249 
         if (io_config.echo_mode == (INT32) TRUE) {
250 
           fprintf(io_config.echo_file, "MiniMON29K Release 3.0\n");
251 
           fprintf(io_config.echo_file, ">AMD MONDFE Version: %d.%d.%d",
252 
                                  (int) ((DFEId & 0x00000F00) >> 8),
253 
                                  (int) ((DFEId & 0x000000F0) >> 4),
254 
                                  (int) ((DFEId & 0x0000000F) >> 0));
255 
           fprintf(io_config.echo_file, "\tIPC Version: %d.%d.%d UDI Rev. %d.%d.%d <\n",
256 
                                  (int) ((DFEIPCId & 0x00000F00) >> 8),
257 
                                  (int) ((DFEIPCId & 0x000000F0) >> 4),
258 
                                  (int) ((DFEIPCId & 0x0000000F) >> 0),
259 
                                  (int) ((DFE & 0x00000F00) >> 8),
260 
                                  (int) ((DFE & 0x000000F0) >> 4),
261 
                                  (int) ((DFE & 0x0000000F) >> 0));
262 
           fprintf(io_config.echo_file, "%s\n", TIPString);
263 
           fprintf(io_config.echo_file, ">TIP Version: %d.%d.%d",
264 
                                  (int) ((TIPId & 0x00000F00) >> 8),
265 
                                  (int) ((TIPId & 0x000000F0) >> 4),
266 
                                  (int) ((TIPId & 0x0000000F) >> 0));
267 
           fprintf(io_config.echo_file, "\tIPC Version: %d.%d.%d UDI Rev. %d.%d.%d<\n",
268 
                                  (int) ((TIPIPCId & 0x00000F00) >> 8),
269 
                                  (int) ((TIPIPCId & 0x000000F0) >> 4),
270 
                                  (int) ((TIPIPCId & 0x0000000F) >> 0),
271 
                                  (int) ((TIP & 0x00000F00) >> 8),
272 
                                  (int) ((TIP & 0x000000F0) >> 4),
273 
                                  (int) ((TIP & 0x0000000F) >> 0));
274 
         }
275 
         fprintf(stderr, "MiniMON29K Release 3.0\n");
276 
         fprintf(stderr, ">AMD MONDFE Version: %d.%d.%d",
277 
                                  (int) ((DFEId & 0x00000F00) >> 8),
278 
                                  (int) ((DFEId & 0x000000F0) >> 4),
279 
                                  (int) ((DFEId & 0x0000000F) >> 0));
280 
         fprintf(stderr, "\tIPC Version: %d.%d.%d UDI Rev. %d.%d.%d <\n",
281 
                                  (int) ((DFEIPCId & 0x00000F00) >> 8),
282 
                                  (int) ((DFEIPCId & 0x000000F0) >> 4),
283 
                                  (int) ((DFEIPCId & 0x0000000F) >> 0),
284 
                                  (int) ((DFE & 0x00000F00) >> 8),
285 
                                  (int) ((DFE & 0x000000F0) >> 4),
286 
                                  (int) ((DFE & 0x0000000F) >> 0));
287 
         fprintf(stderr, "%s\n", TIPString);
288 
         fprintf(stderr, ">TIP Version: %d.%d.%d",
289 
                                  (int) ((TIPId & 0x00000F00) >> 8),
290 
                                  (int) ((TIPId & 0x000000F0) >> 4),
291 
                                  (int) ((TIPId & 0x0000000F) >> 0));
292 
         fprintf(stderr, "\tIPC Version: %d.%d.%d UDI Rev. %d.%d.%d<\n",
293 
                                  (int) ((TIPIPCId & 0x00000F00) >> 8),
294 
                                  (int) ((TIPIPCId & 0x000000F0) >> 4),
295 
                                  (int) ((TIPIPCId & 0x0000000F) >> 0),
296 
                                  (int) ((TIP & 0x00000F00) >> 8),
297 
                                  (int) ((TIP & 0x000000F0) >> 4),
298 
                                  (int) ((TIP & 0x0000000F) >> 0));
299 
       }
300 
       if ( (int) ((TIPId & 0x00000F00) >> 8) <
301 
            (int) ((DFEId & 0x00000F00) >> 8) ) {
302 
         fprintf(stderr, "!!!!! WARNING: MONTIP's major version number is older than that of MONDFE's         !!!!!\n");
303 
         fprintf(stderr, "!!!!! Please verify the versions and call AMD 29K Technical Support for assistance. !!!!!\n");
304 
       }
305 
       if ((TIP == (UDIUInt32) 0) || ((TIP & 0xFFF) > (DFE & 0xFFF))) {
306 
          fprintf(stderr, "UDI WARNING: UDI Versions NOT Compatible.\n");
307 
       }
308 
       if (TIP == (UDIUInt32) 0)
309 
          return (FAILURE);
310 
       return (SUCCESS);
311 
     } else {
312 
        udi_warning(UDIretval);
313 
        return(FAILURE);
314 
     }
315 
}
316 
 
317 
INT32
318 
Mini_TIP_CreateProc()
319 
{
320 
     UDIError   UDIretval;
321 
     UDIPId     pid;
322 
 
323 
     if ((UDIretval = UDICreateProcess(&pid)) <= TIPFAILURE) {
324 
       PrintErrorMessage (UDIretval);
325 
       return (FAILURE);
326 
     } else if (UDIretval == SUCCESS) {
327 
       CurrentPID = pid;
328 
       return (SUCCESS);
329 
     } else {
330 
        udi_warning(UDIretval);
331 
        return(FAILURE);
332 
     }
333 
}
334 
 
335 
INT32
336 
Mini_TIP_disc()
337 
{
338 
  UDIError      UDIretval;
339 
 
340 
  if ((UDIretval = UDIDisconnect(SessionID,
341 
                              UDIContinueSession)) <= TIPFAILURE) {
342 
       PrintErrorMessage (UDIretval);
343 
       return (FAILURE);
344 
  } else if (UDIretval == SUCCESS) {
345 
       return(SUCCESS);
346 
  } else {
347 
        udi_warning(UDIretval);
348 
        return(FAILURE);
349 
  };
350 
}
351 
 
352 
INT32
353 
Mini_TIP_SetCurrSession(sid)
354 
int     sid;
355 
{
356 
  UDIError      UDIretval;
357 
 
358 
  if ((UDIretval = UDISetCurrentConnection((UDISessionId) sid)) <= TIPFAILURE) {
359 
       PrintErrorMessage (UDIretval);
360 
       return (FAILURE);
361 
  } else if (UDIretval == SUCCESS) {
362 
       SessionID = (UDISessionId) sid;
363 
       return (SUCCESS);
364 
  } else {
365 
        udi_warning(UDIretval);
366 
        return(FAILURE);
367 
  }
368 
}
369 
 
370 
INT32
371 
Mini_TIP_SetPID(pid)
372 
int     pid;
373 
{
374 
  UDIError      UDIretval;
375 
 
376 
  if ((UDIretval = UDISetCurrentProcess((UDIPId) pid)) <= TIPFAILURE) {
377 
       PrintErrorMessage (UDIretval);
378 
       return (FAILURE);
379 
  } else if (UDIretval == SUCCESS) {
380 
       return (SUCCESS);
381 
  } else {
382 
        udi_warning(UDIretval);
383 
        return(FAILURE);
384 
  }
385 
}
386 
 
387 
INT32
388 
Mini_TIP_DestroyProc()
389 
{
390 
  UDIError      UDIretval;
391 
 
392 
  if ((UDIretval = UDIDestroyProcess(CurrentPID)) <= TIPFAILURE) {
393 
       PrintErrorMessage (UDIretval);
394 
       return (FAILURE);
395 
  } else if (UDIretval == SUCCESS) {
396 
       return (SUCCESS);
397 
  } else {
398 
        udi_warning(UDIretval);
399 
        return(FAILURE);
400 
  }
401 
}
402 
 
403 
INT32
404 
Mini_TIP_exit()
405 
{
406 
  UDIError      UDIretval;
407 
 
408 
     if ((UDIretval = UDIDisconnect(SessionID,
409 
                              UDITerminateSession)) <= TIPFAILURE) {
410 
       PrintErrorMessage (UDIretval);
411 
       return (FAILURE);
412 
     } else if (UDIretval == SUCCESS) {
413 
       return(SUCCESS);
414 
     } else {
415 
        udi_warning(UDIretval);
416 
        return(FAILURE);
417 
     };
418 
}
419 
/* Breakpoint routines    */
420 
 
421 
/* Remove breakpoint      */
422 
INT32
423 
/*******************************************Mini_bkpt_rm   */
424 
Mini_bkpt_rm(break_id)
425 
int       break_id;
426 
{
427 
  UDIError      UDIretval;
428 
 
429 
  if ((UDIretval = UDIClearBreakpoint ((BreakIdType) break_id)) <= TIPFAILURE) {
430 
    PrintErrorMessage (UDIretval);
431 
    return (FAILURE);
432 
  } else if (UDIretval == SUCCESS) {
433 
    return(SUCCESS);
434 
  } else {
435 
     udi_warning(UDIretval);
436 
     return(FAILURE);
437 
  };
438 
}
439 
 
440 
/* Set   Breakpoints    */
441 
 
442 
INT32
443 
/**********************************************Mini_bkpt_set   */
444 
Mini_bkpt_set(m_space, address, pass_count, type, break_id)
445 
  INT32        m_space;
446 
  ADDR32          address;
447 
  INT32        pass_count;
448 
  INT32        type;
449 
  int       *break_id;
450 
{
451 
  UDIResource   addr;
452 
  UDIError      UDIretval;
453 
 
454 
 
455 
  addr.Space = xlate_mspace_mon2udi(m_space);
456 
  addr.Offset = address;
457 
 
458 
  if (type == BKPT_29000)
459 
     type = (UDIBreakType) UDIBreakFlagExecute;
460 
  else if (type == BKPT_29050)
461 
     type = (UDIBreakType) (MONBreakFlagHardware | UDIBreakFlagExecute);
462 
  else if (type == BKPT_29050_BTE_0)
463 
     type = (UDIBreakType) (MONBreakFlagHardware | UDIBreakFlagExecute);
464 
  else if (type == BKPT_29050_BTE_1)
465 
     type = (UDIBreakType) (MONBreakTranslationEnabled | MONBreakFlagHardware | UDIBreakFlagExecute);
466 
 
467 
  if ((UDIretval = UDISetBreakpoint(addr,
468 
                           (UDIInt32) pass_count,
469 
                           (UDIBreakType) type,
470 
                           (BreakIdType *) break_id)) <= TIPFAILURE) {
471 
     PrintErrorMessage (UDIretval);
472 
     return (FAILURE);
473 
  } else if (UDIretval == SUCCESS) {
474 
     return(SUCCESS);
475 
  } else {
476 
     udi_warning(UDIretval);
477 
     return(FAILURE);
478 
  }
479 
}
480 
 
481 
/* Query   (get status)  Breakpoints   */
482 
 
483 
INT32
484 
/**********************************************Mini_bkpt_stat   */
485 
Mini_bkpt_stat(break_id, address, m_space, pass_count,
486 
               bkpt_type, current_cnt)
487 
  int       break_id;
488 
  INT32       *m_space;
489 
  ADDR32      *address;
490 
  INT32       *pass_count;
491 
  INT32       *bkpt_type;
492 
  INT32       *current_cnt;
493 
{
494 
  UDIError      UDIretval;
495 
  UDIResource   addr;
496 
 
497 
  if ((UDIretval = UDIQueryBreakpoint ((BreakIdType) break_id,
498 
                                &addr,
499 
                                (UDIInt32 *)pass_count,
500 
                                (UDIBreakType *) bkpt_type,
501 
                                (UDIInt32 *) current_cnt)) <= TIPFAILURE) {
502 
    PrintErrorMessage (UDIretval);
503 
    return (FAILURE);
504 
  } else if (UDIretval == SUCCESS) {
505 
    *address = addr.Offset;
506 
    *m_space = xlate_mspace_udi2mon(addr.Space);
507 
    if (*bkpt_type & MONBreakFlagHardware)
508 
        *bkpt_type = BKPT_29050;
509 
    return(SUCCESS);
510 
  } else {
511 
     if (UDIretval == UDIErrorNoMoreBreakIds)
512 
        return ((INT32) MONBreakNoMore);
513 
     else if (UDIretval == UDIErrorInvalidBreakId)
514 
        return ((INT32) MONBreakInvalid);
515 
     else {
516 
       udi_warning(UDIretval);
517 
       return(FAILURE);
518 
     }
519 
  };
520 
}
521 
 
522 
/* Kill    Target     */
523 
 
524 
INT32
525 
/**********************************************Mini_break   */
526 
Mini_break()
527 
{
528 
 
529 
  UDIStop();
530 
  return (SUCCESS);
531 
}
532 
 
533 
/* Obtain Target configuration and resynchronize with target  */
534 
 
535 
UDIInt32
536 
/**********************************************Mini_config_req   */
537 
Mini_config_req(target_config, versions)
538 
  TARGET_CONFIG  *target_config;
539 
  VERSIONS_ETC   *versions;
540 
{
541 
  UDIError      UDIretval;
542 
  UDIMemoryRange        DFEMemRange[MONMaxMemRanges];
543 
  UDIUInt32     ChipVersions[MONMaxChips];
544 
  UDIInt        NumRanges, NumChips;
545 
  UDIInt        i;
546 
 
547 
  NumRanges = (UDIInt) MONMaxMemRanges;
548 
  NumChips  = (UDIInt) MONMaxChips;
549 
 
550 
  if ((UDIretval = UDIGetTargetConfig(
551 
                           (UDIMemoryRange *) &DFEMemRange[0],
552 
                           (UDIInt *) &NumRanges, /* 3 -> I, D, R */
553 
                           (UDIUInt32 *) &ChipVersions[0],
554 
                           (UDIInt *) &NumChips)) <= TIPFAILURE) {
555 
      PrintErrorMessage (UDIretval);
556 
      return(FAILURE);
557 
  } else if ((UDIretval == SUCCESS) || (UDIretval == UDIErrorIncomplete)) {
558 
      if (UDIretval == UDIErrorIncomplete) {
559 
        fprintf(stderr, "Ignoring: ");
560 
        if (io_config.echo_mode == (INT32) TRUE) {
561 
           fprintf(io_config.echo_file, "Ignoring: ");
562 
           fflush (io_config.echo_file);
563 
        }
564 
        udi_warning(UDIretval);
565 
      };
566 
      i = (UDIInt) 0;
567 
      while ((i < (UDIInt) MONMaxMemRanges) && (i < NumRanges)) {
568 
           switch ((int) DFEMemRange[i].Space) {
569 
             case  UDI29KDRAMSpace:
570 
                target_config->D_mem_start = (ADDR32) DFEMemRange[i].Offset;
571 
                target_config->D_mem_size = (INT32) DFEMemRange[i].Size;
572 
                break;
573 
             case        UDI29KIROMSpace:
574 
                target_config->ROM_start = (ADDR32) DFEMemRange[i].Offset;
575 
                target_config->ROM_size = (INT32) DFEMemRange[i].Size;
576 
                break;
577 
             case        UDI29KIRAMSpace:
578 
                target_config->I_mem_start = (ADDR32) DFEMemRange[i].Offset;
579 
                target_config->I_mem_size = (INT32) DFEMemRange[i].Size;
580 
                break;
581 
             default: /* don't care, so ignore it */
582 
                break;
583 
           };
584 
           i = i + (UDIInt) 1;
585 
      } /* end while */
586 
      i = (UDIInt) 0;
587 
      while ((i < (UDIInt) MONMaxChips) && (i < NumChips)) {
588 
           switch (i) {
589 
              case      0:  /* cpu */
590 
                target_config->processor_id = (UINT32) ChipVersions[i];
591 
                break;
592 
              case      1:  /* coprocessor */
593 
                target_config->coprocessor = (UINT32) ChipVersions[i];
594 
                if (target_config->coprocessor == (UINT32) UDI29KChipNotPresent)
595 
                   target_config->coprocessor = (UINT32) -1; /* MONDFE's */
596 
                break;
597 
              default:  /* ignore */
598 
                break;
599 
           };
600 
           i = i + (UDIInt) 1;
601 
      } /* end while */
602 
      return(SUCCESS);
603 
  } else {
604 
      udi_warning(UDIretval);
605 
      return(FAILURE);
606 
  }
607 
}
608 
 
609 
 
610 
/* Copy memory and registers    */
611 
 
612 
 
613 
INT32
614 
/**********************************************Mini_copy   */
615 
Mini_copy(src_space, src_addr, dst_space, dst_addr, byte_count, size, dir)
616 
  INT32        src_space,
617 
               dst_space;
618 
  ADDR32       src_addr,
619 
               dst_addr;
620 
  INT32          byte_count;
621 
  INT16         size;
622 
  INT32          dir;
623 
{
624 
  UDIError      UDIretval;
625 
  UDIResource   from, to;
626 
  UDICount      count_done;
627 
 
628 
  from.Space = xlate_mspace_mon2udi(src_space);
629 
  from.Offset = src_addr;
630 
  to.Space = xlate_mspace_mon2udi(dst_space);
631 
  to.Offset = dst_addr;
632 
 
633 
  if ((UDIretval = UDICopy (from,
634 
                            to,
635 
                            (UDICount) byte_count,
636 
                            (UDISizeT) size,
637 
                            &count_done,
638 
                            (UDIBool) dir)) <= TIPFAILURE) {
639 
      PrintErrorMessage (UDIretval);
640 
      return (FAILURE);
641 
  } else if (UDIretval == SUCCESS) {
642 
      return(SUCCESS);
643 
  } else {
644 
     udi_warning(UDIretval);
645 
     return(FAILURE);
646 
  }
647 
}
648 
 
649 
/* Fill memory and registers    */
650 
 
651 
 
652 
/* fill_count if greater than 4 should be a multiple of 4 */
653 
INT32
654 
/**********************************************Mini_fill   */
655 
Mini_fill(m_space, start, fill_count, pattern_count, pattern)
656 
  INT32        m_space;
657 
  ADDR32          start;
658 
  INT32        fill_count,
659 
                  pattern_count;
660 
  BYTE           *pattern;
661 
{
662 
  UDIBool         host_endian;
663 
  UDIResource   from;
664 
  UDICount      count_done;
665 
  UDIError      UDIretval;
666 
 
667 
  host_endian = FALSE;
668 
 
669 
  from.Offset = start;
670 
  from.Space = xlate_mspace_mon2udi (m_space);
671 
 
672 
  if (fill_count == (INT32) 1) { /* takes only one write */
673 
     if ((UDIretval = UDIWrite((UDIHostMemPtr) pattern,
674 
                               from,
675 
                               (UDICount) fill_count,
676 
                               (UDISizeT) pattern_count, /* a byte at a time */
677 
                               (UDICount *) &count_done,
678 
                               host_endian)) <= TIPFAILURE) {
679 
        PrintErrorMessage (UDIretval);
680 
        return (FAILURE);
681 
     } else if (UDIretval == SUCCESS) {
682 
        return(SUCCESS);
683 
     } else {
684 
        udi_warning(UDIretval);
685 
        return(FAILURE);
686 
     };
687 
  } else {
688 
     /* Handle arbitrary length strings to Data memory separately */
689 
     if ((pattern_count > (INT32) 4) &&
690 
                               ((int) (pattern_count % 4) != (int) 0)){
691 
        if (from.Space != UDI29KDRAMSpace)
692 
          return (FAILURE);
693 
        return((INT32) FillString(from, (UDIHostMemPtr) pattern,
694 
                           (UDISizeT) pattern_count, (UDICount) fill_count));
695 
     } else {
696 
        return((INT32) FillWords(from, (UDIHostMemPtr) pattern,
697 
                           (UDISizeT) pattern_count, (UDICount) fill_count));
698 
     }
699 
  };
700 
}
701 
 
702 
/* Initiate a wait and get target status  */
703 
 
704 
INT32
705 
/**********************************************Mini_get_target_stats   */
706 
Mini_get_target_stats(maxtime, target_status)
707 
INT32   maxtime;
708 
INT32  *target_status;
709 
{
710 
  UDIPId        pid;
711 
  UDIError      UDIretval;
712 
  UDIInt32      udiwait_code;
713 
 
714 
  if (maxtime == (INT32) -1) {
715 
    udiwait_code = (UDIInt32) UDIWaitForever;
716 
  } else {
717 
    udiwait_code = (UDIInt32) maxtime;
718 
  };
719 
  if ((UDIretval = UDIWait ((UDIInt32) udiwait_code,
720 
                            &pid,
721 
                            (UDIUInt32 *) target_status)) <= TIPFAILURE) {
722 
        PrintErrorMessage (UDIretval);
723 
        return (SUCCESS);  /* considered non-fatal */
724 
  } else if (UDIretval == SUCCESS) {
725 
        CurrentPID = (UDIPId) pid; /* useful when reconnecting */
726 
        return(SUCCESS);
727 
  } else {
728 
        udi_warning(UDIretval);
729 
        return(FAILURE);
730 
  };
731 
}
732 
 
733 
 
734 
INT32
735 
/**********************************************Mini_go   */
736 
Mini_go()
737 
{
738 
  UDIError      UDIretval;
739 
 
740 
  if ((UDIretval = UDIExecute()) <= TIPFAILURE) {
741 
        PrintErrorMessage (UDIretval);
742 
        return (FAILURE);
743 
  } else if (UDIretval == SUCCESS) {
744 
        return(SUCCESS);
745 
  } else {
746 
        udi_warning(UDIretval);
747 
        return(FAILURE);
748 
  };
749 
}
750 
 
751 
INT32
752 
/**********************************************Mini_init   */
753 
Mini_init(txt_start, txt_end, dat_start, dat_end,
754 
          entry_point, m_stack, r_stack,
755 
          arg_string)
756 
  ADDR32          txt_start,
757 
                  txt_end,
758 
                  dat_start,
759 
                  dat_end;
760 
  ADDR32          entry_point;
761 
  INT32        m_stack,
762 
                  r_stack;
763 
  char          *arg_string;
764 
{
765 
  UDIMemoryRange        ProcessMemory[MONMaxProcessMemRanges];
766 
  UDIInt        NumRanges;
767 
  UDIResource   Entry;
768 
  CPUSizeT      StackSizes[MONMaxStacks];
769 
  UDIInt        NumStacks;
770 
  UDIError      UDIretval;
771 
 
772 
  NumRanges = (UDIInt) MONMaxProcessMemRanges;
773 
  NumStacks = (UDIInt) MONMaxStacks;
774 
  ProcessMemory[0].Space = (CPUSpace) UDI29KIRAMSpace;
775 
  ProcessMemory[0].Offset = (CPUOffset) txt_start;
776 
  ProcessMemory[0].Size = (CPUSizeT) (txt_end - txt_start);
777 
  ProcessMemory[1].Space = (CPUSpace) UDI29KDRAMSpace;
778 
  ProcessMemory[1].Offset = (CPUOffset) dat_start;
779 
  ProcessMemory[1].Size = (CPUSizeT) (dat_end - dat_start);
780 
  Entry.Offset = entry_point;
781 
  Entry.Space = xlate_mspace_mon2udi((INT32) I_MEM);
782 
  StackSizes[0] = (CPUSizeT) r_stack;
783 
  StackSizes[1] = (CPUSizeT) m_stack;
784 
 
785 
  if ((UDIretval = UDIInitializeProcess (&ProcessMemory[0],
786 
                                         (UDIInt) NumRanges,
787 
                                         Entry,
788 
                                         &StackSizes[0],
789 
                                         (UDIInt) NumStacks,
790 
                                         arg_string)) <= TIPFAILURE) {
791 
        PrintErrorMessage (UDIretval);
792 
        return (FAILURE);
793 
  } else if (UDIretval == SUCCESS) {
794 
        return(SUCCESS);
795 
  } else {
796 
        udi_warning(UDIretval);
797 
        return(FAILURE);
798 
  };
799 
}
800 
 
801 
 
802 
/* Read memory or registers from target  */
803 
INT32
804 
/**********************************************Mini_read_req   */
805 
Mini_read_req(m_space, address, byte_count, size, count_done,
806 
              buffer, host_endian)
807 
  INT32        m_space;
808 
  ADDR32       address;
809 
  INT32        byte_count;
810 
  INT16        size;
811 
  INT32        host_endian;
812 
  INT32       *count_done;
813 
  BYTE        *buffer;
814 
{
815 
  UDIError      UDIretval;
816 
  UDIResource   from;
817 
 
818 
  from.Space = xlate_mspace_mon2udi(m_space);
819 
  from.Offset = address;
820 
 
821 
  if ((UDIretval = UDIRead (from,
822 
                            (UDIHostMemPtr) buffer,
823 
                            (UDICount) byte_count,
824 
                            (UDISizeT) size,
825 
                            (UDICount *) count_done,
826 
                            (UDIBool) host_endian)) <= TIPFAILURE) {
827 
       PrintErrorMessage (UDIretval);
828 
      return(FAILURE);
829 
  } else if (UDIretval == SUCCESS) {
830 
      return(SUCCESS);
831 
  } else {
832 
      udi_warning(UDIretval);
833 
      return(FAILURE);
834 
  }
835 
}
836 
 
837 
/*
838 
 * Reset target processor
839 
 */
840 
INT32
841 
/**********************************************Mini_reset_processor   */
842 
Mini_reset_processor()
843 
{
844 
  UDIMemoryRange        ProcessMemory[MONMaxProcessMemRanges];
845 
  UDIInt        NumRanges;
846 
  UDIResource   Entry;
847 
  CPUSizeT      StackSizes[MONMaxStacks];
848 
  UDIInt        NumStacks;
849 
  UDIError      UDIretval;
850 
  UDIPId        CurrentPID;
851 
  UDIUInt32     StopReason;
852 
 
853 
 
854 
  NumRanges = (UDIInt) MONMaxProcessMemRanges;
855 
  NumStacks = (UDIInt) MONMaxStacks;
856 
  ProcessMemory[0].Space = (CPUSpace) UDI29KIRAMSpace;
857 
  ProcessMemory[0].Offset = (CPUOffset) 0;
858 
  ProcessMemory[0].Size = (CPUSizeT) 0;
859 
  ProcessMemory[0].Space = (CPUSpace) UDI29KIRAMSpace;
860 
  ProcessMemory[0].Offset = (CPUOffset) 0;
861 
  ProcessMemory[0].Size = (CPUSizeT) 0;
862 
  Entry.Offset = 0;
863 
  Entry.Space = xlate_mspace_mon2udi((INT32) I_MEM);
864 
  StackSizes[0] = (CPUSizeT) 0;
865 
  StackSizes[1] = (CPUSizeT) 0;
866 
 
867 
  if ((UDIretval = UDIWait((UDIInt32) 0, &CurrentPID, &StopReason))
868 
                                                         <= TIPFAILURE) {
869 
       PrintErrorMessage (UDIretval);
870 
      return(FAILURE);
871 
  } else if (UDIretval != SUCCESS) {
872 
      udi_warning(UDIretval);
873 
      return(FAILURE);
874 
  };
875 
  /* set PID to ProcProcessor */
876 
  if (( UDIretval = UDISetCurrentProcess((UDIPId) UDIProcessProcessor))
877 
                                                           <= TIPFAILURE) {
878 
       PrintErrorMessage (UDIretval);
879 
      return(FAILURE);
880 
  } else if (UDIretval != SUCCESS) {
881 
      udi_warning(UDIretval);
882 
      return(FAILURE);
883 
  };
884 
  /* Successful */
885 
  /* call InitializeProcess. Paramters ignored. */
886 
  if ((UDIretval = UDIInitializeProcess (&ProcessMemory[0],
887 
                                         (UDIInt) NumRanges,
888 
                                         Entry,
889 
                                         &StackSizes[0],
890 
                                         (UDIInt) NumStacks,
891 
                                         (char *) 0)) <= TIPFAILURE) {
892 
       PrintErrorMessage (UDIretval);
893 
      return(FAILURE);
894 
  } else if (UDIretval != SUCCESS) {
895 
      udi_warning(UDIretval);
896 
      return(FAILURE);
897 
  };
898 
  /* Successful */
899 
  if (( UDIretval = UDISetCurrentProcess((UDIPId) CurrentPID))
900 
                                                         <= TIPFAILURE) {
901 
       PrintErrorMessage (UDIretval);
902 
      return(FAILURE);
903 
  } else if (UDIretval != SUCCESS) {
904 
      udi_warning(UDIretval);
905 
      return(FAILURE);
906 
  };
907 
  return (SUCCESS);
908 
}
909 
 
910 
/* Write memory or registers to target  */
911 
INT32
912 
/**********************************************Mini_write_req   */
913 
Mini_write_req(m_space, address, byte_count, size, count_done,
914 
               buffer, host_endian)
915 
  INT32        m_space;
916 
  ADDR32          address;
917 
  INT32        byte_count;
918 
  INT16         size;
919 
  INT32       *count_done;
920 
  BYTE           *buffer;
921 
  INT32        host_endian;
922 
{
923 
  UDIError      UDIretval;
924 
  UDIResource   to;
925 
 
926 
  to.Space = xlate_mspace_mon2udi(m_space);
927 
  to.Offset = address;
928 
 
929 
  if ((UDIretval = UDIWrite((UDIHostMemPtr) buffer,
930 
                            to,
931 
                            (UDICount) byte_count,
932 
                            (UDISizeT) size,
933 
                            (UDICount *) count_done,
934 
                            (UDIBool) host_endian)) <= TIPFAILURE) {
935 
        PrintErrorMessage (UDIretval);
936 
       return(FAILURE);
937 
  } else if (UDIretval == SUCCESS) {
938 
      return(SUCCESS);
939 
  } else {
940 
      udi_warning(UDIretval);
941 
      return(FAILURE);
942 
  }
943 
}
944 
 
945 
INT32
946 
Mini_stdin_mode_x(mode)
947 
INT32   *mode;
948 
{
949 
  UDIError      UDIretval;
950 
 
951 
  if ((UDIretval = UDIStdinMode ((UDIMode *) mode)) <= TIPFAILURE) {
952 
        PrintErrorMessage (UDIretval);
953 
        return (FAILURE);
954 
  } else if (UDIretval == SUCCESS) {
955 
        return(SUCCESS);
956 
  } else {
957 
        udi_warning(UDIretval);
958 
        return(FAILURE);
959 
  };
960 
}
961 
 
962 
INT32
963 
/**********************************************Mini_put_stdin   */
964 
Mini_put_stdin(buffer, bufsize, count)
965 
  char       *buffer;
966 
  INT32        bufsize;
967 
  INT32       *count;
968 
{
969 
  UDIError      UDIretval;
970 
 
971 
  if ((UDIretval = UDIPutStdin ((UDIHostMemPtr) buffer,
972 
                                (UDISizeT) bufsize,
973 
                                (UDISizeT *) count)) <= TIPFAILURE) {
974 
        PrintErrorMessage (UDIretval);
975 
        return (FAILURE);
976 
  } else if (UDIretval == SUCCESS) {
977 
        return(SUCCESS);
978 
  } else {
979 
        udi_warning(UDIretval);
980 
        return(FAILURE);
981 
  };
982 
}
983 
 
984 
/* Put characters to stdout   */
985 
 
986 
 
987 
INT32
988 
/**********************************************Mini_get_stdout   */
989 
Mini_get_stdout(buffer, bufsize, count_done)
990 
  char       *buffer;
991 
  INT32       *count_done;
992 
  INT32        bufsize;
993 
{
994 
  UDIError      UDIretval;
995 
 
996 
  if ((UDIretval = UDIGetStdout ((UDIHostMemPtr) buffer,
997 
                         (UDISizeT) bufsize,
998 
                         (UDISizeT *) count_done)) <= TIPFAILURE) {
999 
        PrintErrorMessage (UDIretval);
1000 
        return (FAILURE);
1001 
  } else if (UDIretval == SUCCESS) {
1002 
        return(SUCCESS);
1003 
  } else {
1004 
        udi_warning(UDIretval);
1005 
        return(FAILURE);
1006 
  }
1007 
}
1008 
 
1009 
INT32
1010 
/**********************************************Mini_get_stderr   */
1011 
Mini_get_stderr(buffer, bufsize, count_done)
1012 
  char       *buffer;
1013 
  INT32       *count_done;
1014 
  INT32        bufsize;
1015 
{
1016 
  UDIError      UDIretval;
1017 
  if ((UDIretval = UDIGetStderr ((UDIHostMemPtr) buffer,
1018 
                         (UDISizeT) bufsize,
1019 
                         (UDISizeT *) count_done)) <= TIPFAILURE) {
1020 
        PrintErrorMessage (UDIretval);
1021 
        return (FAILURE);
1022 
  } else if (UDIretval == SUCCESS) {
1023 
        return(SUCCESS);
1024 
  } else {
1025 
        udi_warning(UDIretval);
1026 
        return(FAILURE);
1027 
  }
1028 
}
1029 
 
1030 
/* Step instructions   */
1031 
 
1032 
 
1033 
INT32
1034 
/**********************************************Mini_step   */
1035 
Mini_step(count)
1036 
INT32   count;
1037 
{
1038 
  UDIError      UDIretval;
1039 
  UDIRange      dummy_range;
1040 
  UDIStepType   step_type;
1041 
 
1042 
  dummy_range.Low = 0;
1043 
  dummy_range.High = 0xffffffff;
1044 
 
1045 
  step_type = UDIStepNatural;
1046 
 
1047 
  if ((UDIretval = UDIStep((UDIUInt32) count,
1048 
                           step_type,
1049 
                           dummy_range)) <= TIPFAILURE) {
1050 
        PrintErrorMessage (UDIretval);
1051 
        return (FAILURE);
1052 
  } else if (UDIretval == SUCCESS) {
1053 
        return(SUCCESS);
1054 
  } else {
1055 
        udi_warning(UDIretval);
1056 
        return(FAILURE);
1057 
  };
1058 
}
1059 
 
1060 
INT32
1061 
/***************************************************** Mini_put_trans */
1062 
Mini_put_trans(buffer)
1063 
char    *buffer;
1064 
{
1065 
  UDIError      UDIretval;
1066 
  UDISizeT      count;
1067 
  UDISizeT      *count_done;
1068 
 
1069 
  count = (UDISizeT) (strlen (buffer) + 1);
1070 
  if ((UDIretval = UDIPutTrans((UDIHostMemPtr) buffer,
1071 
                               (UDISizeT) count,
1072 
                               (UDISizeT *) count_done)) <= TIPFAILURE) {
1073 
        PrintErrorMessage (UDIretval);
1074 
        return (FAILURE);
1075 
  } else if (UDIretval == SUCCESS) {
1076 
        return(SUCCESS);
1077 
  } else {
1078 
        udi_warning(UDIretval);
1079 
        return(FAILURE);
1080 
  };
1081 
 
1082 
}
1083 
 
1084 
 
1085 
static CPUSpace
1086 
xlate_mspace_mon2udi(m_space)
1087 
INT32   m_space;
1088 
{
1089 
  switch(m_space) {
1090 
    case        LOCAL_REG:
1091 
        return((CPUSpace) UDI29KLocalRegs);
1092 
    case        ABSOLUTE_REG:
1093 
        return((CPUSpace) UDI29KGlobalRegs);
1094 
    case        GLOBAL_REG:
1095 
        return((CPUSpace) UDI29KGlobalRegs);
1096 
    case        SPECIAL_REG:
1097 
        return((CPUSpace) UDI29KSpecialRegs);
1098 
    case        TLB_REG:
1099 
        return((CPUSpace) UDI29KTLBRegs);
1100 
    case        COPROC_REG:
1101 
        return((CPUSpace) UDI29KAm29027Regs);
1102 
    case        I_MEM:
1103 
        return((CPUSpace) UDI29KIRAMSpace);
1104 
    case        D_MEM:
1105 
        return((CPUSpace) UDI29KDRAMSpace);
1106 
    case        I_ROM:
1107 
        return((CPUSpace) UDI29KIROMSpace);
1108 
    case        D_ROM:
1109 
        return((CPUSpace) UDI29KDRAMSpace);
1110 
    case        I_O:
1111 
        return((CPUSpace) UDI29KIOSpace);
1112 
    case        I_CACHE:
1113 
        return((CPUSpace) UDI29KICacheSpace);
1114 
    case        D_CACHE:
1115 
        return((CPUSpace) UDI29KDCacheSpace);
1116 
    case        PC_SPACE:
1117 
        return((CPUSpace) UDI29KPC);
1118 
    case        A_SPCL_REG:
1119 
        return((CPUSpace) UDI29KSpecialRegs);
1120 
    case        GENERIC_SPACE:
1121 
        return ((CPUSpace) UDI29KDRAMSpace);
1122 
    case        VERSION_SPACE:
1123 
        return ((CPUSpace) VERSION_SPACE);
1124 
    default:
1125 
        return((CPUSpace) FAILURE);
1126 
  };
1127 
}
1128 
 
1129 
static INT32
1130 
xlate_mspace_udi2mon(mspace)
1131 
CPUSpace        mspace;
1132 
{
1133 
   switch(mspace) {
1134 
     case       UDI29KDRAMSpace:
1135 
        return((INT32) D_MEM);
1136 
     case       UDI29KIOSpace:
1137 
        return((INT32) I_O);
1138 
     case       UDI29KCPSpace0:
1139 
        return((INT32) FAILURE);
1140 
     case       UDI29KCPSpace1:
1141 
        return((INT32) FAILURE);
1142 
     case       UDI29KIROMSpace:
1143 
        return((INT32) I_ROM);
1144 
     case       UDI29KIRAMSpace:
1145 
        return((INT32) I_MEM);
1146 
     case       UDI29KLocalRegs:
1147 
        return((INT32) LOCAL_REG);
1148 
     case       UDI29KGlobalRegs:
1149 
        return((INT32) GLOBAL_REG);
1150 
     case       UDI29KRealRegs:
1151 
        return((INT32) GLOBAL_REG);
1152 
     case       UDI29KSpecialRegs:
1153 
        return((INT32) SPECIAL_REG);
1154 
     case       UDI29KTLBRegs:
1155 
        return((INT32) TLB_REG);
1156 
     case       UDI29KACCRegs:
1157 
        return((INT32) FAILURE);
1158 
     case       UDI29KICacheSpace:
1159 
        return((INT32) I_CACHE);
1160 
     case       UDI29KAm29027Regs:
1161 
        return((INT32) COPROC_REG);
1162 
     case       UDI29KPC:
1163 
        return((INT32) PC_SPACE);
1164 
     case       UDI29KDCacheSpace:
1165 
        return((INT32) D_CACHE);
1166 
     default:
1167 
        return(FAILURE);
1168 
   };
1169 
}
1170 
 
1171 
static
1172 
void udi_warning(num)
1173 
int     num;
1174 
{
1175 
  fprintf(stderr, "UDIERROR: %d : %s\n", num, udi_errmsg[num]);
1176 
  fflush(stderr);
1177 
  if (io_config.echo_mode == (INT32) TRUE) {
1178 
     fprintf(io_config.echo_file, "UDIERROR: %d :%s\n", num, udi_errmsg[num]);
1179 
     fflush (io_config.echo_file);
1180 
  }
1181 
}
1182 
 
1183 
static void
1184 
PrintErrorMessage(UDIretval)
1185 
UDIError        UDIretval;
1186 
{
1187 
    UDISizeT    ErrorMsgCnt;
1188 
 
1189 
    fprintf(stderr, "TIPERROR: %d :", UDIretval);
1190 
    fflush(stderr);
1191 
    if (io_config.echo_mode == (INT32) TRUE) {
1192 
       fprintf(io_config.echo_file, "TIPERROR: %d :", UDIretval);
1193 
       fflush(io_config.echo_file);
1194 
    }
1195 
 
1196 
    ErrorMsgCnt = (UDISizeT) 0;
1197 
    do {
1198 
       if (UDIGetErrorMsg(UDIretval,
1199 
                             (UDISizeT) MONErrorMsgSize,
1200 
                             MONErrorMsg, &ErrorMsgCnt) != UDINoError) {
1201 
           fprintf(stderr, "TIPERROR: Could not get TIP error message.\n");
1202 
           fflush(stderr);
1203 
           return;
1204 
        }
1205 
       write (fileno(stderr), &MONErrorMsg[0], (int) ErrorMsgCnt);
1206 
       if (io_config.echo_mode == (INT32) TRUE)
1207 
          write (fileno(io_config.echo_file), &MONErrorMsg[0], (int) ErrorMsgCnt);
1208 
    } while (ErrorMsgCnt == (UDISizeT) MONErrorMsgSize);
1209 
    fprintf(stderr, "\n");
1210 
    if (io_config.echo_mode == (INT32) TRUE) {
1211 
       fprintf(io_config.echo_file, "\n");
1212 
       fflush(io_config.echo_file);
1213 
    }
1214 
    return;
1215 
}
1216 
 
1217 
static UDIError
1218 
FillWords(from, pattern, pattern_count, fill_count)
1219 
UDIResource     from;
1220 
UDIHostMemPtr   pattern;
1221 
UDISizeT        pattern_count;
1222 
UDICount        fill_count;
1223 
{
1224 
   UDICount     count_done;
1225 
   UDIBool      host_endian, direction;
1226 
   UDIError     UDIretval;
1227 
   UDIResource  to;
1228 
 
1229 
   INT32        isregspace = ISREG(xlate_mspace_udi2mon(from.Space));
1230 
 
1231 
   host_endian = FALSE;
1232 
 
1233 
        if ((UDIretval = UDIWrite((UDIHostMemPtr) pattern,
1234 
                               from,
1235 
                               (UDICount) 1,
1236 
                               (UDISizeT) pattern_count,
1237 
                               (UDICount *) &count_done,
1238 
                               host_endian)) <= TIPFAILURE) {
1239 
           PrintErrorMessage (UDIretval);
1240 
           return (FAILURE);
1241 
        } else if (UDIretval == SUCCESS) {  /* do copy */
1242 
           fill_count = fill_count - 1; /* one less */
1243 
           if (fill_count > (INT32) 0) { /* do copy */
1244 
              if (isregspace)
1245 
                   to.Offset = from.Offset + (pattern_count/4);
1246 
              else
1247 
                   to.Offset = from.Offset + pattern_count;
1248 
              to.Space = from.Space; /* already translated */
1249 
              direction = TRUE; /* front to back */
1250 
              if (pattern_count > (INT32) 4) { /* is a multiple of 4 also */
1251 
                 fill_count = (INT32) (fill_count * (pattern_count/4));
1252 
                 pattern_count = (INT32) 4;
1253 
              };
1254 
              if ((UDIretval = UDICopy (from,
1255 
                             to,
1256 
                             fill_count,
1257 
                             (UDISizeT) pattern_count,
1258 
                             (UDICount *) &count_done,
1259 
                             direction)) <= TIPFAILURE) {
1260 
                  PrintErrorMessage (UDIretval);
1261 
                  return (FAILURE);
1262 
              } else if (UDIretval == SUCCESS) {
1263 
                 return(SUCCESS);
1264 
              } else {
1265 
                 udi_warning(UDIretval);
1266 
                 return(FAILURE);
1267 
              }
1268 
           };
1269 
           /* return if no more to copy */
1270 
           return(SUCCESS);
1271 
        } else {
1272 
           udi_warning(UDIretval);
1273 
           return(FAILURE);
1274 
        };
1275 
}
1276 
 
1277 
static UDIError
1278 
FillString(from, pattern, pattern_count, fill_count)
1279 
UDIResource     from;
1280 
UDIHostMemPtr   pattern;
1281 
UDISizeT        pattern_count;
1282 
UDICount        fill_count;
1283 
{
1284 
   UDICount     count_done;
1285 
   UDIBool      host_endian, direction;
1286 
   UDIError     UDIretval;
1287 
   UDIResource  to;
1288 
 
1289 
   host_endian = FALSE;
1290 
 
1291 
        if ((UDIretval = UDIWrite((UDIHostMemPtr) pattern,
1292 
                               from,
1293 
                               (UDICount) pattern_count,
1294 
                               (UDISizeT) 1,
1295 
                               (UDICount *) &count_done,
1296 
                               host_endian)) <= TIPFAILURE) {
1297 
           PrintErrorMessage (UDIretval);
1298 
           return (FAILURE);
1299 
        } else if (UDIretval == SUCCESS) {  /* do copy */
1300 
           fill_count = fill_count - 1; /* one less */
1301 
           if (fill_count > (INT32) 0) { /* do copy */
1302 
              to.Offset = from.Offset + pattern_count;
1303 
              to.Space = from.Space;
1304 
              direction = TRUE; /* front to back */
1305 
              if ((UDIretval = UDICopy (from,
1306 
                             to,
1307 
                             (UDICount) (fill_count*pattern_count),
1308 
                             (UDISizeT) 1,
1309 
                             (UDICount *) &count_done,
1310 
                             direction)) <= TIPFAILURE) {
1311 
                  PrintErrorMessage (UDIretval);
1312 
                  return (FAILURE);
1313 
              } else if (UDIretval == SUCCESS) {
1314 
                 return(SUCCESS);
1315 
              } else {
1316 
                 udi_warning(UDIretval);
1317 
                 return(FAILURE);
1318 
              }
1319 
           };
1320 
           /* return if no more to copy */
1321 
           return(SUCCESS);
1322 
        } else {
1323 
           udi_warning(UDIretval);
1324 
           return(FAILURE);
1325 
        };
1326 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.