path: root/main/common/flash.c

/**************************************************************************
 *
 * Copyright (c) 2013 Alcatel-Lucent
 *
 * Alcatel Lucent licenses this file to You under the Apache License,
 * Version 2.0 (the "License"); you may not use this file except in
 * compliance with the License.  A copy of the License is contained the
 * file LICENSE at the top level of this repository.
 * You may also obtain a copy of the License at:
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **************************************************************************
 *
 * flash.c:
 *
 * This file contains the portions of the flash code that are device
 * independent.  Refer to the appropriate device sub-directory for the
 * code that is specific to the flash device on the target.
 *
 * Original author:     Ed Sutter (ed.sutter@alcatel-lucent.com)
 *
 */
#include "config.h"
#include "genlib.h"
#if INCLUDE_FLASH
#include "cpu.h"
#include "flash.h"
#include <ctype.h>
#include "stddefs.h"
#include "tfs.h"
#include "tfsprivate.h"
#include "cli.h"

extern struct flashdesc FlashNamId[];

int     FlashTrace;
int     FlashCurrentBank;
int     sectortoaddr(int,int *,uchar **);

#define SRANGE_ERROR    -1
#define SRANGE_SINGLE   1
#define SRANGE_RANGE    2
#define SRANGE_ALL      3

/* FlashProtectWindow:
 *  Must be set to allow any flash operation to be done on space assumed
 *  to be software protected.
 */
int FlashProtectWindow;

/* FlashBank[]:
 *  This table contains all of the information that is needed to keep the
 *  flash code somewhat generic across multiple flash devices.
 */
struct  flashinfo FlashBank[FLASHBANKS];

#ifdef DISABLE_INTERRUPTS_DURING_FLASHOPS
#define FLASH_INTSDECL              unsigned long oints
#define FLASH_INTSOFF()             oints = intsoff()
#define FLASH_INTSRESTORE(ival)     intsrestore(oints)
#else
#define FLASH_INTSDECL
#define FLASH_INTSOFF()
#define FLASH_INTSRESTORE(ival)
#endif

/* showlockop():
 * Return a string that verbosely represents the flash lock
 * operation...
 */
char *
showlockop(int operation)
{
    switch(operation) {
    case FLASH_LOCK:
        return("lock");
    case FLASH_UNLOCK:
        return("unlock");
    case FLASH_LOCKDWN:
        return("lock_down");
    case FLASH_LOCKQRY:
        return("lock_qry");
    case FLASH_LOCKABLE:
        return("lockable");
    default:
        return("???");
    }
}

/* showflashtype():
 *  Find a match between the incoming id and an entry in the FlashNamId[]
 *  table.  The FlashNamId[] table is part of the device-specific code.
 */
int
showflashtype(ulong id, int showid)
{
    struct flashdesc *fdp;

    if(showid) {
        printf("Flash ID: 0x%lx\n",id);
    }

    fdp = FlashNamId;
    while(fdp->desc) {
        if(id == fdp->id) {
            printf("Device = %s\n",fdp->desc);
            return(0);
        }
        fdp++;
    }
    if(id == FLASHRAM) {
        printf("Device = FLASH-RAM\n");
        return(0);
    }
    printf("Flash id 0x%lx not recognized\n",id);
    return(-1);
}

void
showflashtotal(void)
{
#if FLASHBANKS > 1
    printf("Total of %d banks (0-%d), current default bank: %d\n",
           FLASHBANKS,FLASHBANKS-1,FlashCurrentBank);
#else
    printf("Current flash bank: 0\n");
#endif
}

/* showflashinfo():
 * Dump information about specified flash device.
 */
int
showflashinfo(char *devrange)
{
    uchar   *base;
    struct  sectorinfo *sp;
    struct  flashinfo *fdev;
    char    *range, varname[32];
    int     first_sector_of_device, devtot;
    int     locksupported, sector, lastsector, hdrprinted;

    devtot = 0;
    hdrprinted = 0;
    lastsector = lastflashsector();

    /* An incoming NULL range implies "any" sector...
     */
    if(devrange == 0) {
        showflashtotal();
        range = "any";
    } else {
        range = devrange;
    }

    /* Loop through all sectors on all devices, picking only those
     * sectors that fall in the specified range.
     */
    for(sector = 0; sector <= lastsector; sector++) {
        if(gotachar()) {
            getchar();
            printf("<break>\n");
            break;
        }
        if(!inRange(range,sector)) {
            continue;
        }

        if(!(fdev = snumtofdev(sector))) {
            return(-1);
        }

        first_sector_of_device = fdev->sectors[0].snum;

        if(flashlock(first_sector_of_device,FLASH_LOCKABLE) > 0) {
            locksupported = 1;
        } else {
            locksupported = 0;
        }

        /* If sector is first sector of a device, then print
         * device info also...
         */
        if((sector == first_sector_of_device) && (!strcmp(range,"any"))) {
            if(showflashtype(fdev->id,0) < 0) {
                return(-1);
            }
            printf(" Bank width  : %d\n",fdev->width);
            printf(" Sectors     : %d\n",fdev->sectorcnt);
            printf(" Base addr   : 0x%08lx\n",(ulong)(fdev->base));
            hdrprinted = 0;

            if(devrange == 0) {
                sprintf(varname,"FLASH_BASE_%d",devtot);
                shell_sprintf(varname,"0x%lx",(ulong)(fdev->base));
                sprintf(varname,"FLASH_SCNT_%d",devtot);
                shell_sprintf(varname,"%d",fdev->sectorcnt);
                sprintf(varname,"FLASH_END_%d",devtot);
                shell_sprintf(varname,"0x%lx",(ulong)(fdev->end));
            }
            devtot++;
        }

        if(!hdrprinted) {
            printf(" Sctr TFS?   Begin       End         Size    %s  %s%s",
                   "SWProt?", "Erased?", locksupported ? "  Locked?\n" : "\n");
            hdrprinted = 1;
        }

        sp = &fdev->sectors[sector - first_sector_of_device];
        sectortoaddr(sp->snum,0,&base);
        if((range == 0) || inRange(range,sp->snum)) {
            printf(" %3d   %c   0x%08lx  0x%08lx  0x%06lx   %s       %s      ",
                   sp->snum, tfsspace((char *)base) ? '*' : ' ',
                   (ulong)(sp->begin), (ulong)(sp->end), sp->size,
                   sp->protected ? "yes" : " no",
                   flasherased(sp->begin,sp->end) ? "yes" : " no");
            if(locksupported) {
                switch(flashlock(sp->snum,FLASH_LOCKQRY)) {
                case -1:
                    printf("???");
                    break;
                case 1:
                    printf("yes");
                    break;
                case 0:
                    printf(" no");
                    break;
                }
            }
            printf("\n");
        }
    }

    if(devrange == 0) {
        shell_sprintf("FLASH_DEVTOT","%d",devtot);
    }

    return(0);
}

