---

cmdline.cpp

Go to the documentation of this file.

/*
 * This file is part of Jelie,
 * (c) 2002 Julien Pilet <julien.pilet@epfl.ch> and
 * Stephane Magnenat <stephane.magnenat@epfl.ch>
 *
 * Jelie is free software; you can redistribute it
 * and/or modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the License,
 * or (at your option) any later version.
 *
 * Jelie is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Foobar; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/time.h>
#include "cmdline.h"
#include "jtagpxa250.h"
#include "filemanager.h"
#include "debug.h"
#include <unistd.h>

// Commands

char *LoadICCmd::getDescr() { 
        return  "loadic <file> <address> [mini]\n"
                "Load the file given as parameter into the instruction cache\n"
                "If \"mini\" is not specified, code will be loaded in main IC.\n"
                "Example:\n\tloadic file.bin 0f0000 mini\n";
}

int LoadICCmd::exec(int argc, char *argv[]) {
        assert(pxa250Ptr);
        if (argc < 3) {
                printf(getDescr());
                return 1;
        }

        unsigned int address;
        sscanf(argv[2], "%x", &address);

        FILE *f = fileManagerPtr->openFP(argv[1], "r");

        if (!f) {
                perror(argv[1]);
                return 1;
        } else {
                bool mini = argc >= 4 && strcmp(argv[3], "mini")==0;
                unsigned int buffer[8*1024];    // 32kbyte buffer (8k instructions)
                int nbi = fread(buffer, 4, 8*1024, f);  // read instructions 
                printf("%d instructions read from file %s\n", nbi, argv[1]);
                printf("Ready to upload in the %s instruction cache, at address 0x%X\n",
                                mini ? "mini" : "main",
                                address);
                printf("First instruction: 0x%08X (lsB 0x%02X)\n", buffer[0], buffer[0]&0xFF);

#ifdef WORDS_BIGENDIAN
                for (int i=0; i<nbi;i++) {
                        unsigned char *cp= (unsigned char *) &buffer[i];
                        buffer[i] = JTAGpxa250::charArrayLEToInt(cp);
                }
#endif

                if (mini & nbi > 512) {
                        printf("WARNING: trying to load more than 512 instructions in the mini instruction cache!\n");
                }

                pxa250Ptr->loadIC(mini, address, buffer, nbi);
                // wait for proc to be ready
                return 0;
        }
}

int CheckCmd::exec(int argc, char *argv[]) {

        assert(pxa250Ptr);
        if (pxa250Ptr->check()) {
                printf("Success\n");
                return 0;
        } else {
                printf("Failure\n");
                return 1;
        }
}

int InitCmd::exec(int argc, char *argv[]) {

        assert(pxa250Ptr);
        if (pxa250Ptr->init(argc, argv)) {
                printf("Success\n");
                return 0;
        } else {
                printf("Failure\n");
                return 1;
        }
}

int StopCmd::exec(int argc, char *argv[]) {
        assert(pxa250Ptr);
        pxa250Ptr->getReadyForUpload();
        return 0;
}

int BootCmd::exec(int argc, char *argv[]) {
        assert(pxa250Ptr);
        pxa250Ptr->boot();
        return 0;
}

int ResetCmd::exec(int argc, char *argv[]) {
        assert(pxa250Ptr);
        pxa250Ptr->jtag->jtagReset();
        return 0;
}

int QuitCmd::exec(int argc, char *argv[]) {
        printf("quitting.\n");
        return -1;
}

int HelpCmd::exec(int argc, char *argv[]) {

        if (argc > 1) {
                // look for the command whose name is passed as argument
                std::vector<Command *>::iterator it;
                for (it = cmds.begin(); it != cmds.end(); ++it) {
                        if (strcmp(argv[1], (*it)->getName()) == 0) {
                                printf("%s:\n%s\n", argv[1], (*it)->getDescr());
                                return 0;
                        }
                }
                printf("%s: command not found.\n", argv[1]);
                return 1;
        } else {
                // list all commands
                std::vector<Command *>::iterator it;
                for (it = cmds.begin(); it != cmds.end(); ++it) {
                        printf("%20s - %s\n", (*it)->getName(), (*it)->getBrief());
                }
                return 0;
        }
}

long long GetTick()
{
        struct timeval now;

        gettimeofday(&now, NULL);
        return (now.tv_sec)*1000+(now.tv_usec)/1000;
}

int LoadCmd::exec(int argc, char *argv[])
{
        assert(pxa250Ptr);

        unsigned int address;
        unsigned int fileSize;
        unsigned int fileSizeAligned;
        unsigned int *data;
        bool halfword = false;

        if (argc < 2)
        {
                printf(getDescr());
                return 1;
        }
        else if (argc == 2)
        {
                address = 0xa0000000;
        }
        else
        {
                sscanf(argv[2], "%x", &address);
                if (argc>= 4 && argv[3][0] == 'h')
                        halfword = true;
        }

        FILE *fp=fileManagerPtr->openFP(argv[1], "r");
        if (fp)
        {
                // get file length
                fseek(fp, 0, SEEK_END);
                fileSize=ftell(fp);
                fileSizeAligned = (fileSize&0x3) ? ((fileSize&(~0x3))+4) : fileSize;
                fseek(fp, 0, SEEK_SET);

                if (halfword) {
                        fileSizeAligned*=2;
                }

                // allocate array
                data = (unsigned int *)malloc(fileSizeAligned);

                // read data
                if (halfword) {
                        for (unsigned int i=0; i<fileSizeAligned; i++) {
                                unsigned short s;
                                fread(&s, 2, 1, fp);
                                data[i] = s;
                        }
                } else {
                        fread(data, 1, fileSize, fp);
                }
                fclose(fp);

                // put data into memory
                long long startTick=GetTick();
                printf("Sending %d words into the device's memory... ", fileSizeAligned / 4);
                fflush(stdout);
                pxa250Ptr->putData(address, fileSizeAligned / 4, data);
                float duration= ((float)GetTick()-startTick)/1000.0f;
                printf("done in %.3f s (%.3f KByte/s)\n", duration, fileSizeAligned/(duration*1000.0f));

                /*
                   Verification phase, skipped
                // get data from memory
                printf("Verifying %d bytes from the device's memory", fileSize);
                fflush(stdout);
                pxa250Ptr->getData(address, fileSize, data);
                printf("done\n");
                 */

                free(data);

                return 0;
        }
        else
                return 1;
}

