gonzui


Format: Advanced Search

tkernel_2/monitor/driver/flash/src/main.cbare sourcepermlink (0.02 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 TRON Forum(http://www.tron.org/) at 2015/06/01.
   11:  *
   12:  *----------------------------------------------------------------------
   13:  */
   14: 
   15: /*
   16:  *      main.c
   17:  *
   18:  *       Flash ROM write processing
   19:  */
   20: 
   21: #include "flash.h"
   22: 
   23: IMPORT B __flashwr_org[], __flashwr_start[], __flashwr_end[];
   24: 
   25: /*
   26:  * Flash ROM sector erase / write
   27:  *       addr    Flash ROM write start address (must be on a sector boundary)
   28:  *       data    write data start address (RAM)
   29:  *       nsec    number of sectors to write
   30:  *       msg      0 : no message display  no verify write
   31:  *                1 : message display    with verify write
   32:  *               -1 : message display no verify write
   33:  *       return value error code
   34:  */
   35: EXPORT ER writeFrom( UW addr, UW data, W nsec, W msg )
   36: {
   37:         ER (* volatile flashwr_p)( UW addr, void *data, W nsec, BOOL reset );
   38:         BOOL   reset;
   39:         W      sz;
   40:         UB     c;
   41:         ER     er;
   42: 
   43:         /* parameter check */
   44:         if ( nsec <= 0 ) return E_PAR;
   45:         if ( (addr & (FROM_SECSZ-1)) != 0 ) return E_PAR;
   46:         sz = FROM_SECSZ * nsec;
   47:         if ( !inMemArea(addr, addr + sz, MSA_FROM) ) return E_PAR;
   48:         if ( !inMemArea(data, data + sz, MSA_OS|MSA_ERAM|MSA_WRK) )
   49:                                                         return E_PAR;
   50: 
   51:         /* check the write-protect status */
   52:         er = flashwr_protect(addr, nsec);
   53:         if ( er < E_OK ) return er;
   54: 
   55:         /* Confirm if monitor itself is to be written */
   56:         reset = isOverlapMemArea(addr, addr + sz, MSA_MON);
   57:         if ( reset && msg != 0 ) {
   58:                 DSP_S("Update Monitor Area, ");
   59:                 if (msg > 0) {
   60:                         DSP_S("OK (y/n)? ");
   61:                         c = (UB)getChar(1);
   62:                         putChar(c);
   63:                         putChar('\n');
   64:                         if (c != 'Y' && c != 'y') return E_OK;
   65:                 } else if (msg < 0) {
   66:                         DSP_S("Restart System after Writing.");
   67:                 }
   68:         }
   69: 
   70:         /* initial set-up before Flash ROM write */
   71:         flashwr_setup(reset);
   72: 
   73:         if ( __flashwr_start != __flashwr_org ) {
   74:                 /* transfer flashwr() to RAM area */
   75:                 memcpy(__flashwr_start, __flashwr_org,
   76:                                         __flashwr_end - __flashwr_start);
   77:         }
   78: 
   79:         /* Flash ROM sector erase / write
   80:          *       flashwr() is executed in RAM area.
   81:          *        if reset = TRUE, doesn't return.
   82:          *       The offset is too large, and so we use indirect address.
   83:          */
   84:         flashwr_p = &flashwr;
   85:         er = (*flashwr_p)(addr, (UH*)data, nsec, reset);
   86: 
   87:         /* restore after Flash ROM write */
   88:         flashwr_done();
   89: 
   90:         return er;
   91: }
   92: 
   93: /*
   94:  * set up Flash ROM loading processing
   95:  *       mode     0 : set up for loading write data
   96:  *               -1 : set up for writing already loaded data
   97:  *
   98:  *       in the case of setting up loading (mode= 0)
   99:  *         addr returns the following value.
  100:  *           addr[0]  the start address in RAM area for loading data
  101:  *           addr[1]  the end address in RAM area for loading data
  102:  *               addr[1] - addr[0] + 1 = load area size
  103:  *               in principle, load area size matches the size of FLASH ROM.
  104:  *               But if RAM is small, there may be cases
  105:  *               in which load area size is smaller than that of Flash ROM size.
  106:  *           addr[2]  the distance between the data load RAM area and Flash ROM area
  107:  *               adjustment is made so that the addr[0] position is written to the beginning of Flash ROM.
  108:  *               addr[2] = addr[0] - Flash ROM start address
  109:  *
  110:  *       in the case of setting up for writing (mode = -1),
  111:  *         we set the writing area based on the addr value when we called this function using mode = 0.
  112:  *           addr[0]  starting address of loaded data in RAM area (to be written)
  113:  *            addr[1]  ending address of loaded data in RAM area (to be written)
  114:  *               addr[1] - addr[0] + 1 = size of written data
  115:  *           addr[2]  the value remains the same after it was set by mode = 0 (ignored)
  116:  *         the modified values are returned in addr.
  117:  *           addr[0]  Flash ROM write start address
  118:  *           addr[1]  start address of write data in RAM
  119:  *               address will be adjusted to the sector boundary of Flash ROM.
  120:  *           addr[2]  number of sectors to write
  121:  *               Since writing is done in the unit of sectors, the writing will be done from the sector boundary,
  122:  *               areas immediately before and after the designated area may be part of the write operation.
  123:  */
  124: EXPORT void setupFlashLoad( W mode, UW addr[3] )
  125: {
  126:         UW     SECMSK = FROM_SECSZ - 1;
  127:         UW     ofs, sa, romsize, ramtop, ramend;
  128:         const MEMSEG *rom, *ram;
  129: 
  130:         /* Flash ROM capacity */
  131:         rom = MemArea(MSA_FROM, 1);
  132:         romsize = rom->end - rom->top;
  133: 
  134:         /* RAM area for writing */
  135:         ram = MemArea(MSA_OS|MSA_WRK, 1);
  136:         ramtop = (ram->top + SECMSK) & ~SECMSK;
  137:         ramend = ram->end & ~SECMSK;
  138: 
  139:         /* Use the end of RAM area for working area
  140:             if we have enough RAM, we set aside the area as large as the last sector  */
  141:         sa = (ramend - FROM_SECSZ) - romsize;
  142:         if ( sa < ramtop ) sa = ramtop;
  143:         ofs = sa - (UW)rom->top;       /* the distance between the ROM area and RAM work area */
  144: 
  145:         if ( mode >= 0 ) {
  146:                 /* set up loading */
  147:                 addr[0] = rom->top + ofs;             /* RAM address lower limit */
  148:                 addr[1] = rom->end + ofs - 1;         /* RAM address upper limit */
  149:                 addr[2] = ofs;                                /* offset */
  150:                 if ( addr[1] >= ramend ) addr[1] = ramend - 1;
  151:         } else {
  152:                 /* set up writing */
  153:                 sa = addr[0] & ~SECMSK;                       /* RAM start address */
  154:                 addr[2] = ((addr[1] & ~SECMSK) - sa) / FROM_SECSZ + 1;
  155:                                                         /* number of sectors */
  156:                 addr[1] = sa;                         /* RAM start address */
  157:                 addr[0] = sa - ofs;                   /* ROM start address */
  158:         }
  159: }