#ifdef FLASH_COPY_TO_RAM

/* flashopload():
 *  Copy flash operation to ram space.
 *  Note that this function assumes that cache is disabled at this point.
 *  This is important because we are copying text into bss space and if
 *  cache was on, there could be a coherency problem.
 */
int
flashopload(ulong *begin,ulong *end,ulong *copy,int size)
{
    /* Some CPUs have 16bit opcodes and can only do aligned accesses. */
    unsigned short *sBegin = (unsigned short *)begin;
    unsigned short *sEnd = (unsigned short *)end;
    unsigned short *sCopy = (unsigned short *)copy;

    /* Verify space availability: */
    if(((int)end - (int)begin) >= size) {
        printf("flashopload overflow ((0x%lx-0x%lx) > 0x%x)\n",
               (ulong)end,(ulong)begin,size);
        return(-1);
    }

    /* Initially fill the copy space with 0xff so that the space
     * remaining is viewable...
     */
    memset((char *)copy,0xff,size);

    /* Copy function() to RAM, then verify: */
    while(sBegin < sEnd) {
        *sCopy = *sBegin;
        if(*sCopy++ != *sBegin++) {
            printf("flashopload failed\n");
            return(-1);
        }
    }

    return(0);
}

#endif

/* flashtype():
 *  Use the device-specific function pointer to call the routine
 *  relocated to RAM space.
 */
int
flashtype(struct flashinfo *fdev)
{
    return(fdev->fltype(fdev));
}

/* flasherase():
 *  Use the device-specific function pointer to call the routine
 *  relocated to RAM space.
 *  Note that flasherase() is called with a sector number.  The sector
 *  number is relative to the entire system, not just the particular device.
 *  This means that if there is more than one flash device in the system that
 *  the actual sector number (relative to the device) may not be the same
 *  value.  This adjustment is made here so that the underlying code that is
 *  pumped into ram for execution does not have to be aware of this.
 * Return...
 *  1 if successful
 * -1 if failure
 *  0 if sector is protected or locked
 */
int
flasherase(int snum)
{
    uchar *tmp;
    ulong *base, *end;
    int size, rc, dev_snum;
    struct flashinfo *fdev;
    struct sectorinfo *sinfo;

    if(FlashTrace) {
        printf("flasherase(%d)\n",snum);
    }

    if(!(fdev = snumtofdev(snum))) {
        return(-1);
    }

    /* If the device type is RAM, the erase is a bit different...
     */
    if(fdev->id == FLASHRAM) {
        // Use 'tmp' here to eliminate a 3.4 toolset warning.
        sectortoaddr(snum,&size,&tmp);
        base = (ulong *)tmp;
        end = base + (size/sizeof(long));
        while(base < end) {
            *base = 0xffffffff;
            if(*base != 0xffffffff) {
                return(-1);
            }
            base++;
        }
        return(1);
    }

    /* If the sector is soft-protected or locked, return negative
     * and print failure.  If the sector is already erased, then
     * there is no need to issue the device-specific erase algorithm.
     */
    dev_snum = snum - fdev->sectors[0].snum;
    sinfo = &fdev->sectors[dev_snum];
    if(!flasherased(sinfo->begin,sinfo->end)) {
        if((!FlashProtectWindow) && (sinfo->protected)) {
            printf("Sector %d protected\n",snum);
            return(0);
        }

        if(flashlocked(snum,1)) {
            return(0);
        }

        rc = fdev->flerase(fdev,dev_snum);
        if(rc < 0) {
            return(rc);
        }
    }
    return(1);
}


/* flashwrite():
 *  Use the device-specific function pointer to call the routine
 *  relocated to RAM space.
 *  First make a few checks on the request, then write to flash if all
 *  checks succeed.
 */