int PutCmd::exec(int argc, char *argv[])
{ 
        assert(pxa250Ptr);

        if (argc < 3)
        {
                printf(getDescr());
                return 1;
        }

        bool halfword = false;
        if ((argc >= 4) && (argv[3][0]=='h'))
                halfword = true;
        
        unsigned int address, value;
        sscanf(argv[1], "%x", &address);
        sscanf(argv[2], "%x", &value);
        pxa250Ptr->putData(address, 1, &value, halfword);

        return 0;
}

int EraseFlashCmd::exec(int argc, char *argv[])
{
        assert(pxa250Ptr);
        bool fullErase = false;

        // chip erase
        if (argc == 1)
                fullErase = true;

        // erase command
        pxa250Ptr->putData(0x555 * 2, 0xaa, true);
        pxa250Ptr->putData(0x2aa * 2, 0x55, true);
        pxa250Ptr->putData(0x555 * 2, 0x80, true);
        pxa250Ptr->putData(0x555 * 2, 0xaa, true);
        pxa250Ptr->putData(0x2aa * 2, 0x55, true);
        
        // sector by sector or full
        unsigned int address, data;
        if (fullErase)
        {
                // full chip erase command
                address = 0x555 * 2; // we prepare address for the DQ7 polling next in the program
                pxa250Ptr->putData(0x555 * 2, 0x10, true);
        }
        else
        {
                // get address
                unsigned int i;
                for (i=1; i<(unsigned)argc; i++)
                {
                        sscanf(argv[i], "%x", &address);

                        // wait for DQ3 == 0
                        do
                        {
                                pxa250Ptr->getData(address, 1, &data);
                        } while ((data&(1<<3)) != 0);

                        // erase sector
                        pxa250Ptr->putData(address, 0x30, true);
                }
        }
        
        // wait for DQ7 == 1
        do
        {
                pxa250Ptr->getData(address, 1, &data);
        } while ((data&(1<<7)) == 0);

        return 0;
}

ProgramFlashCmd::ProgramFlashCmd(CmdLine &cmdLine) : cmdLine(cmdLine)
{
}

