source: examples-v2/micromonitor/diagnostics/monlib.c @ c304643

4.11
Last change on this file since c304643 was 9a0cbfd, checked in by Joel Sherrill <joel.sherrill@…>, on Aug 6, 2009 at 11:23:20 PM

2009-08-06 Joel Sherrill <joel.sherrill@…>

  • ChangeLog?, README, diagnostics/README, diagnostics/cfg.h, diagnostics/cli.h, diagnostics/cstart.c, diagnostics/main.c, diagnostics/makefile, diagnostics/monlib.c, diagnostics/monlib.h, diagnostics/tfs.h, umon/Makefile, umon/README, umon/test.c: New files.
  • Property mode set to 100755
File size: 23.1 KB
Line 
1/* monlib.c:
2 *      This file is part of the monitor code, but it is actually linked into
3 *      the application.  It is built with (but not linked with) the monitor,
4 *      then the monlib.o file is linked with the application.
5 *      The only requirement on the application is that it know where the address
6 *      of the monCom function is in the monitor's space. 
7 *      The monCom function will be accessible in some "well-known" way (processor
8 *      and platform dependent) so that this will not be a problem.
9 *
10 *      This monlib.c file is a replacement for the older mechanism that was
11 *      a bit more error-prone...  A table of function pointers existed at some
12 *      well-known location in the monitor, and the content of that table was
13 *      assumed to also be "well-known".  This new version only assumes that the
14 *      pointer to monCom is well-known; everything else will work based on the
15 *      fact that the monitor and application will share the monlib.h header
16 *      file.
17 *
18 *      General notice:
19 *      This code is part of a boot-monitor package developed as a generic base
20 *      platform for embedded system designs.  As such, it is likely to be
21 *      distributed to various projects beyond the control of the original
22 *      author.  Please notify the author of any enhancements made or bugs found
23 *      so that all may benefit from the changes.  In addition, notification back
24 *      to the author will allow the new user to pick up changes that may have
25 *      been made by other users after this version of the code was distributed.
26 *
27 *      Note1: the majority of this code was edited with 4-space tabs.
28 *      Note2: as more and more contributions are accepted, the term "author"
29 *                 is becoming a mis-representation of credit.
30 *
31 *      Original author:        Ed Sutter
32 *      Email:                          esutter@lucent.com
33 *      Phone:                          908-582-2351
34 */
35#include "monlib.h"
36
37static int              (*_tfsseek)(int,int,int);
38static int              (*_tfsgetline)(int,char *,int);
39static int              (*_tfsipmod)(char *,char *,int,int);
40static int              (*_tfsinit)(void);
41static int              (*_tfsadd)(char *,char *,char *,unsigned char *,int);
42static int              (*_tfsunlink)(char *);
43static int              (*_tfsrun)(char **,int);
44static int              (*_tfsread)(int,char *,int);
45static int              (*_tfswrite)(int,char *,int);
46static int              (*_tfsopen)(char *,long,char *);
47static int              (*_tfsclose)(int,char *);
48static int              (*_printf)();
49static int              (*_cprintf)();
50static int              (*_sprintf)();
51static int              (*_monrestart)(int);
52static int              (*_rputchar)(unsigned char c);
53static int              (*_getchar)(void);
54static int              (*_gotachar)(void);
55static int              (*_getbytes)(char *,int,int);
56static int              (*_addcommand)(struct monCommand *,char *);
57static int              (*_docommand)(char *,int);
58static int              (*_getline)(char *,int,int);
59static int              (*_tfsfstat)(char *,struct tfshdr *);
60static int              (*_tfseof)(int);
61static int              (*_decompress)(char *,int,char *);
62static int              (*_tfstruncate)(int,long);
63static int              (*_heapextend)(char *,int);
64static int              (*_tfslink)(char *,char *);
65static int              (*_pcicfgwrite)(int,int,int,int,int,unsigned long);
66static int              (*_i2cwrite)(int,int,unsigned char *,int);
67static int              (*_i2cread)(int,int,unsigned char *,int);
68static int              (*_flashwrite)(char *,char *,int);
69static int              (*_flasherase)(int);
70static int              (*_flashinfo)(int,int *,char **);
71static int              (*_flashoverride)(void *,int,int);
72static int              (*_sendenet)(char *,int);
73static int              (*_recvenet)(char *,int);
74static int              (*_printpkt)(char *,int,int);
75static int              (*_setenv)(char *,char *);
76static int              (*_watchdog)(void);
77static int              (*_timeofday)(int,void *);
78static int              (*_montimer)(int cmd, void *arg);
79
80static char             *(*_getenv)(char *);
81static char             *(*_version)(void);
82static char             *(*_getenvp)(void);
83#ifdef MALLOC_DEBUG
84static char             *(*_malloc)(int,char *,int);
85static char             *(*_realloc)(char *buf,int,char *,int);
86#else
87static char             *(*_malloc)(int);
88static char             *(*_realloc)(char *,int);
89#endif
90static char             *(*_getsym)(char *,char *,int);
91
92static void             (*_intsrestore)(unsigned long);
93static void             (*_appexit)(int);
94static void             (*_free)(char *);
95static void             (*_getargv)(int *,char ***);
96static void             (*_profiler)(void *);
97static void             (*_bbc)(char *,int);
98static void             (*_memtrace)();
99static void             (*_appwarmstart)(unsigned long);
100static void             (*_mondelay)(long);
101static void             (*_printmem)(char *,int,int);
102
103static long             (*_tfsctrl)(int,long,long);
104static long             (*_tfstell)(int);
105static long             (*_portcmd)(int,void *);
106
107static struct   tfshdr *(*_tfsnext)(struct tfshdr *);
108static struct   tfshdr *(*_tfsstat)(char *);
109
110static unsigned long    (*_i2cctrl)(int,int,unsigned long,unsigned long);
111static unsigned long    (*_pcicfgread)(int,int,int,int,int);
112static unsigned long    (*_pcictrl)(int,int,unsigned long,unsigned long);
113static unsigned long    (*_crc32)(unsigned char *,unsigned long);
114static unsigned long    (*_intsoff)(void);
115static unsigned long    (*_assign_handler)(long,unsigned long,unsigned long);
116
117static unsigned short   (*_xcrc16)(unsigned char *,unsigned long);
118
119
120static void (*_monlock)(void);
121static void (*_monunlock)(void);
122static int      (*_moncom)(int,void *,void *, void *);
123
124/**************************************************************************
125 *
126 * The following macros support the default monitor lock/unlock mechanism when
127 * they point to monLock and monUnlock.  If something other than the default
128 * is to be used, then simply redefine them here.  Refer to the monitor
129 * app note that discusses multi-tasking access to the monitor API for more
130 * information.
131 *
132 * TFS_MONLOCK/UNLOCK:
133 * Lock/unlock for functions that access TFS flash space:
134 */
135#define TFS_MONLOCK                     monLock
136#define TFS_MONUNLOCK           monUnlock
137
138/* ENV_MONLOCK/UNLOCK:
139 * Lock/unlock for functions that access monitor shell variables:
140 */
141#define ENV_MONLOCK                     monLock
142#define ENV_MONUNLOCK           monUnlock
143
144/* CONSOLE_MONLOCK/UNLOCK:
145 * Lock/unlock for functions in the monitor that deal with console output.
146 */
147#define CONSOLE_MONLOCK         monLock
148#define CONSOLE_MONUNLOCK       monUnlock
149
150/* HEAP_MONLOCK/UNLOCK:
151 * Lock/unlock for functions in the monitor that deal with the heap.
152 */
153#define HEAP_MONLOCK            monLock
154#define HEAP_MONUNLOCK          monUnlock
155
156/* BLOCKING_MONLOCK/UNLOCK:
157 * Lock/unlock for functions in the monitor that block waiting for
158 * console input.
159 */
160#define BLOCKING_MONLOCK        monLock
161#define BLOCKING_MONUNLOCK      monUnlock
162
163/* GENERIC_MONLOCK/UNLOCK:
164 * Lock/unlock for all functions not covered by the above macros.
165 */
166#define GENERIC_MONLOCK         monLock
167#define GENERIC_MONUNLOCK       monUnlock
168
169/**************************************************************************
170 *
171 * monConnect():
172 *      This must be the first call by the application code to talk to the
173 *      monitor.  It is expecting three incoming function pointers:
174 *
175 *      mon:    Points to the monitor's _moncom function;
176 *                      This is a "well-known" address because the monitor and
177 *                      application code (two separately linked binaries) must
178 *                      know it.
179 *      lock:   Points to a function in the application code that will be
180 *                      used by the monitor as a lock-out function (some kind of
181 *                      semaphore in the application). 
182 *      unlock: Points to a function in the application code that will be
183 *                      used by the monitor as an un-lock-out function (undo whatever
184 *                      lock-out mechanism was done by lock).
185 */
186int
187monConnect(int (*mon)(int,void *,void *,void *),
188        void (*lock)(void), void (*unlock)(void))
189{
190        int rc = 0;
191
192        /* Assign incoming lock and unlock functions... */
193        _monlock = lock;
194        _monunlock = unlock;
195
196        /* If the mon pointer is non-zero, then make the mon_ connections... */
197        if (mon) {
198
199                _moncom = mon;
200
201                /* Make the connections between "mon_" functions that are                       */
202                /* symbolically accessible by the application and the corresponding     */
203                /* functions that exists in the monitor.                                                        */
204                rc += _moncom(GETMONFUNC_PUTCHAR,&_rputchar,0,0);
205                rc += _moncom(GETMONFUNC_GETCHAR,&_getchar,0,0);
206                rc += _moncom(GETMONFUNC_GOTACHAR,&_gotachar,0,0);
207                rc += _moncom(GETMONFUNC_GETBYTES,&_getbytes,0,0);
208                rc += _moncom(GETMONFUNC_PRINTF,&_printf,0,0);
209                rc += _moncom(GETMONFUNC_CPRINTF,&_cprintf,0,0);
210                rc += _moncom(GETMONFUNC_SPRINTF,&_sprintf,0,0);
211                rc += _moncom(GETMONFUNC_RESTART,&_monrestart,0,0);
212                rc += _moncom(GETMONFUNC_GETENV,&_getenv,0,0);
213                rc += _moncom(GETMONFUNC_SETENV,&_setenv,0,0);
214                rc += _moncom(GETMONFUNC_TFSINIT,&_tfsinit,0,0);
215                rc += _moncom(GETMONFUNC_TFSADD,&_tfsadd,0,0);
216                rc += _moncom(GETMONFUNC_TFSUNLINK,&_tfsunlink,0,0);
217                rc += _moncom(GETMONFUNC_TFSRUN,&_tfsrun,0,0);
218                rc += _moncom(GETMONFUNC_TFSNEXT,&_tfsnext,0,0);
219                rc += _moncom(GETMONFUNC_TFSSTAT,&_tfsstat,0,0);
220                rc += _moncom(GETMONFUNC_TFSREAD,&_tfsread,0,0);
221                rc += _moncom(GETMONFUNC_TFSWRITE,&_tfswrite,0,0);
222                rc += _moncom(GETMONFUNC_TFSOPEN,&_tfsopen,0,0);
223                rc += _moncom(GETMONFUNC_TFSCLOSE,&_tfsclose,0,0);
224                rc += _moncom(GETMONFUNC_TFSSEEK,&_tfsseek,0,0);
225                rc += _moncom(GETMONFUNC_TFSGETLINE,&_tfsgetline,0,0);
226                rc += _moncom(GETMONFUNC_TFSIPMOD,&_tfsipmod,0,0);
227                rc += _moncom(GETMONFUNC_TFSCTRL,&_tfsctrl,0,0);
228                rc += _moncom(GETMONFUNC_ADDCOMMAND,&_addcommand,0,0);
229                rc += _moncom(GETMONFUNC_DOCOMMAND,&_docommand,0,0);
230                rc += _moncom(GETMONFUNC_GETARGV,&_getargv,0,0);
231                rc += _moncom(GETMONFUNC_CRC16,&_xcrc16,0,0);
232                rc += _moncom(GETMONFUNC_CRC32,&_crc32,0,0);
233                rc += _moncom(GETMONFUNC_INTSOFF,&_intsoff,0,0);
234                rc += _moncom(GETMONFUNC_INTSRESTORE,&_intsrestore,0,0);
235                rc += _moncom(GETMONFUNC_APPEXIT,&_appexit,0,0);
236                rc += _moncom(GETMONFUNC_MALLOC,&_malloc,0,0);
237                rc += _moncom(GETMONFUNC_FREE,&_free,0,0);
238                rc += _moncom(GETMONFUNC_GETLINE,&_getline,0,0);
239                rc += _moncom(GETMONFUNC_TFSFSTAT,&_tfsfstat,0,0);
240                rc += _moncom(GETMONFUNC_TFSEOF,&_tfseof,0,0);
241                rc += _moncom(GETMONFUNC_DECOMPRESS,&_decompress,0,0);
242                rc += _moncom(GETMONFUNC_TFSTRUNCATE,&_tfstruncate,0,0);
243                rc += _moncom(GETMONFUNC_HEAPXTEND,&_heapextend,0,0);
244                rc += _moncom(GETMONFUNC_PROFILER,&_profiler,0,0);
245                rc += _moncom(GETMONFUNC_TFSLINK,&_tfslink,0,0);
246                rc += _moncom(GETMONFUNC_BBC,&_bbc,0,0);
247                rc += _moncom(GETMONFUNC_MEMTRACE,&_memtrace,0,0);
248                rc += _moncom(GETMONFUNC_TFSTELL,&_tfstell,0,0);
249                rc += _moncom(GETMONFUNC_VERSION,&_version,0,0);
250                rc += _moncom(GETMONFUNC_WARMSTART,&_appwarmstart,0,0);
251                rc += _moncom(GETMONFUNC_PCICFGREAD,&_pcicfgread,0,0);
252                rc += _moncom(GETMONFUNC_PCICFGWRITE,&_pcicfgwrite,0,0);
253                rc += _moncom(GETMONFUNC_PCICONTROL,&_pcictrl,0,0);
254                rc += _moncom(GETMONFUNC_I2CREAD,&_i2cread,0,0);
255                rc += _moncom(GETMONFUNC_I2CWRITE,&_i2cwrite,0,0);
256                rc += _moncom(GETMONFUNC_I2CCONTROL,&_i2cctrl,0,0);
257                rc += _moncom(GETMONFUNC_MONDELAY,&_mondelay,0,0);
258                rc += _moncom(GETMONFUNC_GETENVP,&_getenvp,0,0);
259                rc += _moncom(GETMONFUNC_REALLOC,&_realloc,0,0);
260                rc += _moncom(GETMONFUNC_SENDENETPKT,&_sendenet,0,0);
261                rc += _moncom(GETMONFUNC_RECVENETPKT,&_recvenet,0,0);
262                rc += _moncom(GETMONFUNC_GETSYM,&_getsym,0,0);
263                rc += _moncom(GETMONFUNC_PRINTPKT,&_printpkt,0,0);
264                rc += _moncom(GETMONFUNC_FLASHWRITE,&_flashwrite,0,0);
265                rc += _moncom(GETMONFUNC_FLASHERASE,&_flasherase,0,0);
266                rc += _moncom(GETMONFUNC_FLASHINFO,&_flashinfo,0,0);
267                rc += _moncom(GETMONFUNC_ASSIGNHDLR,&_assign_handler,0,0);
268                rc += _moncom(GETMONFUNC_WATCHDOG,&_watchdog,0,0);
269                rc += _moncom(GETMONFUNC_PRINTMEM,&_printmem,0,0);
270                rc += _moncom(GETMONFUNC_PORTCMD,&_portcmd,0,0);
271                rc += _moncom(GETMONFUNC_TIMEOFDAY,&_timeofday,0,0);
272                rc += _moncom(GETMONFUNC_TIMER,&_montimer,0,0);
273                rc += _moncom(GETMONFUNC_FLASHOVRRD,&_flashoverride,0,0);
274        }
275        return(rc);
276}
277
278/* ignorelock:
279 * Used as a back-door to disable the monLock()/monUnlock() stuff.
280 * This is useful if the application CLI falls through to the monitor's
281 * CLI and you are using the "call" command in the monitor to execute some
282 * function that has a mon_xxx function in it.  In this case, the fact that
283 * the application has fallen through to the monitor means that the lock
284 * is already active, so when the function tries to call some other mon_xxx
285 * function it won't be able to because of the lock already being set.
286 *
287 * With these functions in the application space, the user can do the
288 * following:
289 *      call %DisableLock
290 *  call %Func_with_monXXX_in_it
291 *  call %EnableLock
292 *
293 * Note that this is NOT to be used by application code, it is simply a
294 * back-door mechanism to allow "call" from the CLI to invoke functions
295 * that have mon_XXX functionality in them.
296 */
297static int ignorelock = 0;
298
299void
300DisableMonLock(void)
301{
302        ignorelock = 2;
303}
304
305void
306EnableMonLock(void)
307{
308        ignorelock = 0;
309}
310
311/* monLock() & monUnlock():
312 * Used by all of the wrapper functions below this point to call
313 * the function pointed to by _monlock & _monunlock function pointers
314 * (if set).
315 * These functions must test both the function pointer and the state
316 * of the ignorelock variable.  The function DisableMonLock() sets the
317 * ignorelock variable to 2 because it is being executed through "call"
318 * which means that the lock is active. 
319 */
320static void
321monLock()
322{
323        if (_monlock) {
324                switch(ignorelock) {
325                        case 1:
326                                break;
327                        case 2:
328                                ignorelock--;
329                                break;
330                        default:
331                                _monlock();
332                                break;
333                }
334        }
335}
336
337static void
338monUnlock()
339{
340        if (_monunlock) {
341                switch(ignorelock) {
342                        case 1:
343                                break;
344                        case 2:
345                                ignorelock--;
346                        default:
347                                _monunlock();
348                                break;
349                }
350        }
351}
352
353int
354mon_com(int cmd, void *arg1, void *arg2, void *arg3)
355{
356        int     ret;
357       
358        GENERIC_MONLOCK();
359        ret = _moncom(cmd,arg1,arg2,arg3);
360        GENERIC_MONUNLOCK();
361        return(ret);
362}
363
364int
365mon_putchar(char c)
366{
367        int     ret;
368       
369        CONSOLE_MONLOCK();
370        ret = _rputchar(c);
371        CONSOLE_MONUNLOCK();
372        return(ret);
373}
374
375int
376mon_getchar(void)
377{
378        int     ret;
379
380        BLOCKING_MONLOCK();
381        ret = _getchar();
382        BLOCKING_MONUNLOCK();
383        return(ret);
384}
385
386int
387mon_gotachar(void)
388{
389        int     ret;
390
391        GENERIC_MONLOCK();
392        ret = _gotachar();
393        GENERIC_MONUNLOCK();
394        return(ret);
395}
396
397int
398mon_getbytes(char *buf,int cnt,int block)
399{
400        int     ret;
401
402        BLOCKING_MONLOCK();
403        ret = _getbytes(buf,cnt,block);
404        BLOCKING_MONUNLOCK();
405        return(ret);
406}
407
408int
409mon_printf(fmt,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12)
410char *fmt;
411int a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12;
412{
413        int     ret;
414
415        CONSOLE_MONLOCK();
416        ret = _printf(fmt,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12);
417        CONSOLE_MONUNLOCK();
418        return(ret);
419}
420
421int
422mon_cprintf(fmt,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12)
423char *fmt;
424int a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12;
425{
426        int     ret;
427
428        CONSOLE_MONLOCK();
429        ret = _cprintf(fmt,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12);
430        CONSOLE_MONUNLOCK();
431        return(ret);
432}
433
434int
435mon_sprintf(buf,fmt,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12)
436char *fmt, *buf;
437int a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12;
438{
439        int     ret;
440
441        GENERIC_MONLOCK();
442        ret = _sprintf(buf,fmt,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12);
443        GENERIC_MONUNLOCK();
444        return(ret);
445}
446
447int
448mon_restart(int val)
449{
450        int     ret;
451
452        GENERIC_MONLOCK();
453        ret = _monrestart(val);
454        GENERIC_MONUNLOCK();
455        return(ret);
456}
457
458char *
459mon_getenvp(void)
460{
461        char *ret;
462
463        ENV_MONLOCK();
464        ret = _getenvp();
465        ENV_MONUNLOCK();
466        return(ret);
467}
468
469char *
470mon_getenv(char *name)
471{
472        char *ret;
473
474        ENV_MONLOCK();
475        ret = _getenv(name);
476        ENV_MONUNLOCK();
477        return(ret);
478}
479
480int
481mon_setenv(char *name,char *val)
482{
483        int ret;
484
485        ENV_MONLOCK();
486        ret = _setenv(name,val);
487        ENV_MONUNLOCK();
488        return(ret);
489}
490
491char *
492mon_getsym(char *name,char *buf, int bufsize)
493{
494        char *ret;
495
496        ENV_MONLOCK();
497        ret = _getsym(name,buf,bufsize);
498        ENV_MONUNLOCK();
499        return(ret);
500}
501
502int
503mon_tfsinit(void)
504{
505        int     ret;
506
507        TFS_MONLOCK();
508        ret = _tfsinit();
509        TFS_MONUNLOCK();
510        return(ret);
511}
512
513int
514mon_tfsadd(char *name, char *info, char *flags, unsigned char *src, int size)
515{
516        int     ret;
517
518        TFS_MONLOCK();
519        ret = _tfsadd(name,info,flags,src,size);
520        TFS_MONUNLOCK();
521        return(ret);
522}
523
524int
525mon_tfslink(char *src, char *target)
526{
527        int     ret;
528
529        TFS_MONLOCK();
530        ret = _tfslink(src,target);
531        TFS_MONUNLOCK();
532        return(ret);
533}
534
535int
536mon_tfsunlink(char *name)
537{
538        int     ret;
539
540        TFS_MONLOCK();
541        ret = _tfsunlink(name);
542        TFS_MONUNLOCK();
543        return(ret);
544}
545
546int
547mon_tfsrun(char **name,int verbose)
548{
549        int     ret;
550
551        TFS_MONLOCK();
552        ret = _tfsrun(name,verbose);
553        TFS_MONUNLOCK();
554        return(ret);
555}
556
557struct tfshdr *
558mon_tfsnext(struct tfshdr *fp)
559{
560        struct tfshdr *ret;
561
562        TFS_MONLOCK();
563        ret = _tfsnext(fp);
564        TFS_MONUNLOCK();
565        return(ret);
566}
567
568int
569mon_tfstruncate(int tfd, long len)
570{
571        int ret;
572
573        TFS_MONLOCK();
574        ret = _tfstruncate(tfd,len);
575        TFS_MONUNLOCK();
576        return(ret);
577}
578
579int
580mon_tfseof(int tfd)
581{
582        int ret;
583
584        TFS_MONLOCK();
585        ret = _tfseof(tfd);
586        TFS_MONUNLOCK();
587        return(ret);
588}
589
590int
591mon_tfsfstat(char *name, struct tfshdr *fp)
592{
593        int ret;
594
595        TFS_MONLOCK();
596        ret = _tfsfstat(name,fp);
597        TFS_MONUNLOCK();
598        return(ret);
599}
600
601struct tfshdr *
602mon_tfsstat(char *name)
603{
604        struct tfshdr *ret;
605
606        TFS_MONLOCK();
607        ret = _tfsstat(name);
608        TFS_MONUNLOCK();
609        return(ret);
610}
611
612int
613mon_tfsread(int fd, char *buf, int cnt)
614{
615        int     ret;
616
617        TFS_MONLOCK();
618        ret = _tfsread(fd,buf,cnt);
619        TFS_MONUNLOCK();
620        return(ret);
621}
622
623int
624mon_tfswrite(int fd, char *buf, int cnt)
625{
626        int     ret;
627
628        TFS_MONLOCK();
629        ret = _tfswrite(fd,buf,cnt);
630        TFS_MONUNLOCK();
631        return(ret);
632}
633
634int
635mon_tfsopen(char *file,long flagmode,char *buf)
636{
637        int     ret;
638
639        TFS_MONLOCK();
640        ret = _tfsopen(file,flagmode,buf);
641        TFS_MONUNLOCK();
642        return(ret);
643}
644
645int
646mon_tfsclose(int fd,char *info)
647{
648        int     ret;
649
650        TFS_MONLOCK();
651        ret = _tfsclose(fd,info);
652        TFS_MONUNLOCK();
653        return(ret);
654}
655
656int
657mon_tfsseek(int fd, int offset, int whence)
658{
659        int     ret;
660
661        TFS_MONLOCK();
662        ret = _tfsseek(fd,offset,whence);
663        TFS_MONUNLOCK();
664        return(ret);
665}
666
667int
668mon_tfsgetline(int fd,char *bp,int max)
669{
670        int     ret;
671
672        TFS_MONLOCK();
673        ret = _tfsgetline(fd,bp,max);
674        TFS_MONUNLOCK();
675        return(ret);
676}
677
678int
679mon_tfsipmod(char *name,char *buf,int offset,int size)
680{
681        int     ret;
682
683        TFS_MONLOCK();
684        ret = _tfsipmod(name,buf,offset,size);
685        TFS_MONUNLOCK();
686        return(ret);
687}
688
689long
690mon_tfsctrl(int rqst,long arg1,long arg2)
691{
692        long    ret;
693
694        TFS_MONLOCK();
695        ret = _tfsctrl(rqst,arg1,arg2);
696        TFS_MONUNLOCK();
697        return(ret);
698}
699
700long
701mon_tfstell(int fd)
702{
703        long    ret;
704
705        TFS_MONLOCK();
706        ret = _tfstell(fd);
707        TFS_MONUNLOCK();
708        return(ret);
709}
710
711int
712mon_addcommand(struct monCommand *cmdlist, char *cmdlvl)
713{
714        int     ret;
715
716        GENERIC_MONLOCK();
717        ret = _addcommand(cmdlist,cmdlvl);
718        GENERIC_MONUNLOCK();
719        return(ret);
720}
721
722int
723mon_docommand(char *cmdline,int verbose)
724{
725        int     ret;
726
727        GENERIC_MONLOCK();
728        ret = _docommand(cmdline,verbose);
729        GENERIC_MONUNLOCK();
730        return(ret);
731}
732
733void
734mon_getargv(int *argc,char ***argv)
735{
736        GENERIC_MONLOCK();
737        _getargv(argc,argv);
738        GENERIC_MONUNLOCK();
739}
740
741unsigned short
742mon_xcrc16(char *buf,long nbytes)
743{
744        unsigned short ret;
745
746        GENERIC_MONLOCK();
747        ret = _xcrc16((unsigned char *)buf,nbytes);
748        GENERIC_MONUNLOCK();
749        return(ret);
750}
751
752unsigned long
753mon_intsoff(void)
754{
755        unsigned long ret;
756
757        GENERIC_MONLOCK();
758        ret = _intsoff();
759        GENERIC_MONUNLOCK();
760        return(ret);
761}
762
763void
764mon_intsrestore(unsigned long msr)
765{
766        GENERIC_MONLOCK();
767        _intsrestore(msr);
768        GENERIC_MONUNLOCK();
769}
770
771void
772mon_appexit(int val)
773{
774        GENERIC_MONLOCK();
775        _appexit(val);
776        GENERIC_MONUNLOCK();
777}
778
779#ifdef MALLOC_DEBUG
780char *
781mon_malloc(int size,char *fname,int fline)
782{
783        char *ret;
784
785        HEAP_MONLOCK();
786        ret = _malloc(size,fname,fline);
787        HEAP_MONUNLOCK();
788        return(ret);
789}
790
791char *
792mon_realloc(char *buf, int size, char *fname, int fline)
793{
794        char *ret;
795
796        HEAP_MONLOCK();
797        ret = _realloc(buf,size, fname, fline);
798        HEAP_MONUNLOCK();
799        return(ret);
800}
801#else
802char *
803mon_malloc(int size)
804{
805        char *ret;
806
807        HEAP_MONLOCK();
808        ret = _malloc(size);
809        HEAP_MONUNLOCK();
810        return(ret);
811}
812
813char *
814mon_realloc(char *buf, int size)
815{
816        char *ret;
817
818        HEAP_MONLOCK();
819        ret = _realloc(buf,size);
820        HEAP_MONUNLOCK();
821        return(ret);
822}
823#endif
824
825void
826mon_free(char *cp)
827{
828        HEAP_MONLOCK();
829        _free(cp);
830        HEAP_MONUNLOCK();
831}
832
833int
834mon_getline(char *buf,int max,int ledit)
835{
836        int     ret;
837
838        BLOCKING_MONLOCK();
839        ret = _getline(buf,max,ledit);
840        BLOCKING_MONUNLOCK();
841        return(ret);
842}
843
844int
845mon_decompress(char *src,int srcsize,char *dest)
846{
847        int     ret;
848
849        GENERIC_MONLOCK();
850        ret = _decompress(src,srcsize,dest);
851        GENERIC_MONUNLOCK();
852        return(ret);
853}
854
855int
856mon_heapextend(char *base,int size)
857{
858        int     ret;
859
860        GENERIC_MONLOCK();
861        ret = _heapextend(base,size);
862        GENERIC_MONUNLOCK();
863        return(ret);
864}
865
866void
867mon_bbc(char *filename, int lineno)
868{
869        _bbc(filename, lineno);
870}
871
872void
873mon_profiler(void *pdata)
874{
875        _profiler(pdata);
876}
877
878void
879mon_memtrace(fmt,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12)
880char *fmt;
881int a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12;
882{
883        _memtrace(fmt,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12);
884}
885
886char *
887mon_version(void)
888{
889        char *ret;
890
891        GENERIC_MONLOCK();
892        ret = _version();
893        GENERIC_MONUNLOCK();
894        return(ret);
895}
896
897void
898mon_warmstart(unsigned long mask)
899{
900        GENERIC_MONLOCK();
901        _appwarmstart(mask);
902        GENERIC_MONUNLOCK();
903}
904
905int
906mon_pcicfgwrite(int interface,int bus,int dev,int func,int reg,
907        unsigned long val)
908{
909        int     retval;
910
911        GENERIC_MONLOCK();
912        retval = _pcicfgwrite(interface,bus,dev,func,reg,val);
913        GENERIC_MONUNLOCK();
914        return(retval);
915}
916
917unsigned long
918mon_pcicfgread(int interface,int bus,int dev, int func,int reg)
919{
920        unsigned long retval;
921
922        GENERIC_MONLOCK();
923        retval = _pcicfgread(interface,bus,dev,func,reg);
924        GENERIC_MONUNLOCK();
925        return(retval);
926}
927
928unsigned long
929mon_pcictrl(int interface, int cmd, unsigned long arg1, unsigned long arg2)
930{
931        unsigned long val;
932
933        GENERIC_MONLOCK();
934        val = _pcictrl(interface,cmd,arg1,arg2);
935        GENERIC_MONUNLOCK();
936        return(val);
937}
938
939unsigned long
940mon_i2cctrl(int interface, int cmd, unsigned long arg1, unsigned long arg2)
941{
942        unsigned long val;
943
944        GENERIC_MONLOCK();
945        val = _i2cctrl(interface,cmd,arg1,arg2);
946        GENERIC_MONUNLOCK();
947        return(val);
948}
949
950int
951mon_i2cwrite(int interface, int bigaddr, unsigned char *data, int len)
952{
953        int     val;
954
955        GENERIC_MONLOCK();
956        val = _i2cwrite(interface,bigaddr,data,len);
957        GENERIC_MONUNLOCK();
958        return(val);
959}
960
961int
962mon_i2cread(int interface, int bigaddr, unsigned char *data, int len)
963{
964        int     val;
965
966        GENERIC_MONLOCK();
967        val = _i2cread(interface,bigaddr,data,len);
968        GENERIC_MONUNLOCK();
969        return(val);
970}
971
972void
973mon_delay(long msec)
974{
975        GENERIC_MONLOCK();
976        _mondelay(msec);
977        GENERIC_MONUNLOCK();
978}
979
980int
981mon_timer(int cmd, void *arg)
982{
983        int ret;
984
985        GENERIC_MONLOCK();
986        ret = _montimer(cmd, arg);
987        GENERIC_MONUNLOCK();
988        return(ret);
989}
990
991int
992mon_sendenetpkt(char *pkt,int size)
993{
994        int     ret;
995
996        GENERIC_MONLOCK();
997        ret = _sendenet(pkt,size);
998        GENERIC_MONUNLOCK();
999        return(ret);
1000}
1001
1002int
1003mon_recvenetpkt(char *pkt,int size)
1004{
1005        int     ret;
1006
1007        GENERIC_MONLOCK();
1008        ret = _recvenet(pkt,size);
1009        GENERIC_MONUNLOCK();
1010        return(ret);
1011}
1012
1013void
1014mon_printpkt(char *buf,int size, int incoming)
1015{
1016        GENERIC_MONLOCK();
1017        _printpkt(buf,size,incoming);
1018        GENERIC_MONUNLOCK();
1019}
1020
1021int
1022mon_flashoverride(void *flashinfo,int get,int bank)
1023{
1024        int     ret;
1025
1026        TFS_MONLOCK();
1027        ret = _flashoverride(flashinfo,get,bank);
1028        TFS_MONUNLOCK();
1029        return(ret);
1030}
1031
1032int
1033mon_flashwrite(char *dest,char *src,int bytecnt)
1034{
1035        int     ret;
1036
1037        TFS_MONLOCK();
1038        ret = _flashwrite(dest,src,bytecnt);
1039        TFS_MONUNLOCK();
1040        return(ret);
1041}
1042
1043int
1044mon_flasherase(int snum)
1045{
1046        int     ret;
1047
1048        TFS_MONLOCK();
1049        ret = _flasherase(snum);
1050        TFS_MONUNLOCK();
1051        return(ret);
1052}
1053
1054int
1055mon_flashinfo(int snum, int *size, char **base)
1056{
1057        int     ret;
1058
1059        TFS_MONLOCK();
1060        ret = _flashinfo(snum,size,base);
1061        TFS_MONUNLOCK();
1062        return(ret);
1063}
1064
1065unsigned long
1066mon_assignhandler(long hnum, unsigned long arg1, unsigned long arg2)
1067{
1068        int     ret;
1069
1070        GENERIC_MONLOCK();
1071        ret = _assign_handler(hnum,arg1,arg2);
1072        GENERIC_MONUNLOCK();
1073        return(ret);
1074}
1075
1076int
1077mon_watchdog(void)
1078{
1079        int     ret;
1080
1081        GENERIC_MONLOCK();
1082        ret = _watchdog();
1083        GENERIC_MONUNLOCK();
1084        return(ret);
1085}
1086
1087void
1088mon_printmem(char *mem, int size, int ascii)
1089{
1090        GENERIC_MONLOCK();
1091        _printmem(mem,size,ascii);
1092        GENERIC_MONUNLOCK();
1093}
1094
1095long
1096mon_portcmd(int cmd, void *arg)
1097{
1098        long ret;
1099
1100        GENERIC_MONLOCK();
1101        ret = _portcmd(cmd,arg);
1102        GENERIC_MONUNLOCK();
1103        return(ret);
1104}
1105
1106int
1107mon_timeofday(int cmd, void *arg)
1108{
1109        int ret;
1110
1111        GENERIC_MONLOCK();
1112        ret = _timeofday(cmd,arg);
1113        GENERIC_MONUNLOCK();
1114        return(ret);
1115}
Note: See TracBrowser for help on using the repository browser.