int
flashwrite(struct flashinfo *fdev,uchar *dest,uchar *src,long bytecnt)
{
    int j, lowsector, highsector, rc, first_sector_of_device;
    register uchar  *dp, *sp, *edp;

    if(FlashTrace) {
        printf("flashwrite(0x%lx,0x%lx,%ld)\n",(long)dest,(long)src,bytecnt);
    }

    if(fdev->id == FLASHRAM) {
        uchar *sp, *dp, *end;
        sp = src;
        dp = dest;
        end = dp+bytecnt;
        while(dp < end) {
            *dp = *sp;
            if(*dp != *sp) {
                return(-1);
            }
            dp++;
            sp++;
        }
        return(0);
    }

    dp = dest;
    sp = src;
    edp = (dest + bytecnt) - 1;
    first_sector_of_device = fdev->sectors[0].snum;

    /* If outside the devices space, return failed.. */
    if((edp < fdev->sectors[0].begin) ||
            (dp > fdev->sectors[fdev->sectorcnt-1].end)) {
        printf("flashwrite() failed: dest out of flash range\n");
        return(-1);
    }

    /* Make sure the destination is not within a protected sector */
    if(FlashProtectWindow == FLASH_PROTECT_WINDOW_CLOSED) {

        /* First determine the sectors that overlap with the
         * flash space to be written...
         */

        lowsector = highsector = -1;
        for(j=0; j<fdev->sectorcnt; j++) {
            if((dp >= fdev->sectors[j].begin) &&
                    (dp <= fdev->sectors[j].end)) {
                lowsector = j;
            }
        }
        for(j=0; j<fdev->sectorcnt; j++) {
            if((edp >= fdev->sectors[j].begin) &&
                    (edp <= fdev->sectors[j].end)) {
                highsector = j;
            }
        }
        if((lowsector == -1) || (highsector == -1)) {
            printf("flashwrite() failed: can't find sector\n");
            return(-1);
        }

        /* Now that the range of affected sectors is known,
         * verify that those sectors are not protected or locked...
         */
        for(j=lowsector; j<=highsector; j++) {
            if(fdev->sectors[j].protected) {
                printf("flashwrite() failed: sector protected\n");
                return(-1);
            }
            if(flashlocked(j+first_sector_of_device,1)) {
                return(-1);
            }
        }
    }

    /* Now make sure that there is no attempt to transition a bit
     * in the affected range from 0 to 1...  A flash write can only
     * bring bits low (erase brings them  high).
     */
    while(dp < edp) {
        if((*dp & *sp) != *sp) {
            printf("flashwrite(0x%lx) failed: bit 0->1 rqst denied.\n",
                   (long)dp);
            return(-1);
        }
        dp++;
        sp++;
        WATCHDOG_MACRO;
    }
    rc = fdev->flwrite(fdev,dest,src,bytecnt);
    if(rc < 0) {
        return(rc);
    }

    /* Assuming everything else appears to have passed, make sure the
     * source and destination addresses match...
     */
    if(memcmp((char *)dest,(char *)src,(int)bytecnt) != 0) {
        printf("flashwrite() post-verify failed.\n");
        return(-1);
    }
    return(0);
}

/* flashewrite():
 *  Use the device-specific function pointer to call the routine
 *  relocated to RAM space.
 */
int
flashewrite(uchar *dest,uchar *src,long bytecnt)
{
    int i;
    struct flashinfo *fdev;

    if(FlashTrace) {
        printf("flashwrite(0x%lx,0x%lx,%ld)\n",(long)dest,(long)src,bytecnt);
    }

    if((fdev = addrtobank(dest)) == 0) {
        return(-1);
    }

    /* Source and destination addresses must be long-aligned. */
    if(((int)src & 3) || ((int)dest & 3)) {
        return(-1);
    }

    /* If the protection window is closed, then verify that no protected
     * sectors will be written over...
     */
    if(FlashProtectWindow == FLASH_PROTECT_WINDOW_CLOSED) {
        for(i=0; i<fdev->sectorcnt; i++) {
            if((((uchar *)dest) > (fdev->sectors[i].end)) ||
                    (((uchar *)dest+bytecnt) < (fdev->sectors[i].begin))) {
                continue;
            } else if(fdev->sectors[i].protected) {
                return(-1);
            }
        }
    }
    return(fdev->flewrite(fdev,dest,src,bytecnt));
}

/* flashlock():
   Use a function pointer to call the routine relocated to RAM space.
*/
int
flashlock(int snum,int operation)
{
    int dev_snum;
    struct flashinfo *fdev;

    if(FlashTrace) {
        printf("flashlock(%d,%s)\n",snum,showlockop(operation));
    }

    fdev = snumtofdev(snum);
    dev_snum = snum - fdev->sectors[0].snum;
    return(fdev->fllock(fdev,dev_snum,operation));
}

int
flashlocked(int snum, int verbose)
{
    if((flashlock(snum,FLASH_LOCKABLE) > 0) &&
            (flashlock(snum,FLASH_LOCKQRY) == 1)) {
        if(verbose) {
            printf("Sector %d locked\n",snum);
        }
        return(1);
    }
    return(0);
}

/* snumtofdev():
 * Return the flash device pointer that corresponds to the incoming
 * sector number.
 */