int ProgramFlashCmd::exec(int argc, char *argv [])
{
        assert(pxa250Ptr);

        unsigned int address, i;
        unsigned int fileSize;
        unsigned int fileSizeAligned;
        unsigned short *data;

        if (argc < 2)
        {
                printf(getDescr());
                return 1;
        }
        else if (argc == 2)
        {
                address = 0x00000000;
        }
        else
        {
                sscanf(argv[2], "%x", &address);
        }

        // check flash id, before continuing
        pxa250Ptr->putData(0x555 * 2, 0xaa, true);
        pxa250Ptr->putData(0x2aa * 2, 0x55, true);
        pxa250Ptr->putData(0x555 * 2, 0x90, true);
        unsigned flashid=0;
        pxa250Ptr->getData(0, 1, &flashid);

        if (flashid != 0x225b0052) {
                printf("The flash is not AS29LV800B. Sorry.\n");
                return 1;
        }


        FILE *fp=fileManagerPtr->openFP(argv[1], "r");
        if (fp)
        {
                // get file length
                fseek(fp, 0, SEEK_END);
                fileSize=ftell(fp);
                fileSizeAligned = (fileSize&0x1) ? fileSize+1 : fileSize;
                fclose(fp);

                // prepare the command line to call 'enp.lnj'
                char call[256];

                sprintf(call, "flash/enp.lnj %s %x %x\n", 
                                argv[1],
                                address,
                                fileSize/2);
                printf("calling: \"%s\"\n", call);

                long long startTick=GetTick();

                if (cmdLine.exec(call)) 
                        return 3;
                
                cmdLine.exec("wait");

                printf("Embedded flasher returned %d\n", pxa250Ptr->getSavePlace(0));

                float duration= ((float)GetTick()-startTick)/1000.0f;
                printf("done in %.3f s (%.3f KByte/s)\n", duration, fileSizeAligned/(duration*1000.0f));

                return 0;
        }
        else
                return 2;
}

int GetCmd::exec(int argc, char *argv[])
{ 
        assert(pxa250Ptr);
        unsigned int address;
        unsigned int size;
        unsigned int *data;

        if (argc < 2)
        {
                printf(getDescr());
                return 1;
        }
        else if (argc == 2)
        {
                size = 1;
        }
        else
        {
                sscanf(argv[2], "%x", &size);
        }

        sscanf(argv[1], "%x", &address);

        data = (unsigned int *)malloc(size*sizeof(unsigned int));
        pxa250Ptr->getData(address, size, data);
        
        for (unsigned i=0; i<size; i++)
        {
                printf("%08x : %08x\n", address+(i*4), data[i]);
        }
        
        free(data);
        
        return 0;
}

int ExecCmd::exec(int argc, char *argv[])
{
        assert(pxa250Ptr);
        unsigned int address;
        unsigned int sp;

        if (argc<2)
        {
                address=0xa0000000;
                sp=0xa0000000+(64*1024*1024);
        }
        else if (argc<3)
        {
                sscanf(argv[1], "%x", &address);
                sp=0xa0000000+(64*1024*1024);
        }
        else
        {
                sscanf(argv[1], "%x", &address);
                sscanf(argv[2], "%x", &sp);
        }

        pxa250Ptr->execute(address, sp);

        return 0;
}

int ExtBreakCmd::exec(int argc, char *argv[]) {
        assert(pxa250Ptr);
        pxa250Ptr->extBreak();

        return 0;
}

int RebootCmd::exec(int argc, char *argv[]) {
        assert(pxa250Ptr);
        pxa250Ptr->reboot();
        return 0;
}

int ContinueCmd::exec(int argc, char *argv[]) {
        assert(pxa250Ptr);
        pxa250Ptr->continueCmd();
        return 0;
}

int RegisterCmd::exec(int argc, char *argv[]) {
        assert(pxa250Ptr);
        if (argc < 2) {
                printf("%s",getDescr());
                return 1;
        }

        unsigned int reg = strtoul(argv[1], 0, 10);

        if (argc >= 3) {
                // this is a write
                unsigned int val = strtoul(argv[2], 0, 16);

                return pxa250Ptr->setSavePlace(reg, val) ? 0 : 2;
        } else {
                // this is a read
                unsigned int val = pxa250Ptr->getSavePlace(reg);
                printf("Register %d = %08x (%d)\n", reg, val, val);
                return 0;
        }
}

int HwBreakCmd::exec(int argc, char *argv[]) {

        if (argc < 2) {
                printf("%s", getDescr());
                return 1;
        }

        // activate or remove breakpoint ?
        bool enable;

        if (strcmp("on", argv[1]) == 0) {
                enable = true;
        } else {
                if (strcmp("off", argv[1]) == 0)
                        enable = false;
                else {
                        printf("%s", getDescr());
                        return 2;
                }
        }

        // at what address ?
        unsigned int addr;
        
        if (argc >= 3)
                addr = strtoul(argv[2], 0, 16);
        else 
                addr = pxa250Ptr->getSavePlace(15);

        JTAGpxa250::Cp15Reg reg=JTAGpxa250::IBCR0;

        if (argc >= 4) {
                switch (argv[3][0]) {
                case '0': reg = JTAGpxa250::IBCR0; break;
                case '1': reg = JTAGpxa250::IBCR1; break;
                default:
                        printf("%s", getDescr());
                        return 3;
                }
        } 

        // now load the debug register
        if (pxa250Ptr->setCp15DebugRegister(addr | ( enable ? 1 : 0), reg))
                return 0;
        else
                return 4;
}
                
