OpenCores
URL https://opencores.org/ocsvn/s6soc/s6soc/trunk

Subversion Repositories s6soc

[/] [s6soc/] [trunk/] [sw/] [host/] [flashdrvr.cpp] - Diff between revs 19 and 45

Go to most recent revision | Show entire file | Details | Blame | View Log

Rev 19 Rev 45
Line 9... Line 9...
// Creator:     Dan Gisselquist
// Creator:     Dan Gisselquist
//              Gisselquist Tecnology, LLC
//              Gisselquist Tecnology, LLC
//
//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//
//
// Copyright (C) 2016, Gisselquist Technology, LLC
// Copyright (C) 2016-2017, Gisselquist Technology, LLC
//
//
// This program is free software (firmware): you can redistribute it and/or
// This program is free software (firmware): you can redistribute it and/or
// modify it under the terms of  the GNU General Public License as published
// modify it under the terms of  the GNU General Public License as published
// by the Free Software Foundation, either version 3 of the License, or (at
// by the Free Software Foundation, either version 3 of the License, or (at
// your option) any later version.
// your option) any later version.
Line 21... Line 21...
// This program is distributed in the hope that it will be useful, but WITHOUT
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY or
// ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY or
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
// for more details.
// for more details.
//
//
 
// You should have received a copy of the GNU General Public License along
 
// with this program.  (It's in the $(ROOT)/doc directory.  Run make with no
 
// target there if the PDF file isn't present.)  If not, see
 
// <http://www.gnu.org/licenses/> for a copy.
 
//
// License:     GPL, v3, as defined and found on www.gnu.org,
// License:     GPL, v3, as defined and found on www.gnu.org,
//              http://www.gnu.org/licenses/gpl.html
//              http://www.gnu.org/licenses/gpl.html
//
//
//
//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//
//
//
//
//
 
#include <stdio.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdlib.h>
 
#include <stdint.h>
#include <unistd.h>
#include <unistd.h>
#include <strings.h>
#include <strings.h>
#include <ctype.h>
#include <ctype.h>
#include <string.h>
#include <string.h>
#include <signal.h>
#include <signal.h>
#include <assert.h>
#include <assert.h>
 
 
#include "devbus.h"
#include "devbus.h"
#include "regdefs.h"
#include "regdefs.h"
#include "flashdrvr.h"
#include "flashdrvr.h"
 