struct flashinfo *
snumtofdev(int snum)
{
    int dev;
    struct flashinfo *fbnk;

    fbnk = FlashBank;
    for(dev=0; dev<FLASHBANKS; dev++,fbnk++) {
        if((snum >= fbnk->sectors[0].snum) &&
                (snum <= fbnk->sectors[fbnk->sectorcnt-1].snum)) {
            return(fbnk);
        }
    }
    printf("snumtofdev(%d) failed\n",snum);
    return(0);
}

/* addrtosector():
 *  Incoming address is translated to sector number, size of sector
 *  and base of sector.
 *  Return 0 if successful; else -1.
 */
int
addrtosector(uchar *addr,int *sector,int *size,uchar **base)
{
    struct flashinfo *fbnk;
    struct  sectorinfo *sinfo;
    int     dev, sec, i;

    sec = 0;
    fbnk = FlashBank;
    for(dev=0; dev<FLASHBANKS; dev++,fbnk++) {
        for(i=0; i<fbnk->sectorcnt; i++,sec++) {
            sinfo = &fbnk->sectors[i];
            if((addr >= sinfo->begin) && (addr <= sinfo->end)) {
                if(sector) {
                    *sector = sec;
                }
                if(base) {
                    *base = sinfo->begin;
                }
                if(size) {
                    *size = sinfo->size;
                }
                return(0);
            }
        }
    }
    printf("addrtosector(0x%lx) failed\n",(ulong)addr);
    return(-1);
}

/* addrtobank():
 *  From the incoming address, return a pointer to the flash bank that
 *  this address is within.
 */
struct flashinfo *
addrtobank(uchar *addr)
{
    struct flashinfo *fbnk;
    int     dev;

    fbnk = FlashBank;
    for(dev=0; dev<FLASHBANKS; dev++,fbnk++) {
        if((addr >= fbnk->base) && (addr <= fbnk->end)) {
            return(fbnk);
        }
    }
    printf("addrtobank(0x%lx) failed\n",(ulong)addr);
    return(0);
}

int
sectortoaddr(int sector,int *size,uchar **base)
{
    struct flashinfo *fbnk;
    struct  sectorinfo *sinfo;
    int     dev, sec, i;

    sec = 0;
    fbnk = FlashBank;
    for(dev=0; dev<FLASHBANKS; dev++,fbnk++) {
        for(i=0; i<fbnk->sectorcnt; i++,sec++) {
            if(sec == sector) {
                sinfo = &fbnk->sectors[i];
                if(base) {
                    *base = sinfo->begin;
                }
                if(size) {
                    *size = sinfo->size;
                }
                return(0);
            }
        }
    }
    printf("sectortoaddr(%d) failed\n",sector);
    return(-1);
}

/* InFlashSpace():
 * Return 1 if the block of memory is within flash space;
 * else return 0.
 */
int
InFlashSpace(uchar *begin, int size)
{
    int     dev;
    uchar   *end;
    struct flashinfo *fbnk;

    end = begin+size;
    fbnk = FlashBank;
    for(dev=0; dev<FLASHBANKS; dev++,fbnk++) {
        if(((begin >= fbnk->base) && (begin <= fbnk->end)) ||
                ((end >= fbnk->base) && (end <= fbnk->end))) {
            return(1);
        }
    }
    return(0);
}

/* flashbankinfo():
 *  Based on the incoming bank number, return the beginning, end and
 *  number of sectors within that bank.
 */
int
flashbankinfo(int bank,uchar **begin,uchar **end,int *sectorcnt)
{
    struct flashinfo *fbnk;

    if(bank >= FLASHBANKS) {
        return(-1);
    }

    fbnk = &FlashBank[bank];
    if(begin) {
        *begin = fbnk->base;
    }
    if(end) {
        *end = fbnk->end;
    }
    if(sectorcnt) {
        *sectorcnt = fbnk->sectorcnt;
    }
    return(0);
}

/* lastlargesector():
 *  Incoming bank number is used to populate the sector information
 *  (sector number, sector size and address) of the last large sector
 *  in the specified bank.
 *      * from_addr defines the search start address:
 *          * from_addr = 0 means start from the first sector;
 *          * from_addr MUST be sector aligned.
 *      * sectorcnt defines the numbers of contiguous sectors to search across;
 *          * sectorcnt = 0 means search to the last sector.
 *  Return 0 if successful; else -1.
 */