int WaitCmd::exec(int argc, char *argv[]) {
        
        while (!pxa250Ptr->targetReady()) {
                usleep(100);
                pxa250Ptr->pollForTX();
        }
        return 0;
}
        
// CmdLine class implementation

CmdLine::CmdLine() {
        commands.push_back(new InitCmd());
        commands.push_back(new CheckCmd());
        commands.push_back(new StopCmd());
        commands.push_back(new LoadICCmd());
        commands.push_back(new QuitCmd());
        commands.push_back(new ResetCmd());
        commands.push_back(new BootCmd());
        commands.push_back(new LoadCmd());
        commands.push_back(new PutCmd());
        commands.push_back(new GetCmd());
        commands.push_back(new ExecCmd());
        commands.push_back(new ExtBreakCmd());
        commands.push_back(new ContinueCmd());
        commands.push_back(new RebootCmd());
        commands.push_back(new RegisterCmd());
        commands.push_back(new HwBreakCmd());
        commands.push_back(new HelpCmd(commands));
        //commands.push_back(new EraseFlashCmd());
        commands.push_back(new WaitCmd());
        commands.push_back(new ProgramFlashCmd(*this));
}

CmdLine::~CmdLine() {
        std::vector<Command *>::iterator it;
        for (it = commands.begin(); it != commands.end(); ++it) {
                delete *it;
                *it = 0;
        }
}

int CmdLine::exec(const char *cmdLine, int argc, char **argv) {
        // copy the command line
        char *cmd = strdup(cmdLine);
        char *words[256];
        int nbWords = splitString(cmd, words, 256, " \t\r\n");

        assert(cmd);
        assert(words);

        // ignore comments and empty lines
        if ((nbWords==0) || (words[0][0] == '#')) {
                free(cmd);
                return 0;
        }

        // parameters replacement and comment ignoring
        for (int i=0; i< nbWords; i++) {
                if (words[i][0] == '#') {
                        nbWords = i;
                        break;
                } 

                if (argc && words[i][0] == '\\' && isdigit(words[i][1])) {
                        long p = strtoul(words[i] + 1, 0, 10);
                        if (p < 0) p = 0;
                        if (p < argc)
                                words[i] = argv[p];
                }
        }

        // search for a matching command
        std::vector<Command *>::iterator it;
        for (it = commands.begin(); it != commands.end(); ++it) {
                if (strcmp((*it)->getName(), words[0]) == 0) {
                        int ret= (*it)->exec(nbWords, words);
                        free(cmd);
                        return ret;
                }
        }

        // look for a script of the corresponding name
        FILE *f = fileManagerPtr->openFP(words[0], "rt");
        if (f) {
                char line[256];
                int ln=0;
                while (fgets(line, sizeof(line), f)) {
                        ln++;
                        debugMessage(CMD_SCRIPT_DEBUG, "%s:%d: %s\n", words[0], ln, line);
                        int r=exec(line, nbWords, words);
                        if (r) {
                                printf("%s:%d: command returned %d\n", 
                                                words[0], ln, r);
                                fclose(f);
                                free(cmd);
                                return -3;
                        }
                                
                }
                fclose(f);
                free(cmd);
                return 0;
        }

        fprintf(stderr, "%s: command not found\n", words[0]);
        free(cmd);
        return -2;
}

int CmdLine::getNextToken(const char *string, const char *delim) {

        for (int i=0; string[i]; i++) {
                for (int c=0; delim[c]; c++) {
                        if (string[i] != delim[c])
                                return i;
                }
        }
        return -1;
}


int CmdLine::splitString(char *inputString, char **outputArray, 
                        unsigned arraySize, const char *delimiters)
{
        char *c;
        unsigned arrayPos=0;
        int inWord = 0;

        if (!inputString) return 0;
        for (c= inputString; *c; c++) {
                if (index(delimiters, *c)) {
                        *c = 0;
                        inWord = 0;
                } else {
                        if (!inWord && arrayPos < arraySize) {
                                inWord = 1;
                                outputArray[arrayPos++] = c;
                        }
                }
        }
        return arrayPos;
}

---