#include "byteswap.h"
 
 
const   bool    HIGH_SPEED = false;
const   bool    HIGH_SPEED = false;
 
 
void    FLASHDRVR::flwait(void) {
void    FLASHDRVR::flwait(void) {
        DEVBUS::BUSW    v;
        DEVBUS::BUSW    v;
Line 72... Line 78...
                }
                }
        } while(v & ERASEFLAG);
        } while(v & ERASEFLAG);
}
}
 
 
bool    FLASHDRVR::erase_sector(const unsigned sector, const bool verify_erase) {
bool    FLASHDRVR::erase_sector(const unsigned sector, const bool verify_erase) {
        DEVBUS::BUSW    page[SZPAGE];
        DEVBUS::BUSW    page[SZPAGEW];
 
 
        printf("Erasing sector: %08x\n", sector);
        if (m_debug) printf("Erasing sector: %08x\n", sector);
        m_fpga->writeio(R_QSPI_EREG, DISABLEWP);
        m_fpga->writeio(R_QSPI_EREG, DISABLEWP);
        m_fpga->writeio(R_QSPI_EREG, ERASEFLAG + sector);
        m_fpga->writeio(R_QSPI_EREG, ERASEFLAG + (sector>>2));
 
 
        // If we're in high speed mode and we want to verify the erase, then
        // If we're in high speed mode and we want to verify the erase, then
        // we can skip waiting for the erase to complete by issueing a read
        // we can skip waiting for the erase to complete by issueing a read
        // command immediately.  As soon as the erase completes the read will
        // command immediately.  As soon as the erase completes the read will
        // begin sending commands back.  This allows us to recover the lost 
        // begin sending commands back.  This allows us to recover the lost 
        // time between the interrupt and the next command being received.
        // time between the interrupt and the next command being received.
        if  ((!HIGH_SPEED)||(!verify_erase)) {
        if  ((!HIGH_SPEED)||(!verify_erase)) {
                flwait();
                flwait();
 
 
 
                if (m_debug) {
                printf("@%08x -> %08x\n", R_QSPI_EREG,
                printf("@%08x -> %08x\n", R_QSPI_EREG,
                                m_fpga->readio(R_QSPI_EREG));
                                m_fpga->readio(R_QSPI_EREG));
                printf("@%08x -> %08x\n", R_QSPI_SREG,
                printf("@%08x -> %08x\n", R_QSPI_SREG,
                                m_fpga->readio(R_QSPI_SREG));
                                m_fpga->readio(R_QSPI_SREG));
                printf("@%08x -> %08x\n", sector,
                printf("@%08x -> %08x\n", sector,
                                m_fpga->readio(sector));
                                m_fpga->readio(sector));
        }
        }
 
        }
 
 
        // Now, let's verify that we erased the sector properly
        // Now, let's verify that we erased the sector properly
        if (verify_erase) {
        if (verify_erase) {
                for(int i=0; i<NPAGES; i++) {
                for(int i=0; i<NPAGES; i++) {
                        m_fpga->readi(sector+i*SZPAGE, SZPAGE, page);
                        m_fpga->readi(sector+i*SZPAGEW, SZPAGEW, page);
                        for(int i=0; i<SZPAGE; i++)
                        for(int i=0; i<SZPAGEW; i++)
                                if (page[i] != 0xffffffff)
                                if (page[i] != 0xffffffff)
                                        return false;
                                        return false;
                }
                }
        }
        }
 
 
        return true;
        return true;
}
}
 
 
bool    FLASHDRVR::write_page(const unsigned addr, const unsigned len,
bool    FLASHDRVR::page_program(const unsigned addr, const unsigned len,
                const unsigned *data, const bool verify_write) {
                const char *data, const bool verify_write) {
        DEVBUS::BUSW    buf[SZPAGE];
        DEVBUS::BUSW    buf[SZPAGEW], bswapd[SZPAGEW];
 
 
        assert(len > 0);
        assert(len > 0);
        assert(len <= PGLEN);
        assert(len <= PGLENB);
        assert(PAGEOF(addr)==PAGEOF(addr+len-1));
        assert(PAGEOF(addr)==PAGEOF(addr+len-1));
 
 
        if (len <= 0)
        if (len <= 0)
                return true;
                return true;
 
 
 
        bool    empty_page = true;
 
        for(unsigned i=0; i<len; i+=4) {
 
                DEVBUS::BUSW v;
 
                v = buildword((const unsigned char *)&data[i]);
 
                bswapd[(i>>2)] = v;
 
                if (v != 0xffffffff)
 
                        empty_page = false;
 
        }
 
 
 
        if (!empty_page) {
        // Write the page
        // Write the page
        m_fpga->writeio(R_ICONTROL, ISPIF_DIS);
        m_fpga->writeio(R_ICONTROL, ISPIF_DIS);
        m_fpga->clear();
        m_fpga->clear();
        m_fpga->writeio(R_ICONTROL, ISPIF_EN);
        m_fpga->writeio(R_ICONTROL, ISPIF_EN);
        printf("Writing page: 0x%08x - 0x%08x\n", addr, addr+len-1);
                printf("Writing page: 0x%08x - 0x%08x\r", addr, addr+len-1);
        m_fpga->writeio(R_QSPI_EREG, DISABLEWP);
        m_fpga->writeio(R_QSPI_EREG, DISABLEWP);
        m_fpga->writei(addr, len, data);
                m_fpga->writei(addr, (len>>2), bswapd);
 
                fflush(stdout);
 
 
        // If we're in high speed mode and we want to verify the write, then
                // If we're in high speed mode and we want to verify the write,
        // we can skip waiting for the write to complete by issueing a read
                // then we can skip waiting for the write to complete by
        // command immediately.  As soon as the write completes the read will
                // issueing a read command immediately.  As soon as the write
        // begin sending commands back.  This allows us to recover the lost 
                // completes the read will begin sending commands back.  This
        // time between the interrupt and the next command being received.
                // allows us to recover the lost time between the interrupt and
 
                // the next command being received.
        flwait();
        flwait();
 
        }
        // if ((!HIGH_SPEED)||(!verify_write)) { }
        // if ((!HIGH_SPEED)||(!verify_write)) { }
        if (verify_write) {
        if (verify_write) {
                // printf("Attempting to verify page\n");
                // printf("Attempting to verify page\n");
                // NOW VERIFY THE PAGE
                // NOW VERIFY THE PAGE
                m_fpga->readi(addr, len, buf);
                m_fpga->readi(addr, len>>2, buf);
                for(unsigned i=0; i<len; i++) {
                for(unsigned i=0; i<(len>>2); i++) {
                        if (buf[i] != data[i]) {
                        if (buf[i] != bswapd[i]) {
                                printf("\nVERIFY FAILS[%d]: %08x\n", i, i+addr);
                                printf("\nVERIFY FAILS[%d]: %08x\n", i, (i<<2)+addr);
                                printf("\t(Flash[%d]) %08x != %08x (Goal[%08x])\n",
                                printf("\t(Flash[%d]) %08x != %08x (Goal[%08x])\n",
                                        i, buf[i], data[i], i+addr);
                                        (i<<2), buf[i], bswapd[i], (i<<2)+addr);
                                return false;
                                return false;
                        }
                        }
                } // printf("\nVerify success\n");
                } // printf("\nVerify success\n");
        } return true;
        } return true;
}
}
 
 
bool    FLASHDRVR::write(const unsigned addr, const unsigned len,
bool    FLASHDRVR::write(const unsigned addr, const unsigned len,
                const unsigned *data, const bool verify) {
                const char *data, const bool verify) {
        // Work through this one sector at a time.
        // Work through this one sector at a time.
        // If this buffer is equal to the sector value(s), go on
        // If this buffer is equal to the sector value(s), go on
        // If not, erase the sector
        // If not, erase the sector
 
 
        /*
        for(unsigned s=SECTOROF(addr); s<SECTOROF(addr+len+SECTORSZB-1);
        fprintf(stderr, "FLASH->write(%08x, %d, ..., %s)\n", addr, len,
                        s+=SECTORSZB) {
                        (verify)?"Verify":"");
 
        */
 
        // m_fpga->writeio(R_QSPI_CREG, 2);
 
        // m_fpga->readio(R_VERSION);   // Read something innocuous
 
        // m_fpga->writeio(R_QSPI_SREG, 0);
 
        // m_fpga->readio(R_VERSION);   // Read something innocuous
 
 
 
        for(unsigned s=SECTOROF(addr); s<SECTOROF(addr+len+SECTORSZ-1); s+=SECTORSZ) {
 
                // printf("IN LOOP, s=%08x\n", s);
 
                // Do we need to erase?
                // Do we need to erase?
                bool    need_erase = false;
                bool    need_erase = false, need_program = false;
                unsigned newv = 0; // (s<addr)?addr:s;
                unsigned newv = 0; // (s<addr)?addr:s;
                {
                {
                        DEVBUS::BUSW    *sbuf = new DEVBUS::BUSW[SECTORSZ];
                        char *sbuf = new char[SECTORSZB];
                        const DEVBUS::BUSW *dp;
                        const char *dp; // pointer to our "desired" buffer
                        unsigned        base,ln;
                        unsigned        base,ln;
 
 
                        base = (addr>s)?addr:s;
                        base = (addr>s)?addr:s;
                        ln=((addr+len>s+SECTORSZ)?(s+SECTORSZ):(addr+len))-base;
                        ln=((addr+len>s+SECTORSZB)?(s+SECTORSZB):(addr+len))-base;
                        m_fpga->readi(base, ln, sbuf);
                        m_fpga->readi(base, ln>>2, (uint32_t *)sbuf);
 
                        byteswapbuf(ln>>2, (uint32_t *)sbuf);
 
 
                        dp = &data[base-addr];
                        dp = &data[base-addr];
                        for(unsigned i=0; i<ln; i++) {
                        for(unsigned i=0; i<ln; i++) {
                                if ((sbuf[i]&dp[i]) != dp[i]) {
                                if ((sbuf[i]&dp[i]) != dp[i]) {
 
                                        if (m_debug) {
                                        printf("\nNEED-ERASE @0x%08x ... %08x != %08x (Goal)\n",
                                        printf("\nNEED-ERASE @0x%08x ... %08x != %08x (Goal)\n",
                                                i+base-addr, sbuf[i], dp[i]);
                                                i+base-addr, sbuf[i], dp[i]);
 
                                        }
                                        need_erase = true;
                                        need_erase = true;
                                        newv = i+base;
                                        newv = (i&-4)+base;
                                        break;
                                        break;
                                } else if ((sbuf[i] != dp[i])&&(newv == 0)) {
                                } else if ((sbuf[i] != dp[i])&&(newv == 0))
                                        // if (newv == 0)
                                        newv = (i&-4)+base;
                                                // printf("MEM[%08x] = %08x (!= %08x (Goal))\n",
 
                                                        // i+base, sbuf[i], dp[i]);
 
                                        newv = i+base;
 
                                }
 
                        }
                        }
                }
                }
 
 
                if (newv == 0)
                if (newv == 0)
                        continue; // This sector already matches
                        continue; // This sector already matches
 
 
                // Just erase anyway
                // Erase the sector if necessary
                if (!need_erase)
                if (!need_erase) {
                        printf("NO ERASE NEEDED\n");
                        if (m_debug) printf("NO ERASE NEEDED\n");
                else {
                } else {
                        printf("ERASING SECTOR: %08x\n", s);
                        printf("ERASING SECTOR: %08x\n", s);
                        if (!erase_sector(s, verify)) {
                        if (!erase_sector(s, verify)) {
                                printf("SECTOR ERASE FAILED!\n");
                                printf("SECTOR ERASE FAILED!\n");
                                return false;
                                return false;
                        } newv = (s<addr) ? addr : s;
                        } newv = (s<addr) ? addr : s;
                }
                }
                for(unsigned p=newv; (p<s+SECTORSZ)&&(p<addr+len); p=PAGEOF(p+PGLEN)) {
 
 
                // Now walk through all of our pages in this sector and write
 
                // to them.
 
                for(unsigned p=newv; (p<s+SECTORSZB)&&(p<addr+len); p=PAGEOF(p+PGLENB)) {
                        unsigned start = p, len = addr+len-start;
                        unsigned start = p, len = addr+len-start;
 
 
                        // BUT! if we cross page boundaries, we need to clip
                        // BUT! if we cross page boundaries, we need to clip
                        // our results to the page boundary
                        // our results to the page boundary
                        if (PAGEOF(start+len-1)!=PAGEOF(start))
                        if (PAGEOF(start+len-1)!=PAGEOF(start))
                                len = PAGEOF(start+PGLEN)-start;
                                len = PAGEOF(start+PGLENB)-start;
                        if (!write_page(start, len, &data[p-addr], verify)) {
                        if (!page_program(start, len, &data[p-addr], verify)) {
                                printf("WRITE-PAGE FAILED!\n");
                                printf("WRITE-PAGE FAILED!\n");
                                return false;
                                return false;
                        }
                        }
                }
                } if ((need_erase)||(need_program))
 
                        printf("Sector 0x%08x: DONE%15s\n", s, "");
        }
        }
 
 
        m_fpga->writeio(R_QSPI_EREG, 0); // Re-enable write protection
        m_fpga->writeio(R_QSPI_EREG, ENABLEWP); // Re-enable write protection
 
 
        return true;
        return true;
}
}
 
 
 
 
 No newline at end of file
 No newline at end of file

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.