int
lastlargesector(int bank, uchar *from_addr,
                int sectorcnt, int *sector, int *size, uchar **base)
{
    struct flashinfo    *fbnk;
    struct sectorinfo   *sinfo;
    uchar   *largest_sbase;
    int     i, from_sector, to_sector, largest_ssize, largest_snum;

    if(bank >= FLASHBANKS) {
        printf("lastlargesector(%d) failed\n",bank);
        return(-1);
    }

    fbnk = &FlashBank[bank];
    largest_ssize = 0;
    largest_snum = 0;
    largest_sbase = (uchar *)0;

    if(from_addr) {
        if(addrtosector(from_addr, &from_sector, 0, 0) == -1) {
            return(-1);
        }
        if(fbnk->sectors[from_sector].begin != from_addr) {
            printf("lastlargesector failed:\n"
                   "  parameter from_addr (%0x08X) must be sector aligned\n",
                   from_addr);
            return(-1);
        }
    } else {
        from_sector = 0;
    }

    to_sector = from_sector + sectorcnt - 1;
    if(to_sector > fbnk->sectorcnt - 1) {
        to_sector = fbnk->sectorcnt - 1;
    }

    //printf("from_addr   = 0x%08X\n", from_addr);
    //printf("from_sector = %d\n", from_sector);
    //printf("to_sector   = %d\n", to_sector);

    sinfo = &fbnk->sectors[from_sector];
    for(i=from_sector; i<=to_sector; i++, sinfo++) {
        if(sinfo->size >= largest_ssize) {
            largest_ssize = sinfo->size;
            largest_snum = sinfo->snum;
            largest_sbase = sinfo->begin;
        }
    }

    //printf("largest_sbase = 0x%08X\n", largest_sbase);
    //printf("largest_snum  = %d\n", largest_snum);
    //printf("largest_ssize = 0x%08X\n", largest_ssize);

    if(sector) {
        *sector = largest_snum;
    }
    if(size) {
        *size = largest_ssize;
    }
    if(base) {
        *base = largest_sbase;
    }
    return(0);
}

void
LowerFlashProtectWindow()
{
    if(FlashProtectWindow) {
        FlashProtectWindow--;
    }
}

/* AppFlashWrite():
 *  Takes in a source, destination and byte count and converts that to
 *  the appropriate flashwrite() call.  This function supports the possibility
 *  of having one write request span across multiple devices in contiguous
 *  memory space.
 */
int
AppFlashWrite(uchar *dest,uchar *src,long bytecnt)
{
    int     ret;
    FLASH_INTSDECL;
    long    tmpcnt;
    struct flashinfo *fbnk;

    ret = 0;
    while(bytecnt > 0) {
        fbnk = addrtobank((uchar *)dest);
        if(!fbnk) {
            return(-1);
        }

        if((dest + bytecnt) <= fbnk->end) {
            tmpcnt = bytecnt;
        } else {
            tmpcnt = (fbnk->end - dest) + 1;
        }

        FLASH_INTSOFF();
        ret = flashwrite(fbnk,dest,src,tmpcnt);
        FLASH_INTSRESTORE();
        if(ret < 0) {
            printf("AppFlashWrite(0x%lx,0x%lx,%ld) failed (%d)\n",
                   (ulong)dest,(ulong)src,bytecnt,ret);
            break;
        }
        src += tmpcnt;
        dest += tmpcnt;
        bytecnt -= tmpcnt;
    }
    return(ret);
}

#if INCLUDE_FLASHREAD

/* flashread():
 *  Use the device-specific function pointer to call the routine
 *  relocated to RAM space.
 *  First make a few checks on the request, then read from flash
 *  if the checks succeed.
 */
int
flashread(struct flashinfo *fdev,uchar *dest,uchar *src,long bytecnt)
{
    int rc, first_sector_of_device;
    register uchar  *dp, *sp, *edp;

    if(FlashTrace) {
        printf("flashread(0x%lx,0x%lx,%ld)\n",(long)dest,(long)src,bytecnt);
    }

    if(fdev->id == FLASHRAM) {
        uchar *sp, *dp, *end;
        sp = src;
        dp = dest;
        end = dp+bytecnt;
        while(dp < end) {
            *dp = *sp;
            if(*dp != *sp) {
                return(-1);
            }
            dp++;
            sp++;
        }
        return(0);
    }

    dp = dest;
    sp = src;
    edp = (dest + bytecnt) - 1;
    first_sector_of_device = fdev->sectors[0].snum;

    /* If outside the devices space, return failed.. */
    if((edp < fdev->sectors[0].begin) ||
            (dp > fdev->sectors[fdev->sectorcnt-1].end)) {
        printf("flashread() failed: dest out of flash range\n");
        return(-1);
    }

    rc = fdev->flread(fdev,dest,src,bytecnt);
    if(rc < 0) {
        return(rc);
    }

    /* Assuming everything else appears to have passed, make sure the
     * source and destination addresses match...
     */
    if(memcmp((char *)dest,(char *)src,(int)bytecnt) != 0) {
        printf("flashread() post-verify failed.\n");
        return(-1);
    }
    return(0);
}

/* AppFlashRead():
 *  Takes in a source, destination and byte count and converts that to
 *  the appropriate flashwrite() call.  This function supports the possibility
 *  of having one write request span across multiple devices in contiguous
 *  memory space.
 */
int
AppFlashRead(uchar *dest,uchar *src,long bytecnt)
{
    int     ret;
    FLASH_INTSDECL;
    long    tmpcnt;
    struct flashinfo *fbnk;

    ret = 0;
    while(bytecnt > 0) {
        fbnk = addrtobank((uchar *)dest);
        if(!fbnk) {
            return(-1);
        }

        if((dest + bytecnt) <= fbnk->end) {
            tmpcnt = bytecnt;
        } else {
            tmpcnt = (fbnk->end - dest) + 1;
        }

        FLASH_INTSOFF();
        ret = flashread(fbnk,dest,src,tmpcnt);
        FLASH_INTSRESTORE();
        if(ret < 0) {
            printf("AppFlashRead(0x%lx,0x%lx,%ld) failed (%d)\n",
                   (ulong)dest,(ulong)src,bytecnt,ret);
            break;
        }
        src += tmpcnt;
        dest += tmpcnt;
        bytecnt -= tmpcnt;
    }
    return(ret);
}
#endif

