| 1 | 578 | markom | static char _[] = "@(#)help.c   5.22 93/08/23 15:30:33, 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 |  |  |  **       This file contains the help screens for the monitor.
 | 
      
         | 30 |  |  |  *****************************************************************************
 | 
      
         | 31 |  |  |  */
 | 
      
         | 32 |  |  |  
 | 
      
         | 33 |  |  | /*
 | 
      
         | 34 |  |  | ** Main help
 | 
      
         | 35 |  |  | */
 | 
      
         | 36 |  |  |  
 | 
      
         | 37 |  |  | char *help_main[] = {
 | 
      
         | 38 |  |  |  
 | 
      
         | 39 |  |  | "Use 'h <letter>' for individual command help",
 | 
      
         | 40 |  |  | " ",
 | 
      
         | 41 |  |  | " --------------------- MONDFE Monitor Commands -----------------------------",
 | 
      
         | 42 |  |  | " a - Assemble Instruction        | b,b050,bc - Set/Clear/Display Breakpoint",
 | 
      
         | 43 |  |  | " c - Print Configuration         | caps - DFE and TIP Capabilities",
 | 
      
         | 44 |  |  | " cp - Create UDI Process         | con - Connect to a UDI Debug Session",
 | 
      
         | 45 |  |  | " ch0 - 29K Terminal Control      | d,dw,dh,db,df,dd - Dump Memory/Registers",
 | 
      
         | 46 |  |  | " dp - Destroy UDI Process        | disc - Temporarily Disconnect UDI Session",
 | 
      
         | 47 |  |  | " ex - Exit UDI Session           | esc - Escape to Host Operating System",
 | 
      
         | 48 |  |  | " eon - Turn Echo Mode ON         | eoff - Turn Echo Mode OFF",
 | 
      
         | 49 |  |  | " g - Start/Resume Execution      | f,fw,fh,ff,fd,fs - Fill Memory/Registers",
 | 
      
         | 50 |  |  | " h - Help Command                | init - Initialize Current UDI Process",
 | 
      
         | 51 |  |  | " ix,il - Display Am2903X Cache   | k - Kill Running Program on 29K Target",
 | 
      
         | 52 |  |  | " logon - Turn ON log mode        | logoff - Turn OFF log mode",
 | 
      
         | 53 |  |  | " l - List/Disassemble Memory     | m - Move Data to Memory/Registers",
 | 
      
         | 54 |  |  | " pid - Set UDI Process ID        | q - Quit mondfe",
 | 
      
         | 55 |  |  | " qon - Turn Quiet Mode ON        | qoff - Turn Quiet Mode OFF",
 | 
      
         | 56 |  |  | " sid - Set UDI Session ID        | r - Reset (software reset) 29K Target",
 | 
      
         | 57 |  |  | " t - Trace/Single Step Execution | s,sw,sh,sb,sf,sd - Set Memory/Registers",
 | 
      
         | 58 |  |  | " ver - Montip Version Command    | tip - Montip Transparent Mode Command",
 | 
      
         | 59 |  |  | " y - Yank/Download COFF File     | xp - Display Protected Special Registers",
 | 
      
         | 60 |  |  | " ze - Echo File For Echo Mode    | zc - Execute commands from command file",
 | 
      
         | 61 |  |  | " zl - Use log file for log mode  | | - Comment character (in Command File)",
 | 
      
         | 62 |  |  | " ----------------------------------------------------------------------------",
 | 
      
         | 63 |  |  | ""
 | 
      
         | 64 |  |  | };
 | 
      
         | 65 |  |  |  
 | 
      
         | 66 |  |  |  
 | 
      
         | 67 |  |  | /*
 | 
      
         | 68 |  |  | ** Assemble
 | 
      
         | 69 |  |  | */
 | 
      
         | 70 |  |  |  
 | 
      
         | 71 |  |  | char *help_a[] = {
 | 
      
         | 72 |  |  |  
 | 
      
         | 73 |  |  | "A <address> <instruction>",
 | 
      
         | 74 |  |  | " ",
 | 
      
         | 75 |  |  | "Assemble instructions into memory.",
 | 
      
         | 76 |  |  | " ",
 | 
      
         | 77 |  |  | "The address, is the memory address for the instruction.",
 | 
      
         | 78 |  |  | " ",
 | 
      
         | 79 |  |  | "The instruction will be assembled and placed in memory at the",
 | 
      
         | 80 |  |  | "specified address.",
 | 
      
         | 81 |  |  | " ",
 | 
      
         | 82 |  |  | "Memory addresses:",
 | 
      
         | 83 |  |  | " ",
 | 
      
         | 84 |  |  | "<hex>m - data memory             <hex>i - instruction memory",
 | 
      
         | 85 |  |  | "<hex>r - rom memory              <hex>u - unspecified (no addr check)",
 | 
      
         | 86 |  |  | ""
 | 
      
         | 87 |  |  | };
 | 
      
         | 88 |  |  |  
 | 
      
         | 89 |  |  |  
 | 
      
         | 90 |  |  | /*
 | 
      
         | 91 |  |  | ** Breakpoint
 | 
      
         | 92 |  |  | */
 | 
      
         | 93 |  |  |  
 | 
      
         | 94 |  |  | char *help_b[] = {
 | 
      
         | 95 |  |  |  
 | 
      
         | 96 |  |  | "Breakpoint display, set and clear.",
 | 
      
         | 97 |  |  | " ",
 | 
      
         | 98 |  |  | "B - displays valid breakpoints",
 | 
      
         | 99 |  |  | "B <address> [<passcount>]  - to set  software breakpoint",
 | 
      
         | 100 |  |  | "B050[P,V] <address> [<passcount>]  - to set Am29050 hardware breakpoint",
 | 
      
         | 101 |  |  | " When B050P is used, breakpoint is hit only if translation is disabled.",
 | 
      
         | 102 |  |  | " When B050V is used, breakpoint is hit only if translation is enables.",
 | 
      
         | 103 |  |  | "A breakpoint is set at the specified address.  An optional",
 | 
      
         | 104 |  |  | "<pass count> sets the pass count.  The B050 command sets",
 | 
      
         | 105 |  |  | "a breakpoint using an Am29050 breakpoint register. ",
 | 
      
         | 106 |  |  | "BC <address> - to clear the breakpoint set at <address>",
 | 
      
         | 107 |  |  | "BC - clears all breakpoints.",
 | 
      
         | 108 |  |  | " ",
 | 
      
         | 109 |  |  | "<address> format:",
 | 
      
         | 110 |  |  | " ",
 | 
      
         | 111 |  |  | "<hex>m - data memory              <hex>i - instruction memory",
 | 
      
         | 112 |  |  | "<hex>r - rom memory               <hex>u - unspecified (no addr check)",
 | 
      
         | 113 |  |  | " B Command usage: B, B050, B050V, B050P",
 | 
      
         | 114 |  |  | ""
 | 
      
         | 115 |  |  | };
 | 
      
         | 116 |  |  |  
 | 
      
         | 117 |  |  |  
 | 
      
         | 118 |  |  | /*
 | 
      
         | 119 |  |  | ** Configuration help
 | 
      
         | 120 |  |  | */
 | 
      
         | 121 |  |  |  
 | 
      
         | 122 |  |  | char *help_c[] = {
 | 
      
         | 123 |  |  |  
 | 
      
         | 124 |  |  | "C - Prints target system configuration.",
 | 
      
         | 125 |  |  | " ",
 | 
      
         | 126 |  |  | "This command is used to read and display the target configuration.",
 | 
      
         | 127 |  |  | "A banner is printed displaying information about the target.",
 | 
      
         | 128 |  |  | " ",
 | 
      
         | 129 |  |  | " Other C commands: CAPS, CP, CON, CH0",
 | 
      
         | 130 |  |  | ""
 | 
      
         | 131 |  |  | };
 | 
      
         | 132 |  |  |  
 | 
      
         | 133 |  |  | char *help_caps[] = {
 | 
      
         | 134 |  |  | " CAPS - Prints UDI capabilities of DFE and TIP",
 | 
      
         | 135 |  |  | " This prints the DFE version number, TIP version number, and UDI revision.",
 | 
      
         | 136 |  |  | ""
 | 
      
         | 137 |  |  | };
 | 
      
         | 138 |  |  |  
 | 
      
         | 139 |  |  | char *help_cp[] = {
 | 
      
         | 140 |  |  | "CP - Create a UDI Process.",
 | 
      
         | 141 |  |  | " This sends a request to the TIP to create a new process.",
 | 
      
         | 142 |  |  | ""
 | 
      
         | 143 |  |  | };
 | 
      
         | 144 |  |  |  
 | 
      
         | 145 |  |  | char *help_con[] = {
 | 
      
         | 146 |  |  | "CON <session_id>- Requests connection to UDI TIP running <session_id>.",
 | 
      
         | 147 |  |  | " This connects to the debug session specified by <session_id>.",
 | 
      
         | 148 |  |  | ""
 | 
      
         | 149 |  |  | };
 | 
      
         | 150 |  |  |  
 | 
      
         | 151 |  |  | char *help_ch0[] = {
 | 
      
         | 152 |  |  | " CH0 - Transfers control of the terminal to the 29K target.",
 | 
      
         | 153 |  |  | " This is used to transfer control to the 29K target program.",
 | 
      
         | 154 |  |  | " The input characters typed are sent to the TIP without interpreting",
 | 
      
         | 155 |  |  | " for a mondfe command. Control is transferred to mondfe when a Ctrl-U",
 | 
      
         | 156 |  |  | " is typed.",
 | 
      
         | 157 |  |  | ""
 | 
      
         | 158 |  |  | };
 | 
      
         | 159 |  |  | /*
 | 
      
         | 160 |  |  | ** Dump
 | 
      
         | 161 |  |  | */
 | 
      
         | 162 |  |  |  
 | 
      
         | 163 |  |  | char *help_d[] = {
 | 
      
         | 164 |  |  |  
 | 
      
         | 165 |  |  | "D[W|H|B|F|D] [<from_address> [<to_address>]]",
 | 
      
         | 166 |  |  | " ",
 | 
      
         | 167 |  |  | "Display memory or register contents.",
 | 
      
         | 168 |  |  | " ",
 | 
      
         | 169 |  |  | "DW or D - display as words.           DF - display in floating point.",
 | 
      
         | 170 |  |  | "DH      - display as half-words.      DD - display in double precision",
 | 
      
         | 171 |  |  | "DB      - display as bytes.                floating point.",
 | 
      
         | 172 |  |  | " ",
 | 
      
         | 173 |  |  | "<from_address> defaults to address last displayed.  The ",
 | 
      
         | 174 |  |  | "<to_address> is the address of the last data to display.  The default",
 | 
      
         | 175 |  |  | "is about eight lines of data.",
 | 
      
         | 176 |  |  | " ",
 | 
      
         | 177 |  |  | "Valid register names:",
 | 
      
         | 178 |  |  | "gr0-gr1, gr64-gr127 - global register names",
 | 
      
         | 179 |  |  | "sr0-sr14, sr128-sr135, sr160-sr162,sr164 - special register names",
 | 
      
         | 180 |  |  | "lr0-lr127 - local register names ",
 | 
      
         | 181 |  |  | "tr0-tr127 - TLB register names ",
 | 
      
         | 182 |  |  | "<address> format:",
 | 
      
         | 183 |  |  | " ",
 | 
      
         | 184 |  |  | "<hex>m - data memory                  <hex>i - instruction memory",
 | 
      
         | 185 |  |  | "<hex>r - rom memory                   <hex>u - unspecified (no addr check)",
 | 
      
         | 186 |  |  | " D Command usage: D, DW, DH, DB, DF, DD",
 | 
      
         | 187 |  |  | " Other D Commands: DP, DISC",
 | 
      
         | 188 |  |  | ""
 | 
      
         | 189 |  |  | };
 | 
      
         | 190 |  |  |  
 | 
      
         | 191 |  |  |  
 | 
      
         | 192 |  |  | char *help_dp[] = {
 | 
      
         | 193 |  |  | " DP - Destroy process.",
 | 
      
         | 194 |  |  | " This requests the TIP to destroy a UDI process. ",
 | 
      
         | 195 |  |  | ""
 | 
      
         | 196 |  |  | };
 | 
      
         | 197 |  |  |  
 | 
      
         | 198 |  |  | char *help_disc[] = {
 | 
      
         | 199 |  |  | " DISC - Disconnect from the debug session.",
 | 
      
         | 200 |  |  | " This disconnects the DFE from the current debug session. The TIP is",
 | 
      
         | 201 |  |  | " not destroyed and left running for later reconnections.",
 | 
      
         | 202 |  |  | ""
 | 
      
         | 203 |  |  | };
 | 
      
         | 204 |  |  | /*
 | 
      
         | 205 |  |  |  * Escape command
 | 
      
         | 206 |  |  |  */
 | 
      
         | 207 |  |  |  
 | 
      
         | 208 |  |  | char    *help_e[] = {
 | 
      
         | 209 |  |  | "ESC",
 | 
      
         | 210 |  |  | " ",
 | 
      
         | 211 |  |  | "Temporarily exit to host operating system.",
 | 
      
         | 212 |  |  | "Use EXIT command to resume debug session.",
 | 
      
         | 213 |  |  | "Other E commands: EON, EOFF",
 | 
      
         | 214 |  |  | ""
 | 
      
         | 215 |  |  | };
 | 
      
         | 216 |  |  |  
 | 
      
         | 217 |  |  | char    *help_ex[] = {
 | 
      
         | 218 |  |  | " EX - Exit current debug session.",
 | 
      
         | 219 |  |  | " This command can be used to exit from a debug session when done. Mondfe",
 | 
      
         | 220 |  |  | " looks for another session in progress and connects to that session. If",
 | 
      
         | 221 |  |  | " there are no more debug sessions in progress, this command causes Mondfe",
 | 
      
         | 222 |  |  | " to quit, i.e. it has the same effect as the Quit command",
 | 
      
         | 223 |  |  | ""
 | 
      
         | 224 |  |  | };
 | 
      
         | 225 |  |  |  
 | 
      
         | 226 |  |  | char    *help_esc[] = {
 | 
      
         | 227 |  |  | "ESC",
 | 
      
         | 228 |  |  | " ",
 | 
      
         | 229 |  |  | "Temporarily exit to host operating system.",
 | 
      
         | 230 |  |  | "Use EXIT command to resume debug session.",
 | 
      
         | 231 |  |  | "Other E commands: EON, EOFF",
 | 
      
         | 232 |  |  | ""
 | 
      
         | 233 |  |  | };
 | 
      
         | 234 |  |  |  
 | 
      
         | 235 |  |  | char *help_eon[] = {
 | 
      
         | 236 |  |  | " EON and EOFF can be used to turn echo mode ON and OFF during the",
 | 
      
         | 237 |  |  | " interactive debug session. Echo mode is specified by using the -e ",
 | 
      
         | 238 |  |  | " mondfe command line option and an file name. During echo mode, everything",
 | 
      
         | 239 |  |  | " displayed on the screen are captured in the file specified.",
 | 
      
         | 240 |  |  | ""
 | 
      
         | 241 |  |  | };
 | 
      
         | 242 |  |  |  
 | 
      
         | 243 |  |  | /*
 | 
      
         | 244 |  |  | ** Fill
 | 
      
         | 245 |  |  | */
 | 
      
         | 246 |  |  |  
 | 
      
         | 247 |  |  | char *help_f[] = {
 | 
      
         | 248 |  |  |  
 | 
      
         | 249 |  |  | "F[W|H|B|F|D] <start address>, <end address>, <value>",
 | 
      
         | 250 |  |  | " ",
 | 
      
         | 251 |  |  | "Fill memory or register contents.",
 | 
      
         | 252 |  |  | " ",
 | 
      
         | 253 |  |  | "FW or F - fill as 32-bit integers  |    FF - fill as floating point value.",
 | 
      
         | 254 |  |  | "FH      - fill as 16-bit integers  |    FD - fill as double precision",
 | 
      
         | 255 |  |  | "FB      - fill as 8-bit integers   |    floating point value.",
 | 
      
         | 256 |  |  | "FS      - fill with the string/pattern given.",
 | 
      
         | 257 |  |  | " ",
 | 
      
         | 258 |  |  | "Valid register names:",
 | 
      
         | 259 |  |  | "gr0-gr1, gr64-gr127 - global register names",
 | 
      
         | 260 |  |  | "sr0-sr14, sr128-sr135, sr160-sr162,sr164 - special register names",
 | 
      
         | 261 |  |  | "lr0-lr127 - local register names ",
 | 
      
         | 262 |  |  | "tr0-tr127 - TLB register names ",
 | 
      
         | 263 |  |  | " ",
 | 
      
         | 264 |  |  | "<address> format:",
 | 
      
         | 265 |  |  | " ",
 | 
      
         | 266 |  |  | "<hex>m - data memory               <hex>i - instruction memory",
 | 
      
         | 267 |  |  | "<hex>r - rom memory                <hex>u - unspecified (no addr check)",
 | 
      
         | 268 |  |  | " F command usage: F, FW, FH, FB, FD, FS",
 | 
      
         | 269 |  |  | ""
 | 
      
         | 270 |  |  | };
 | 
      
         | 271 |  |  |  
 | 
      
         | 272 |  |  |  
 | 
      
         | 273 |  |  | /*
 | 
      
         | 274 |  |  | ** Go
 | 
      
         | 275 |  |  | */
 | 
      
         | 276 |  |  |  
 | 
      
         | 277 |  |  | char *help_g[] = {
 | 
      
         | 278 |  |  |  
 | 
      
         | 279 |  |  | "G - Start program execution",
 | 
      
         | 280 |  |  | " ",
 | 
      
         | 281 |  |  | "This resumes program execution at the next instruction.",
 | 
      
         | 282 |  |  | " The program runs either until completion or until it hits a breakpoint",
 | 
      
         | 283 |  |  | " It is used to run the downloaded program and to resume after hitting",
 | 
      
         | 284 |  |  | " a breakpoint. The trace command can be used to execute a specified",
 | 
      
         | 285 |  |  | " number of instructions.",
 | 
      
         | 286 |  |  | ""
 | 
      
         | 287 |  |  | };
 | 
      
         | 288 |  |  |  
 | 
      
         | 289 |  |  |  
 | 
      
         | 290 |  |  | /*
 | 
      
         | 291 |  |  | ** I    (ix, ia, il)
 | 
      
         | 292 |  |  | */
 | 
      
         | 293 |  |  |  
 | 
      
         | 294 |  |  | char *help_i[] = {
 | 
      
         | 295 |  |  | "IX, IL -  Display/Disassemble Am2903X cache registers",
 | 
      
         | 296 |  |  | " ",
 | 
      
         | 297 |  |  | "Display/Disassemble 2903x cache registers by bit field name.",
 | 
      
         | 298 |  |  | " I Commands: IX, IL ",
 | 
      
         | 299 |  |  | " Other I commands: INIT",
 | 
      
         | 300 |  |  | ""
 | 
      
         | 301 |  |  | };
 | 
      
         | 302 |  |  |  
 | 
      
         | 303 |  |  | char *help_init[] = {
 | 
      
         | 304 |  |  | " INIT - Initialize the current process.",
 | 
      
         | 305 |  |  | " This is used to initialize the downloaded program to restart execution",
 | 
      
         | 306 |  |  | " or to reset the target. It resets the target when the current process",
 | 
      
         | 307 |  |  | " ID is set to -1. It does not clear BSS of the downloaded program for ",
 | 
      
         | 308 |  |  | " restart.",
 | 
      
         | 309 |  |  | ""
 | 
      
         | 310 |  |  | };
 | 
      
         | 311 |  |  |  
 | 
      
         | 312 |  |  | /*
 | 
      
         | 313 |  |  | ** Help
 | 
      
         | 314 |  |  | */
 | 
      
         | 315 |  |  |  
 | 
      
         | 316 |  |  | char *help_h[] = {
 | 
      
         | 317 |  |  |  
 | 
      
         | 318 |  |  | "H <cmd>",
 | 
      
         | 319 |  |  | " ",
 | 
      
         | 320 |  |  | "Get help for a monitor command",
 | 
      
         | 321 |  |  | " ",
 | 
      
         | 322 |  |  | "This gets help for a particular monitor command.  If <cmd>.",
 | 
      
         | 323 |  |  | "is not a valid monitor command the main help screen is listed.",
 | 
      
         | 324 |  |  | " Type  <command_name>  for help on a particular command.",
 | 
      
         | 325 |  |  | ""
 | 
      
         | 326 |  |  | };
 | 
      
         | 327 |  |  |  
 | 
      
         | 328 |  |  |  
 | 
      
         | 329 |  |  | /*
 | 
      
         | 330 |  |  | ** Kill
 | 
      
         | 331 |  |  | */
 | 
      
         | 332 |  |  |  
 | 
      
         | 333 |  |  | char *help_k[] = {
 | 
      
         | 334 |  |  |  
 | 
      
         | 335 |  |  | "K - Kill command.",
 | 
      
         | 336 |  |  | " When a K command is issued, the running program on the 29K target",
 | 
      
         | 337 |  |  | " is stopped.",
 | 
      
         | 338 |  |  | ""
 | 
      
         | 339 |  |  | };
 | 
      
         | 340 |  |  |  
 | 
      
         | 341 |  |  |  
 | 
      
         | 342 |  |  | /*
 | 
      
         | 343 |  |  | ** List (disassemble)
 | 
      
         | 344 |  |  | */
 | 
      
         | 345 |  |  |  
 | 
      
         | 346 |  |  | char *help_l[] = {
 | 
      
         | 347 |  |  |  
 | 
      
         | 348 |  |  | "L [<first_address> [<last_address>]]",
 | 
      
         | 349 |  |  | " ",
 | 
      
         | 350 |  |  | "Disassemble instructions from memory.",
 | 
      
         | 351 |  |  | " ",
 | 
      
         | 352 |  |  | "The <first_address,> if specified, is the memory address for the first",
 | 
      
         | 353 |  |  | "instruction.  If no <first_address> is specified, disassembly will begin",
 | 
      
         | 354 |  |  | "from the address in the buffer.",
 | 
      
         | 355 |  |  | " ",
 | 
      
         | 356 |  |  | "The <last_address,> if specified, is the last address to be disassembled.",
 | 
      
         | 357 |  |  | "If no <last_address> is specified, the number of lines of data in the",
 | 
      
         | 358 |  |  | "previous disassemble command will be displayed.",
 | 
      
         | 359 |  |  | " ",
 | 
      
         | 360 |  |  | "<address> format:",
 | 
      
         | 361 |  |  | " ",
 | 
      
         | 362 |  |  | "<hex>m - data memory              <hex>i - instruction memory",
 | 
      
         | 363 |  |  | "<hex>r - rom memory               <hex>u - unspecified (no addr check)",
 | 
      
         | 364 |  |  | " Other L commands: logon, logoff",
 | 
      
         | 365 |  |  | ""
 | 
      
         | 366 |  |  | };
 | 
      
         | 367 |  |  |  
 | 
      
         | 368 |  |  | char    *help_logon[] = {
 | 
      
         | 369 |  |  | " LOGON and LOGOFF commands can be used to turn ON or OFF the log mode",
 | 
      
         | 370 |  |  | " from the mondfe command prompt. WHen log mode is on, every command entered",
 | 
      
         | 371 |  |  | " by the user is logged into the log file specified at invocation or using",
 | 
      
         | 372 |  |  | " the ZL command. When log mode is off, the commands are not logged.",
 | 
      
         | 373 |  |  | ""
 | 
      
         | 374 |  |  | };
 | 
      
         | 375 |  |  |  
 | 
      
         | 376 |  |  | /*
 | 
      
         | 377 |  |  | ** Move
 | 
      
         | 378 |  |  | */
 | 
      
         | 379 |  |  |  
 | 
      
         | 380 |  |  | char *help_m[] = {
 | 
      
         | 381 |  |  |  
 | 
      
         | 382 |  |  | "M <source start> <source end> <destination start>",
 | 
      
         | 383 |  |  | " ",
 | 
      
         | 384 |  |  | "Move within memory or registers.  Destination will contain exact",
 | 
      
         | 385 |  |  | "copy of original source regardless of overlap.  (The source",
 | 
      
         | 386 |  |  | "will be partially altered in the case of overlap.)",
 | 
      
         | 387 |  |  | " ",
 | 
      
         | 388 |  |  | "Valid register names:",
 | 
      
         | 389 |  |  | "gr0-gr1, gr64-gr127 - global register names",
 | 
      
         | 390 |  |  | "sr0-sr14, sr128-sr135, sr160-sr162,sr164 - special register names",
 | 
      
         | 391 |  |  | "lr0-lr127 - local register names ",
 | 
      
         | 392 |  |  | "tr0-tr127 - TLB register names ",
 | 
      
         | 393 |  |  | " ",
 | 
      
         | 394 |  |  | "<address> format :",
 | 
      
         | 395 |  |  | " ",
 | 
      
         | 396 |  |  | "<hex>m - data memory               <hex>i - instruction memory",
 | 
      
         | 397 |  |  | "<hex>r - rom memory                <hex>u - unspecified (no addr check)",
 | 
      
         | 398 |  |  | ""
 | 
      
         | 399 |  |  | };
 | 
      
         | 400 |  |  |  
 | 
      
         | 401 |  |  | char    *help_pid[] = {
 | 
      
         | 402 |  |  | " PID <pid_number> - sets the current UDI process to the <pid_number>",
 | 
      
         | 403 |  |  | " specified.",
 | 
      
         | 404 |  |  | " A <pid_number> of -1 is used to represent the bare machine. This is",
 | 
      
         | 405 |  |  | " is used to access physical addresses, and to reset the target.",
 | 
      
         | 406 |  |  | " Use CP command to create process. Use DP command to destroy process.",
 | 
      
         | 407 |  |  | " Use INIT command to initialize process.",
 | 
      
         | 408 |  |  | ""
 | 
      
         | 409 |  |  | };
 | 
      
         | 410 |  |  |  
 | 
      
         | 411 |  |  | /*
 | 
      
         | 412 |  |  | ** Quit
 | 
      
         | 413 |  |  | */
 | 
      
         | 414 |  |  |  
 | 
      
         | 415 |  |  | char *help_q[] = {
 | 
      
         | 416 |  |  |  
 | 
      
         | 417 |  |  | "Q",
 | 
      
         | 418 |  |  | " ",
 | 
      
         | 419 |  |  | "Quit - exit from the monitor.",
 | 
      
         | 420 |  |  | ""
 | 
      
         | 421 |  |  | };
 | 
      
         | 422 |  |  |  
 | 
      
         | 423 |  |  | char    *help_qoff[] = {
 | 
      
         | 424 |  |  | " QON and QOFF can be used to turn ON/OFF quiet mode of Mondfe. The -q",
 | 
      
         | 425 |  |  | " command line option of mondfe can be used to invoke mondfe in quiet",
 | 
      
         | 426 |  |  | " mode. In quiet mode, the debug messages are suppressed. These messages",
 | 
      
         | 427 |  |  | " can be turned on anytime during the debug session using the QON command",
 | 
      
         | 428 |  |  | " and turned off using the QOFF command.",
 | 
      
         | 429 |  |  | ""
 | 
      
         | 430 |  |  | };
 | 
      
         | 431 |  |  |  
 | 
      
         | 432 |  |  |  
 | 
      
         | 433 |  |  | /*
 | 
      
         | 434 |  |  | ** Reset
 | 
      
         | 435 |  |  | */
 | 
      
         | 436 |  |  |  
 | 
      
         | 437 |  |  | char *help_r[] = {
 | 
      
         | 438 |  |  |  
 | 
      
         | 439 |  |  | "R - Reset the target.",
 | 
      
         | 440 |  |  | " This command resets (performs a software reset) of the target. This is",
 | 
      
         | 441 |  |  | " equivalent to setting the UDI process ID to -1, and initializing the",
 | 
      
         | 442 |  |  | " process using INIT.",
 | 
      
         | 443 |  |  | ""
 | 
      
         | 444 |  |  | };
 | 
      
         | 445 |  |  |  
 | 
      
         | 446 |  |  |  
 | 
      
         | 447 |  |  | /*
 | 
      
         | 448 |  |  | ** Set
 | 
      
         | 449 |  |  | */
 | 
      
         | 450 |  |  |  
 | 
      
         | 451 |  |  | char *help_s[] = {
 | 
      
         | 452 |  |  |  
 | 
      
         | 453 |  |  | "S[W|H|B|F|D] <address> <data>",
 | 
      
         | 454 |  |  | " ",
 | 
      
         | 455 |  |  | "Set memory or register contents.",
 | 
      
         | 456 |  |  | " ",
 | 
      
         | 457 |  |  | "SW or S - set as words.            SF - set in floating point.",
 | 
      
         | 458 |  |  | "SH      - set as half-words.       SD - set in double precision",
 | 
      
         | 459 |  |  | "SB      - set as bytes.                 floating point.",
 | 
      
         | 460 |  |  | " ",
 | 
      
         | 461 |  |  | "<address> indicates location to be set.  <Data> is the value",
 | 
      
         | 462 |  |  | "to be set.  The data is entered in hexadecimal.",
 | 
      
         | 463 |  |  | " ",
 | 
      
         | 464 |  |  | "Valid register names:",
 | 
      
         | 465 |  |  | "gr0-gr1, gr64-gr127 - global register names",
 | 
      
         | 466 |  |  | "sr0-sr14, sr128-sr135, sr160-sr162,sr164 - special register names",
 | 
      
         | 467 |  |  | "lr0-lr127 - local register names ",
 | 
      
         | 468 |  |  | "tr0-tr127 - TLB register names ",
 | 
      
         | 469 |  |  | " ",
 | 
      
         | 470 |  |  | "<address> format:",
 | 
      
         | 471 |  |  | " ",
 | 
      
         | 472 |  |  | "<hex>m - data memory               <hex>i - instruction memory",
 | 
      
         | 473 |  |  | "<hex>r - rom memory                <hex>u - unspecified (no addr check)",
 | 
      
         | 474 |  |  | " S command usage: S, SW, SH, SB, SF, SD",
 | 
      
         | 475 |  |  | " Other S command: SID",
 | 
      
         | 476 |  |  | ""
 | 
      
         | 477 |  |  | };
 | 
      
         | 478 |  |  |  
 | 
      
         | 479 |  |  | char    *help_sid[] = {
 | 
      
         | 480 |  |  | " SID <sid_number> - sets the UDI session ID to <sid_number>.",
 | 
      
         | 481 |  |  | " This command can be used to set the current debug session when there",
 | 
      
         | 482 |  |  | " is multiple debug sessions going on.",
 | 
      
         | 483 |  |  | ""
 | 
      
         | 484 |  |  | };
 | 
      
         | 485 |  |  |  
 | 
      
         | 486 |  |  | /*
 | 
      
         | 487 |  |  | ** Trace
 | 
      
         | 488 |  |  | */
 | 
      
         | 489 |  |  |  
 | 
      
         | 490 |  |  | char *help_t[] = {
 | 
      
         | 491 |  |  |  
 | 
      
         | 492 |  |  | "T <count> - Trace or Step <count> instructions.",
 | 
      
         | 493 |  |  | "Trace allows stepping through code.  The optional <count>",
 | 
      
         | 494 |  |  | "allows multiple steps to be taken.  The count is in hex.",
 | 
      
         | 495 |  |  | " The default value of <count> is 1. This may not step into",
 | 
      
         | 496 |  |  | " trap handlers based on the target/TIP capabilities.",
 | 
      
         | 497 |  |  | " Other T commands: TIP",
 | 
      
         | 498 |  |  | ""
 | 
      
         | 499 |  |  | };
 | 
      
         | 500 |  |  |  
 | 
      
         | 501 |  |  | char    *help_tip[] = {
 | 
      
         | 502 |  |  | " TIP <montip_command> - sends <montip_command> string to montip for execution",
 | 
      
         | 503 |  |  | "  The TIP command can be used to inform Montip to change some of its",
 | 
      
         | 504 |  |  | "  parameters. The TIP command uses the UDI Transparent mode to pass",
 | 
      
         | 505 |  |  | "  the command string. The following TIP commands are now supported:",
 | 
      
         | 506 |  |  | "    tip  lpt=0",
 | 
      
         | 507 |  |  | "       - requests Montip is stop using the parallel port for communicating",
 | 
      
         | 508 |  |  | "         to the 29K target - valid for 29K microcontroller targets.",
 | 
      
         | 509 |  |  | "    tip  lpt=1",
 | 
      
         | 510 |  |  | "       - requests Montip to use the parallel port for communicating",
 | 
      
         | 511 |  |  | "         to the 29K target - valid for 29K microcontroller targets.",
 | 
      
         | 512 |  |  | "  The TIP command can be used before issuing a Y(ank) command to download",
 | 
      
         | 513 |  |  | "  a program (COFF) file using the PC parallel port. The parallel port",
 | 
      
         | 514 |  |  | "  download capability is only applicable for a PC host. The parallel port",
 | 
      
         | 515 |  |  | "  to use MUST be specified as a Montip command line option in the UDI ",
 | 
      
         | 516 |  |  | "  configuration file - udiconfs.txt on PC, udi_soc on Unix hosts - using",
 | 
      
         | 517 |  |  | "  the -par Montip command line option.",
 | 
      
         | 518 |  |  | "  As the parallel port communication is only unidirectional, the serial",
 | 
      
         | 519 |  |  | "  communications port - com1, or com2 - must also be specified on Montip",
 | 
      
         | 520 |  |  | "  command line in the UDI configuration file.",
 | 
      
         | 521 |  |  | "  This command is valid ONLY with MiniMON29K Montip.",
 | 
      
         | 522 |  |  | ""
 | 
      
         | 523 |  |  | };
 | 
      
         | 524 |  |  |  
 | 
      
         | 525 |  |  | /*
 | 
      
         | 526 |  |  | ** X
 | 
      
         | 527 |  |  | */
 | 
      
         | 528 |  |  |  
 | 
      
         | 529 |  |  | char *help_x[] = {
 | 
      
         | 530 |  |  | "XP - Display protected special purpose registers.",
 | 
      
         | 531 |  |  | " ",
 | 
      
         | 532 |  |  | "Display protected special purpose registers by bit field name.",
 | 
      
         | 533 |  |  | ""
 | 
      
         | 534 |  |  | };
 | 
      
         | 535 |  |  |  
 | 
      
         | 536 |  |  |  
 | 
      
         | 537 |  |  | /*
 | 
      
         | 538 |  |  | ** Yank
 | 
      
         | 539 |  |  | */
 | 
      
         | 540 |  |  |  
 | 
      
         | 541 |  |  | char *help_y[] = {
 | 
      
         | 542 |  |  |  
 | 
      
         | 543 |  |  | "Y [-t|d|l|b] [-noi|-i] [-ms <mstk_x>] [-rs <rstk_x] [fname] [arglist]",
 | 
      
         | 544 |  |  | " ",
 | 
      
         | 545 |  |  | "This is the Yank command to download program (COFF) file to the 29K target.",
 | 
      
         | 546 |  |  | " ",
 | 
      
         | 547 |  |  | "where <fname> is name of a COFF file.",
 | 
      
         | 548 |  |  | " ",
 | 
      
         | 549 |  |  | "<arglist> is the list of command line arguments for the program.",
 | 
      
         | 550 |  |  | " ",
 | 
      
         | 551 |  |  | "-t|d|l|b| gives sections for loading. t->text, d->data, l->lit, b->bss.",
 | 
      
         | 552 |  |  | " ",
 | 
      
         | 553 |  |  | "-noi -> no process created, -i -> download for execute (default).",
 | 
      
         | 554 |  |  | " ",
 | 
      
         | 555 |  |  | "-ms <memstk_hex> -> memory stack size, -rs <regstk_hex> -> reg stack size.",
 | 
      
         | 556 |  |  | " ",
 | 
      
         | 557 |  |  | "Ex: y -db hello.pcb arg1 arg2, loads only the DATA and LIT sections.",
 | 
      
         | 558 |  |  | " ",
 | 
      
         | 559 |  |  | "Simply typing Y will use args from the previous Y issued.",
 | 
      
         | 560 |  |  | " ",
 | 
      
         | 561 |  |  | " See the TIP command for downloading using parallel port",
 | 
      
         | 562 |  |  | ""
 | 
      
         | 563 |  |  | };
 | 
      
         | 564 |  |  |  
 | 
      
         | 565 |  |  |  
 | 
      
         | 566 |  |  | char    *help_zc[] = {
 | 
      
         | 567 |  |  | " ZC <cmdfile_name> - execute commands from the <cmdfile_name> command file",
 | 
      
         | 568 |  |  | " The ZC command can be used to execute a series of Mondfe commands",
 | 
      
         | 569 |  |  | " out of a command file. The <cmdfile_name> is the name of the file",
 | 
      
         | 570 |  |  | " containing the command input. This command can be executed at the",
 | 
      
         | 571 |  |  | " mondfe> prompt. When all the commands from the file are executed, the",
 | 
      
         | 572 |  |  | " mondfe> prompt appears again.",
 | 
      
         | 573 |  |  | " Nesting of command files is not allowed.",
 | 
      
         | 574 |  |  | " ",
 | 
      
         | 575 |  |  | " Other Z commands: ZE, ZL",
 | 
      
         | 576 |  |  | ""
 | 
      
         | 577 |  |  | };
 | 
      
         | 578 |  |  |  
 | 
      
         | 579 |  |  | char    *help_ze[] = {
 | 
      
         | 580 |  |  | " ZE <echofile_name> - turns ECHO mode ON and specifies the echo file",
 | 
      
         | 581 |  |  | " When echo mode is on, everything that is displayed on the screen is ",
 | 
      
         | 582 |  |  | " also written into a file, the echo file. The <echofile_name> string ",
 | 
      
         | 583 |  |  | " specifies the file name of the echo file to use.",
 | 
      
         | 584 |  |  | ""
 | 
      
         | 585 |  |  | };
 | 
      
         | 586 |  |  |  
 | 
      
         | 587 |  |  | char    *help_zl[] = {
 | 
      
         | 588 |  |  | " ZL <logfile_name> - turns LOG mode ON and specifies the log file to use",
 | 
      
         | 589 |  |  | " When log mode is on, every mondfe command entered by the user is logged",
 | 
      
         | 590 |  |  | " in the log file. The log file thus created can be directly used an an",
 | 
      
         | 591 |  |  | " input command file for subsequent debug session to repeat the same sequence",
 | 
      
         | 592 |  |  | " of commands. Log mode can be turned on or off using logon or logoff command",
 | 
      
         | 593 |  |  | ""
 | 
      
         | 594 |  |  | };
 |