mon_hw_mem.h

00001 /*
00002  * Monitor program / Memory control part
00003  *
00004  *  Copyright (c) 2010-2014 Kenji Arai / JH1PJL
00005  *  http://www.page.sannet.ne.jp/kenjia/index.html
00006  *  http://mbed.org/users/kenjiArai/
00007  *      Separated:  October   13th, 2014    from mon_hw.cpp
00008  *      Revised:    Nobember   2nd, 2014
00009  *
00010  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
00011  * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
00012  * AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
00013  * DAMAGES OR OTHER  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
00014  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
00015  */
00016 
00017 //-------------------------------------------------------------------------------------------------
00018 //  Control Program
00019 //-------------------------------------------------------------------------------------------------
00020 //  Range check for Memory dump
00021 static void check_range( MEMO * mem )
00022 {
00023     uint8_t  i;
00024     uint32_t m;
00025 
00026     mem->mflg = ERR_NOTHING;
00027     for ( i = 0 ; i < 5 ; i++ ) {
00028         if ( mem->mstr >= mem_range[i][0]) {
00029             if ( mem->mstr < mem_range[i][1] ) {
00030                 m = mem->mstr + mem->msiz;
00031                 if ( m < mem_range[i][1]) {
00032                     return;            // no modification
00033                 } else {
00034                     m = mem_range[i][1];
00035                     mem->msiz = m - mem->mstr + 1;
00036                     mem->mflg = ERR_MODIFY_SIZ;
00037                     return;            // modified size
00038                 }
00039             }
00040         }
00041     }
00042     mem->mflg = ERR_OUT_OF_RANGE;
00043     mem->mstr = 0;
00044     mem->msiz = 0;
00045     return ;
00046 }
00047 
00048 //  Memory dump error massage
00049 void error_print ( unsigned char flg )
00050 {
00051     switch (flg) {
00052         case ERR_MODIFY_SIZ :
00053             put_r();
00054             PRINTF("Reach to out of range");
00055             put_rn();
00056             break;
00057         case ERR_OUT_OF_RANGE :
00058             put_r();
00059             PRINTF("Not in a memory area");
00060             put_rn();
00061             break;
00062         case ERR_NOTHING :
00063         default :
00064             ;
00065     }
00066 }
00067 
00068 //  Print memory contents
00069 void put_dump (const unsigned char *buff, unsigned long ofs, int cnt)
00070 {
00071     int n;
00072 
00073     PRINTF("%08lX ", ofs);
00074     for(n = 0; n < cnt; n++) {      // show hex
00075         PRINTF(" %02X", buff[n]);
00076     }
00077     for(; n < 16; n++) {            // fullfil remained space
00078         PRINTF("   ");
00079     }
00080     PUTC(' ');
00081     for(n = 0; n < cnt; n++) {      // show char
00082         if ((buff[n] < 0x20)||(buff[n] >= 0x7F)) {
00083             PUTC('.');
00084         } else {
00085             PUTC(buff[n]);
00086         }
00087     }
00088     put_rn();
00089 }
00090 
00091 // dump memory with error check
00092 void dump_w_err_ckeck ( char **ptr, MEMO * mem )
00093 {
00094     check_range (mem);
00095     for (*ptr=(char*)mem->mstr; mem->msiz >= 16; *ptr += 16, mem->msiz -= 16) {
00096         put_r();
00097         put_dump((unsigned char*)*ptr, (unsigned int)*ptr, 16);
00098     }
00099     if (mem->msiz) {
00100         put_dump((unsigned char*)*ptr, (unsigned int)*ptr, mem->msiz);
00101     }
00102     error_print(mem->mflg);
00103 }
00104 
00105 static void mem_inf (char *ptr)
00106 {
00107     put_r();
00108     PRINTF("Mem. Mode d <address> [<count>], s, <ret> or f, q, ?");
00109     put_rn();
00110     mem.mstr = mem_range[0][0];     // default start address = Flash
00111     mem.msiz =256;
00112     mem.mold = 0;
00113     mem.mtmp = 0;
00114     mem.mflg = 0;
00115     for (; mem.mflg != 0xff;) {
00116         PRINTF("m>");
00117         ptr = linebuf;
00118         get_line(ptr, buf_size);
00119         put_r();
00120         switch(*ptr++) {
00121             case 'd' :    // d <address> [<count>] - Dump memory
00122                 mem.mtmp = mem.mstr;
00123                 if (!xatoi(&ptr, &mem.mstr)) {
00124                     mem.mstr = mem.mtmp;
00125                 }
00126                 if (!xatoi(&ptr, &mem.msiz)) {
00127                     mem.msiz = 256;
00128                 }
00129                 mem.mtmp = mem.msiz;
00130                 dump_w_err_ckeck(&ptr, &mem);
00131                 mem.mold = mem.mstr;
00132                 mem.mstr += mem.mtmp;
00133                 break;
00134             case 'f' :        // next
00135             case 'n' :
00136             case 0x0d :
00137                 mem.msiz = 256;
00138                 mem.mtmp = mem.msiz;
00139                 dump_w_err_ckeck(&ptr, &mem);
00140                 mem.mold = mem.mstr;
00141                 mem.mstr += 256;
00142                 break;
00143             case 'q' :        // quit
00144                 mem.mflg = 0xff;
00145                 break;
00146             case 'b' :        // Back to more
00147                 if (mem.mold == 0) {
00148                     ;
00149                 } else {
00150                     mem.mold -= 256;
00151                 }
00152             case 'k' :        // keep previous address
00153                 mem.mstr = mem.mold;
00154                 mem.msiz = 256;
00155                 mem.mtmp = mem.msiz;
00156                 dump_w_err_ckeck(&ptr, &mem);
00157                 mem.mstr += 256;
00158                 break;
00159             case 'a' :        // start RAM top
00160 #if defined(TARGET_NUCLEO_L152RE)
00161                 mem.mstr = mem_range[4][0];
00162 #elif defined(TARGET_NUCLEO_F401RE) || defined(TARGET_NUCLEO_F411RE)
00163                 mem.mstr = mem_range[3][0];
00164 #elif defined(TARGET_LPC1768)
00165                 mem.mstr = mem_range[1][0];
00166 #elif defined(TARGET_LPC1114)
00167                 mem.mstr = mem_range[1][0];
00168 #else
00169 #error "target cpu does NOT support"
00170 #endif
00171                 mem.msiz =256;
00172                 mem.mold = 0;
00173                 mem.mtmp = 0;
00174                 mem.mflg = 0;
00175                 dump_w_err_ckeck(&ptr, &mem);
00176                 mem.mstr += 256;
00177                 break;
00178             case 'o' :        // start ROM top
00179                 mem.mstr = mem_range[0][0];
00180                 mem.msiz =256;
00181                 mem.mold = 0;
00182                 mem.mtmp = 0;
00183                 mem.mflg = 0;
00184                 dump_w_err_ckeck(&ptr, &mem);
00185                 mem.mstr += 256;
00186                 break;
00187             case 's' :
00188                 PRINTF("Memory Configuration");
00189                 put_rn();
00190                 PRINTF("%s0x%08lx to 0x%08lx ", rmsg0, mem_range[0][0], mem_range[0][1]);
00191                 put_rn();
00192                 PRINTF("%s0x%08lx to 0x%08lx ", rmsg1, mem_range[1][0], mem_range[1][1]);
00193                 put_rn();
00194                 PRINTF("%s0x%08lx to 0x%08lx ", rmsg2, mem_range[2][0], mem_range[2][1]);
00195                 put_rn();
00196                 PRINTF("%s0x%08lx to 0x%08lx ", rmsg3, mem_range[3][0], mem_range[3][1]);
00197                 put_rn();
00198                 PRINTF("%s0x%08lx to 0x%08lx ", rmsg4, mem_range[4][0], mem_range[4][1]);
00199                 put_rn();
00200 #if defined(TARGET_NUCLEO_L152RE)
00201                 PRINTF("%s0x%08lx to 0x%08lx ", rmsg5, mem_range[5][0], mem_range[5][1]);
00202                 put_rn();
00203 #endif
00204                 break;
00205             case '?' :
00206                 PRINTF("d <address> [<count>] - Dump memory");
00207                 put_rn();
00208                 PRINTF("s  - Show memory structure ");
00209                 put_rn();
00210                 PRINTF("o  - Dump memory / start from ROM top");
00211                 put_rn();
00212                 PRINTF("a  - Dump memory / start from RAM top");
00213                 put_rn();
00214                 PRINTF("k  - Dump memory / keep same 256bytes");
00215                 put_rn();
00216                 PRINTF("b  - Dump memory / before 256bytes");
00217                 put_rn();
00218                 PRINTF("<RET> or f, n - Dump memory / next 256bytes");
00219                 put_rn();
00220                 PRINTF("q  - Exit memory mode");
00221                 put_rn();
00222                 break;
00223             default:
00224                 PUTC('?');
00225                 put_rn();
00226         }
00227     }
00228     PRINTF("Return to All Mode");
00229 }