int
lastflashsector(void)
{
    int lastsnum;
    struct  flashinfo *lastfbnk;

    lastfbnk = &FlashBank[FLASHBANKS-1];
    lastsnum = lastfbnk->sectors[lastfbnk->sectorcnt-1].snum;
    return(lastsnum);
}

int
AppFlashEraseAll()
{
    FLASH_INTSDECL;
    int     ret, snum, lastsnum;

    ret = 0;
    FLASH_INTSOFF();

    /* Loop through all sectors of all banks...
     */
    lastsnum = lastflashsector();
    for(snum=0; snum<=lastsnum; snum++) {
        WATCHDOG_MACRO;
        ret = flasherase(snum);
        if(ret <= 0) {
            break;
        }
    }

    FLASH_INTSRESTORE();
    return(ret);
}

/* Erase the flash sector specified. */
int
AppFlashErase(int snum) /* erase specified sector */
{
    int     ret;
    FLASH_INTSDECL;

    FLASH_INTSOFF();
    ret = flasherase(snum);
    FLASH_INTSRESTORE();
    return(ret);
}

/* sectorProtect():
 *  Set or clear (based on value of protect) the protected flag for the
 *  specified range of sectors...
 *  This supports incoming ranges that can be dash and/or comma delimited.
 *  For example a range can be "0", "0-3", or "0,2-4", etc...
 */
int
sectorProtect(char *range, int protect)
{
    struct  flashinfo *fbnk;
    int i, dev, snum;

    snum = 0;
    for(dev = 0; dev < FLASHBANKS; dev++) {
        fbnk = &FlashBank[dev];
        for(i = 0; i < fbnk->sectorcnt; i++,snum++) {
            if((range == 0) || (*range == 0) || inRange(range,snum)) {
                fbnk->sectors[i].protected = protect;
            }
        }
    }
    return(0);
}

#ifdef FLASHRAM_BASE

struct sectorinfo sinfoRAM[FLASHRAM_SECTORCOUNT];

/* FlashRamInit():
 * This monitor supports TFS space allocated across multiple flash devices
 * that may not be in contiguous memory space.  To allow RAM to be seen
 * as a "flash-like" device to TFS, we set it up in sectors similar to
 * those in a real flash device.
 * Input...
 *  snum:   All the "flash" space is broken up into individual sectors.
 *          This is the starting sector number that is to be used for
 *          the block of sectors within this RAM space.
 *  fbnk:   Pointer to the structure that must be populated with the
 *          flash bank information.  Usually this contains pointers to the
 *          functions that operate on the flash; but for RAM they aren't
 *          necessary.
 *  sinfo:  Table populated with the characteristics (size, start, etc...)
 *          of each sector.
 *  ssizes: A table containing the size of each of the sectors.  This is
 *          copied to the sinfo space.  If this pointer is NULL, then
 *          this function sets all sector sizes to FLASHRAM_SECTORSIZE.
 */
int
FlashRamInit(int snum, int scnt, struct flashinfo *fbnk,
             struct sectorinfo *sinfo, int *ssizes)
{
    int i;
    uchar   *begin;

    /* FLASHRAM_SECTORCOUNT (in config.h) must match the number of sectors
     * allocated to the flash ram device in flashdev.c...
     */
    if(scnt != FLASHRAM_SECTORCOUNT) {
        printf("Warning: flashram sector count inconsistency\n");
    }

    fbnk->id = FLASHRAM;                    /* Device id. */
    fbnk->base = (uchar *)FLASHRAM_BASE;    /* Base address of bank. */
    fbnk->end = (uchar *)FLASHRAM_END;      /* End address of bank. */
    fbnk->sectorcnt = scnt;                 /* Number of sectors. */
    fbnk->width = 1;                        /* Width (in bytes). */
    fbnk->fltype = FlashOpNotSupported;     /* Flashtype() function. */
    fbnk->flerase = FlashOpNotSupported;    /* Flasherase() function. */
    fbnk->flwrite = FlashOpNotSupported;    /* Flashwrite() function. */
    fbnk->flewrite = FlashOpNotSupported;   /* Flashewrite() function. */
    fbnk->fllock = FlashOpNotSupported;     /* Flashlock() function. */
    fbnk->sectors = sinfo;                  /* Ptr to sector size table. */
    begin = fbnk->base;
    for(i=0; i<fbnk->sectorcnt; i++,snum++) {
        sinfo[i].snum = snum;
        if(ssizes == 0) {
            sinfo[i].size = FLASHRAM_SECTORSIZE;
        } else {
            sinfo[i].size = ssizes[i];
        }
        sinfo[i].begin = begin;
        sinfo[i].end = sinfo[i].begin + sinfo[i].size - 1;
        sinfo[i].protected = 0;
        begin += sinfo[i].size;
    }

    return(snum);
}
#endif

char *FlashHelp[] = {
    "Flash memory operations",
    "{op} [args]",
#if INCLUDE_VERBOSEHELP
    "Ops...",
    "  opw",
    "  init",
    "  type",
    "  bank [#]",
    "  prot {rnge}",
    "  info [rnge]",
    "  unprot {rnge}",
    "  lock {rnge}",
    "  unlock [rnge]",
    "  lockdwn {rnge}",
    "  erase {rnge}",
    "  trace {lvl}",
    "  write {dest} {src} {byte_cnt}",
    "  ewrite {dest} {src} {byte_cnt}",
    "",
    "  rnge = range of affected sectors",
    "   Range syntax examples: <1> <1-5> <1,3,7> <all>",
#endif
    0,
};

