gonzui


Format: Advanced Search

tkernel_2/monitor/cmdsvc/src/cmdsvc.hbare sourcepermlink (0.04 seconds)

Search this content:

    1: /*
    2:  *----------------------------------------------------------------------
    3:  *    T-Kernel 2.0 Software Package
    4:  *
    5:  *    Copyright 2011 by Ken Sakamura.
    6:  *    This software is distributed under the latest version of T-License 2.x.
    7:  *----------------------------------------------------------------------
    8:  *
    9:  *    Released by T-Engine Forum(http://www.t-engine.org/) at 2011/05/17.
   10:  *    Modified by T-Engine Forum at 2013/03/01.
   11:  *    Modified by TRON Forum(http://www.tron.org/) at 2015/06/01.
   12:  *
   13:  *----------------------------------------------------------------------
   14:  */
   15: 
   16: /*
   17:  *      cmdsvc.h
   18:  *
   19:  *       T-Monitor command / SVC common processing definitions
   20:  */
   21: 
   22: #include <tmonitor.h>
   23: #include <tm/tmonitor.h>
   24: 
   25: #if CPU_ARMv6
   26: #  include "armv6/cpudep.h"
   27: #endif
   28: 
   29: /* ======================================================================== */
   30: /*
   31:  *       Hardware-independent
   32:  */
   33: 
   34: #define L_LINE          256             /* number of characters per line */
   35: IMPORT  UB       lineBuf[L_LINE];      /* line buffer */
   36: 
   37: #define WRKBUF_SZ       1024          /* must be larger than or equal to 1024 */
   38: IMPORT  UB       wrkBuf[WRKBUF_SZ];    /* work buffer for various operations */
   39: 
   40: #define L_BPCMD         80             /* breakpooint command length */
   41: 
   42: IMPORT  W        errinfo;               /* error information */
   43: 
   44: /*
   45:  * display boot message
   46:  */
   47: IMPORT void dispTitle( void );
   48: 
   49: /*
   50:  * command execution
   51:  *       cmd     command string
   52:  *               if it is NULL, we are wainting for command input
   53:  *       fin     = 0 : execute cmd and then wait for command input
   54:  *               > 0 : execute cmd and return
   55:  *               < 0 : execute cmd and return (ignore execution such as GO,STEP, etc.)
   56:  *               if cmd = NULL, fin is ignored. (equivalent to fin = 0)
   57:  */
   58: IMPORT void procCommand( UB *cmd, W fin );
   59: 
   60: /*
   61:  * loading from serial line
   62:  *       proto   [P_XMODEM] | [P_SFORM]  (other protocols are ignored)
   63:  *               P_XMODEM   XMODEM
   64:  *               not specified  no control sequence
   65:  *               P_SFORM         S-Record format
   66:  *               not specficied            memory image (binary data)
   67:  *       addr    load address
   68:  *               In the case of P_SFORM, the initial ooad address is set to addr.
   69:  *               Loading is done with the above adjustment. If addr = 0, adjustment is not madem, but
   70:  *               load it to data address.
   71:  *       range   valid load range
   72:  *               range[0]  start address of the valid load range
   73:  *               range[1]  end address of the valid load range
   74:  *               range[2]  load offset
   75:  *               load offset is valid only when P_SFORM is used and addr = 0.
   76:  *               Its value is the sum of the load address added with the range[2] offset value.
   77:  *               This is where loading takes place.
   78:  *               range[0] and range[1] will return the final starting and loading address after the loading.
   79:  *
   80:  *               if range = NULL, below is assumed.
   81:  *               range[0] = 0x00000000
   82:  *               range[1] = 0xffffffff
   83:  *               range[2] = 0
   84:  *       return value error code
   85:  */
   86: IMPORT ER doLoading( W proto, UW addr, UW range[3] );
   87: 
   88: /* load option (LOAD commands, etc.) */
   89: #define P_XMODEM        0x20           /* XMODEM */
   90: #define P_TEXT          0x10            /* no protocol */
   91: #define P_SFORM         0x02           /* S-Format */
   92: #define P_MEMIMG        0x01           /* memory image */
   93: 
   94: /*
   95:  * Flash ROM disk write
   96:  *       blksz = 0 set up
   97:  *          Prepare writing to ROM disk and return the maximum ROM size
   98:  *          in sz (bytes).
   99:  *           Return the address to which the data to be written to ROM disk should be loaded.
  100:  *       blksz > 0 written
  101:  *           blksz       ROM disk block size
  102:  *           sz          number of written blocks
  103:  *       return value error code
  104:  */
  105: IMPORT W writeRda( UW blksz, UW *sz );
  106: 
  107: /*
  108:  * disk boot
  109:  *       devnm   device name (possibly with the partition number)
  110:  *               if it is NULL, the standard search order is used to look for a bootable device.
  111:  *       return value error code
  112:  */
  113: IMPORT ER bootDisk( const UB *devnm );
  114: 
  115: /*
  116:  * monitor service call
  117:  *       fno     function code
  118:  *       p1-p4 parameters
  119:  *       return value     return value of the service call
  120:  */
  121: IMPORT W procSVC( W fno, W p1, W p2, W p3, W p4 );
  122: 
  123: /* ======================================================================== */
  124: /*
  125:  *       Hardware-dependent
  126:  */
  127: 
  128: /*
  129:  * disassember
  130:  *       saddr   pass the address where the instruction to be disassembled is.
  131:  *               returns the adjusted address that points at the start of the instruction.
  132:  *       naddr  returns the address of the next instruction. (if it is NULL, value is not returned)
  133:  *       str     the buffer to store the disassembled instruction string (must be long enough)
  134:  *       return value error code
  135:  */
  136: IMPORT ER disAssemble( UW *saddr, UW *naddr, UB *str );
  137: 
  138: /*
  139:  * examine and obtain the breakpoint attribute
  140:  *       examine the breakpoint attribute string specified by `name', and if it is legal,
  141:  *       return its attribute code as return value.
  142:  *      In the case of illegal attribute string, return an error (E_BPATR).
  143:  */
  144: IMPORT W getBreakAtr( UB *name );
  145: 
  146: /*
  147:  * set breakpoint
  148:  *       addr    address where breakpoint is set
  149:  *       atr     breakpoint attribute
  150:  *       cmd     command that is to be executed at the breakpoint (valid only when cmdlen > 0)
  151:  *       cmdlen  cmd length
  152:  *       return value error code
  153:  */
  154: IMPORT ER setBreak( UW addr, W atr, UB *cmd, W cmdlen );
  155: 
  156: /*
  157:  * release breakpoint
  158:  *       addr    address where breakpoint is to be released
  159:  *               if it is 0, then release all breakpoints
  160:  *       return value error code
  161:  */
  162: IMPORT ER clearBreak( UW addr );
  163: 
  164: /*
  165:  * list all breakpoints
  166:  */
  167: IMPORT void dspBreak( void );
  168: 
  169: /*
  170:  * release breakpoint temporarily (monitor entry)
  171:  *       return value      if the current PC is not a breakpoint, returns 0.
  172:  *               if it is a breakpoint, returns non-zero value.
  173:  */
  174: IMPORT W resetBreak( UW vec );
  175: 
  176: /*
  177:  * set breakpoints (monitor exit)
  178:  */
  179: IMPORT void setupBreak( void );
  180: 
  181: /*
  182:  * forcibly stop trace
  183:  */
  184: IMPORT void stopTrace( void );
  185: 
  186: /*
  187:  * trace or normal execution
  188:  *       trace   0 : GO command
  189:  *               1 : STEP command
  190:  *               2 : NEXT command
  191:  *       pc      execution start address
  192:  *       par     in the case of GO
  193:  *                 tempoary breakpoint address (if 0, then no temporary breakpoionts)
  194:  *               in the case of STEP/NEXT
  195:  *                 number of steps (0 is regarded as 1)
  196:  *       return value error code
  197:  */
  198: IMPORT ER goTrace( W trace, UW pc, UW par );
  199: 
  200: /*
  201:  * break processing
  202:  *       bpflg   return the value returned by resetBreak() as is.
  203:  *       cmd     return the command to be executed at the breakpoint.
  204:  *       return value     0 : return monitor immediately and contineu executing the user program.
  205:  *                        1 : enter command processing of the monitor and execute cmd.
  206:  */
  207: IMPORT W procBreak( W bpflg, UB **cmd );
  208: 
  209: /*
  210:  * search register
  211:  *       Return the register number (0 and upward) for the register name `name'.
  212:  *       grp     0 : exclude group names from the search.
  213:  *               1 : include the group names in the search/
  214:  *       name is L_REGNM bytes long, and if the result is not long enough, the remaining part is filled with space.
  215:  *       L_REGNM is machine-dependent, but should be less than or equal to L_SYMBOL.
  216:  *       if the name is invalid (not found), return -1.
  217:  */
  218: IMPORT W searchRegister( UB *name, W grp );
  219: 
  220: /*
  221:  * obtain / set register value
  222:  *       regno   register number
  223:  *       val     value to set
  224:  *       return value obtained set value(if there is an error, 0).
  225:  *               *      set :  error code
  226:  */
  227: IMPORT UW getRegister( W regno );
  228: IMPORT ER setRegister( W regno, UW val );
  229: 
  230: /*
  231:  * display register value
  232:  *       display the register or register group specified by `regno'.
  233:  *       if regno < 0, thendisplay the default register group.
  234:  */
  235: IMPORT void dispRegister( W regno );
  236: 
  237: /*
  238:  * obtain / set the current PC register
  239:  */
  240: IMPORT UW   getCurPC( void );
  241: IMPORT void setCurPC( UW val );
  242: 
  243: /*
  244:  * prepare to execute the boot program
  245:  *       pass boot info to a boot program and start it from the address, `start'.
  246:  *
  247:  *      It means that we don't execute ROM kernel immediately, but we prepare so that upon return from the ordinary monitor,
  248:  *       it gets executed.
  249:  */
  250: IMPORT void setUpBoot( void *start, BootInfo *bootinfo );
  251: 
  252: /*
  253:  * Prepare ROM kernel execution
  254:  *      It means that we don't execute ROM kernel immediately, but we prepare so that upon return from the ordinary monitor,
  255:  *       it gets executed.
  256:  */
  257: IMPORT ER bootROM( void );
  258: 
  259: /*
  260:  * Initialize address check data (executed upon monitor entry)
  261:  */
  262: IMPORT void initChkAddr( void );
  263: 
  264: /*
  265:  * validate memory address
  266:  *      check whether access to area starting from logical address, addr, and has the length of len bytes,
  267:  *       return the corresponding physical address of addr in pa.
  268:  *       rw = 0 for read / rw = 1 for write is checked for the access right check.
  269:  *       Returns the length of accessible bytes for a consecutive region that starts from addr.
  270:  *       if addr is inaccessible, then the size for the accesible region is 0.
  271:  *       So, 0 is returned. In this case, error code is set to a global variable errinfo.
  272:  *       the address returned to pa is machine-depdenent, and may not be a physical address always.
  273:  */
  274: IMPORT W chkMemAddr( UW addr, UW *pa, W len, W rw );
  275: 
  276: /*
  277:  * validate I/O address
  278:  *      heck whether we can access a region from an I/O address (logical address in the case of memory mapped I/O), with the len bytes length,
  279:  *      the I/O address (physical address if memory mapped I/O is used) is returned
  280:  *       in pa.
  281:  *       Returns the length of accessible bytes for a consecutive region that starts from addr.
  282:  *       if addr is inaccessible, then the size for the accesible region is 0.
  283:  *       So, 0 is returned.
  284:  * * the address returned to pa is machine-depdenent, and, in the case of memory mapped I/O.
  285:  *         may not be a physical address always. if memory mapped I/O is not used,
  286:  *          generally speaking, pa will return addr unmodiifed.
  287:  */
  288: IMPORT W chkIOAddr( UW addr, UW *pa, W len );
  289: 
  290: /*
  291:  * Validate PC address
  292:  *      If addr is valid then return 0, otherwise return -1.
  293:  */
  294: IMPORT W invalidPC( UW addr );
  295: 
  296: /*
  297:  * Check whehter kill command can be executed
  298:  *       If it can be executed, return 0, and if not, return -1.
  299:  */
  300: IMPORT W isKillValid( void );
  301: 
  302: /*
  303:  * calling an external program
  304:  */
  305: IMPORT W callExtProg( FP entry );
  306: 
  307: /* ------------------------------------------------------------------------ */