flash.c

完整的Bell实验室的嵌入式文件系统TFS

    /* 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);
        }
    }

    if (flashopload((ulong *)FLASHEWRITE,(ulong *)ENDFLASHEWRITE) < 0)
        return(-1);
    return(flashfunc(fdev,dest,src,bytecnt));
}

AppFlashWrite(dest,src,bytecnt)
ulong   *src, *dest;
long bytecnt;
{
    ulong   oints;
    int ret;

    oints = intsoff();
    ret = flashwrite(&FlashBank[0],dest,src,bytecnt);
    intsrestore(oints);
    if (ret < 0)
        printf("AppFlashWrite(0x%x,0x%x,%d) failed\n", dest,src,bytecnt);
    return(ret);
}

AppFlashEraseAll()
{
    ulong   oints;
    int ret;

    oints = intsoff();
    ret = flasherase(&FlashBank[0],ALL_SECTORS);
    intsrestore(oints);
    return(ret);
}

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

    oints = intsoff();
    ret = flasherase(&FlashBank[0],snum);
    intsrestore(oints);
    return(ret);
}

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

    oints = intsoff();

    fbnk = &FlashBank[bank];
    ret = 0;

    if (strcmp(argv[1],"init") == 0)
        FlashInit();
    else if (strcmp(argv[1],"info") == 0)
        showflashinfo(fbnk);
    else if (strcmp(argv[1],"bank") == 0)  {
        if (argc == 3) {
            bank = atoi(argv[2]);
            printf("Subsequent flash ops apply to bank %d\n",bank);
        }
        else 
            printf("Current flash bank: %d\n",bank);
    }
    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);
            if (flashewrite(fbnk,dest,src,bytecnt) == -1)
                printf("ewrite failed\n");
        }
        else
            ret = -1;
    }
    else if (strcmp(argv[1],"write") == 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 = flashwrite(fbnk,dest,src,bytecnt);
            if (rslt == -1)
                printf("Write failed\n");
        }
        else
            ret = -1;
    }
    else if (strcmp(argv[1],"opw") == 0) {
        FlashProtectWindow = 2;
    }
    else if (strcmp(argv[1],"erase") == 0) {
        if (argc != 3)
            printf("Bad 'erase' arg count...");
        else if (strcmp(argv[2],"all") == 0)
            snum = ALL_SECTORS;
        else 
            snum = (int)strtoul(argv[2],(char **)0,0);

        rslt = flasherase(fbnk,snum);
        if (rslt == -1)
            printf("Erase failed\n");
    }
    else {
        ret = -1;
    }

    intsrestore(oints);
    return(ret);
}

char *FlashHelp[] = {
    "Flash memory operations",
    "{op} [args]",
    "Ops...",
    "  opw",
    "  info",
    "  init",
    "  bank [#]",
    "  erase {# | all}",
    "  write {dest} {src} {byte_cnt}",
    "  ewrite {dest} {src} {byte_cnt}",
    0,
};

/* FlashInit():
   Initialize data structures for each bank of flash...
*/
FlashInit()
{
    int i;
    long    size;

    FlashBank[0].width = FLASH_BANK0_WIDTH;
    FlashBank[0].base = (unsigned char *)FLASH_BANK0_BASE_ADDR;
    FlashBankInit(&FlashBank[0]);

    /* Assume monitor resides in bank0 and that it uses the first 128K */
    /* of code space (actually it uses much less, but different options */
    /* within the monitor are configurable, so assume worst case). */
    /* These "monitor-owned" sectors should be marked as protected. */
    size = 0;
    for (i=0;((i<FlashBank[0].sectorcnt)&(size<FLASH_PROTECT_SIZE));i++) {
        FlashBank[0].sectors[i].protected = 1;
        size += FlashBank[0].sectors[i].size;
    }
    /* Additional flash memory banks would be initialized here... */
    return(0);
}

/* FlashBankInit():
   Initialize flash structures and determine flash device type.
*/
FlashBankInit(fbnk)
struct flashinfo *fbnk;
{
    int i;
    uchar   *begin;

    flashtype(fbnk);
    switch(fbnk->id) {
    case AMD29LV160B:
    case SWAPPED_AMD29LV160B:
        fbnk->sectorcnt = sizeof(SectorSizes160B)/sizeof(int);
        begin = fbnk->base;
        for(i=0;i<fbnk->sectorcnt;i++) {
            fbnk->sectors[i].size = SectorSizes160B[i];
            fbnk->sectors[i].begin = begin;
            fbnk->sectors[i].end =
                fbnk->sectors[i].begin + fbnk->sectors[i].size - 1;
            fbnk->sectors[i].protected = 0;
            begin += SectorSizes160B[i];
        }
        break;
    }
    return(0);
}

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

    sec = 0;
    for(dev=0;dev<FLASHBANKS;dev++) {
        fbnk = &FlashBank[dev];
        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%x) failed\n",addr);
    return(-1);
}

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

    sec = 0;
    for(dev=0;dev<FLASHBANKS;dev++) {
        fbnk = &FlashBank[dev];
        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);
}

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

int
FlashOpError()
{
    printf("Flash-op width index error\n");
    return(0);
}

#endif