/* FlashCmd():
 *  Code that handles the user interface.  See FlashHelp[] below for usage.
 */
int
FlashCmd(int argc,char *argv[])
{
    int     ret;
    FLASH_INTSDECL;
    ulong   dest, src;
    long    bytecnt, rslt;
    struct  flashinfo *fbnk;

    FLASH_INTSOFF();

    fbnk = &FlashBank[FlashCurrentBank];
    ret = CMD_SUCCESS;

    if(strcmp(argv[1],"init") == 0) {
        FlashInit();
    } else if(strcmp(argv[1],"info") == 0) {
        showflashinfo(argv[2]);
    } else if(strcmp(argv[1],"type") == 0) {
        showflashtype((ulong)flashtype(fbnk),1);
    } else if(strcmp(argv[1],"trace") == 0) {
        if(argc == 3) {
            FlashTrace = atoi(argv[2]);
        } else if(argc == 2) {
            printf("Flash trace lvl: %d\n",FlashTrace);
        } else {
            return(CMD_PARAM_ERROR);
        }
    } else if(strcmp(argv[1],"bank") == 0)  {
        int tmpbank;
        if(argc == 3) {
            tmpbank = atoi(argv[2]);
            if(tmpbank < FLASHBANKS) {
                FlashCurrentBank = tmpbank;
            } else {
                printf("Bank %d out of range\n",tmpbank);
                return(CMD_PARAM_ERROR);
            }
            printf("Subsequent flash ops apply to bank %d\n",
                   FlashCurrentBank);
        } else {
            showflashtotal();
        }
    } else if(strcmp(argv[1],"ewrite") == 0) {
        if(argc == 5) {
            dest = strtoul(argv[2],(char **)0,0);
            src = strtoul(argv[3],(char **)0,0);
            bytecnt = (long)strtoul(argv[4],(char **)0,0);
            rslt = flashewrite((uchar *)dest,(uchar *)src,bytecnt);
            if(rslt < 0) {
                printf("ewrite failed (%ld)\n",rslt);
                ret = CMD_FAILURE;
            }
        } else {
            ret = CMD_PARAM_ERROR;
        }
    } else if(!strcmp(argv[1],"write")) {
        if(argc == 5) {
            dest = strtoul(argv[2],(char **)0,0);
            src = strtoul(argv[3],(char **)0,0);
            bytecnt = (long)strtoul(argv[4],(char **)0,0);
            rslt = AppFlashWrite((uchar *)dest,(uchar *)src,bytecnt);
            if(rslt < 0) {
                printf("Write failed (%ld)\n",rslt);
                ret = CMD_FAILURE;
            }
        } else {
            ret = CMD_PARAM_ERROR;
        }
    }
#if INCLUDE_FLASHREAD
    else if(!strcmp(argv[1],"read")) {
        if(argc == 5) {
            dest = strtoul(argv[2],(char **)0,0);
            src = strtoul(argv[3],(char **)0,0);
            bytecnt = (long)strtoul(argv[4],(char **)0,0);
            rslt = AppFlashRead((uchar *)dest,(uchar *)src,bytecnt);
            if(rslt < 0) {
                printf("Read failed (%ld)\n",rslt);
                ret = CMD_FAILURE;
            }
        } else {
            ret = CMD_PARAM_ERROR;
        }
    }
#endif
    else if(!strcmp(argv[1],"opw")) {
        if(getUsrLvl() != MAXUSRLEVEL) {
            printf("Must be user level %d\n",MAXUSRLEVEL);
        } else {
            FlashProtectWindow = 2;
        }
    } else if(!strcmp(argv[1],"unprot")) {
        if(argc != 3) {
            ret = CMD_PARAM_ERROR;
        } else {
            sectorProtect(argv[2],0);
        }
    } else if(!strcmp(argv[1],"prot")) {
        if(argc != 3) {
            ret = CMD_PARAM_ERROR;
        } else {
            sectorProtect(argv[2],1);
        }
    } else if(!strcmp(argv[1],"erase")) {
        if(argc != 3) {
            ret = CMD_PARAM_ERROR;
        } else {
            uchar *base;
            int rc, snum, size, stot = 0;

            if(strncmp(argv[2],"0x",2) == 0) {
                ulong begin, end;
                char *dash = strchr(argv[2],'-');

                begin = end = strtoul(argv[2],0,0);
                if(dash) {
                    end = strtoul(dash+1,0,0);
                }

                while(begin <= end) {
                    if(addrtosector((uchar *)begin,&snum,&size,&base) < 0) {
                        break;
                    }
                    begin = (ulong)base;
                    rc = flasherase(snum);
                    if(rc != 1) {
                        printf("Erase failed (%d)\n",rc);
                        ret = CMD_FAILURE;
                        break;
                    }
                    stot++;
                    begin += size;
                }
            } else {
                int last;

                last = lastflashsector();
                for(snum=0; snum<=last; snum++) {
                    int rc;

                    if((argv[2] == 0) || inRange(argv[2],snum)) {
                        ticktock();
                        rc = flasherase(snum);
                        if(rc != 1) {
                            printf("Erase failed (%d)\n",rc);
                            ret = CMD_FAILURE;
                            break;
                        }
                        stot++;
                    }
                }
            }
            printf("%d sectors erased\n",stot);
        }
    } else if((!strcmp(argv[1],"lock")) || (!strcmp(argv[1],"unlock")) ||
              (!strcmp(argv[1],"lockdwn"))) {
        int operation, snum;

        if(!strcmp(argv[1],"lock")) {
            operation = FLASH_LOCK;
        } else if(!strcmp(argv[1],"unlock")) {
            operation = FLASH_UNLOCK;
        } else {
            operation = FLASH_LOCKDWN;
        }

        if(argc == 2) {
#ifdef FLASH_PROTECT_RANGE
            argv[2] = FLASH_PROTECT_RANGE;
            argc = 3;
            printf("Applying %s to sector(s) %s...\n",argv[1],argv[2]);
#else
            printf("Monitor not built with specified protection range\n");
            ret = CMD_FAILURE;
#endif
        }

        if(argc != 3) {
            ret = CMD_PARAM_ERROR;
        } else {
            int last;
            struct flashinfo *fdev;

            last = lastflashsector();
            for(snum=0; snum<=last; snum++) {
                if(inRange(argv[2],snum)) {
                    ticktock();
                    if((fdev = snumtofdev(snum)) == 0) {
                        ret = CMD_FAILURE;
                        break;
                    }
                    if(flashlock(fdev->sectors[0].snum,FLASH_LOCKABLE) <= 0) {
                        printf("Sector %d does not support %s\n",snum,argv[1]);
                        ret = CMD_FAILURE;
                        break;
                    }
                    rslt = flashlock(snum,operation);
                    if(rslt < 0) {
                        printf("%s failed (%ld) at sector %d\n",
                               argv[1],rslt,snum);
                        ret = CMD_FAILURE;
                        break;
                    }
                }
            }
        }
    } else {
        ret = CMD_PARAM_ERROR;
    }

    FLASH_INTSRESTORE();
    return(ret);
}

/* FlashOpOverride():
 * This function is used by monlib to provide the application with the
 * ability to override the underlying flash operations with functions
 * provided by the application.
 * The finfo parameter is actually a flashinfo pointer; set void here
 * to eliminate confusion when used with monlib.h and the application .
 */
int
FlashOpOverride(void *finfo, int get, int bank)
{
    char *src, *dst;
    struct flashinfo *fdev;

    if((!finfo) || (bank >= FLASHBANKS)) {
        return(-1);
    }

    fdev = &FlashBank[bank];

    if(get) {
        src = (char *)fdev;
        dst = (char *)finfo;
    } else {
        src = (char *)finfo;
        dst = (char *)fdev;
    }
    memcpy(dst,src,sizeof(struct flashinfo));
    return(0);
}

int
FlashOpNotSupported(void)
{
    if(FlashTrace) {
        printf("flash operation not supported\n");
    }

    return(-1);
}

/* Used as a placeholder for the flash drivers that don't
 * support flash lock...
 */
int
FlashLockNotSupported(struct flashinfo *fdev,int snum,int operation)
{
    if(operation == FLASH_LOCKABLE) {
        return(0);
    } else {
        return(-1);
    }
}

#endif

/* flasherased():
 * Return 1 if range of memory is all 0xff; else 0.
 * Scan through the range of memory specified by begin-end (inclusive)
 * looking for anything that is not 0xff.  Do this in three sections so
 * that the pointers can be 4-byte aligned for the bulk of the comparison
 * range...
 * The beginning steps through as a char pointer until aligned on a 4-byte
 * boundary.  Then do ulong * comparisons until the just before the end
 * where we once again use char pointers to align on the last few
 * non-aligned bytes (if any).
 */
int
flasherased(unsigned char *begin, unsigned char *end)
{
    unsigned long *lp, *lp1, ltmp;

    /* If begin is greater than end, the range is illegal.  The only
     * exception to this is the case where end may be zero.  This is
     * considered an exception because in cases where we are dealing
     * with the last sector of a device that sits at the end of memory
     * space, the end point will wrap.
     */
    if((begin > end) && (end != 0)) {
        printf("flasherased(): bad range\n");
        return(0);
    }

    /* Get pointers aligned so that we can do the bulk of the comparison
     * with long pointers...
     */
    while(((long)begin & 3) && (begin <= end)) {
        if(*begin != 0xff) {
            return(0);
        }
        begin++;
    }
    if(begin > end) {
        return(1);
    }

    lp = (unsigned long *)begin;
    ltmp = (unsigned long)end;
    ltmp &= ~3;
    lp1 = (unsigned long *)ltmp;

    while(lp != lp1) {
        if(*lp != 0xffffffff) {
            return(0);
        }
        lp++;

#ifdef WATCHDOG_ENABLED
        /* For each 64K through this loop, tickle the watchdog.
         */
        if((0xffff & (unsigned long)lp) == 0) {
            WATCHDOG_MACRO;
        }
#endif
    }
    if(lp > (unsigned long *)end) {
        return(1);
    }

    begin = (unsigned char *)lp;
    do {
        if(*begin != 0xff) {
            return(0);
        }
    } while(begin++ != end);
    return(*end == 0xff);
}