---

cmdline.h

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
 */

#ifndef _CMDLINE_H_
#define _CMDLINE_H_

#include <vector>

class Command {
public:
        virtual char *getName()=0;

        virtual char *getBrief()=0;

        virtual char *getDescr()=0;

        virtual int exec(int argc, char *argv[])=0;
};

class CmdLine {
private:
        std::vector<Command *> commands;

public:
        CmdLine(); 
        virtual ~CmdLine();

        int exec(const char *cmdLine, int argc=0, char **argv=0);

        static int getEndOfToken(const char *string, const char *delim);

        static int getNextToken(const char *string, const char *delim);

        static int splitString(char *inputString, char **outputArray, 
                        unsigned arraySize, const char *delimiters);
};

class LoadICCmd : public Command {
public:
        virtual char *getName() { return "loadic"; }
        virtual char *getBrief() { return "load a file in the instruction cache"; }
        virtual char *getDescr();
        virtual int exec(int argc, char *argv[]);
};

class CheckCmd : public Command {
public:
        virtual char *getName() { return "check"; }
        virtual char *getBrief() { return "check connection with PXA250." ; }
        virtual char *getDescr() { return "check connection with PXA250 and print out some information.\n" ; }
        virtual int exec(int argc, char *argv[]);
};

class InitCmd : public Command {
public:
        virtual char *getName() { return "init"; }
        virtual char *getBrief() { return "init JTAG connection with the EzUSB microcontroller." ; }
        virtual char *getDescr() { return       "init connection with the EzUSB microcontroller.\n" \
                                                                                "Availables options :\n" \
                                                                                "\tv / idvendor [vendor ID]\n"\
                                                                                "\tp / idproduct [product ID]\n"\
                                                                                "\tf / filename [EzUSB firmeware filename]\n" ; }
        virtual int exec(int argc, char *argv[]);
};

class StopCmd : public Command {
public:
        virtual char *getName() { return "stop"; }
        virtual char *getBrief() { return "stop CPU execution"; }
        virtual char *getDescr() { return "Stop CPU execution and force it to stay in internal reset mode, ready for code upload\n"; }
        virtual int exec(int argc, char *argv[]);
};

class BootCmd : public Command {
public:
        virtual char *getName() { return "boot"; }
        virtual char *getBrief() { return "boot the CPU"; }
        virtual char *getDescr() { return "start program execution from reset vector (usualy 0x00000000)\n"; }
        virtual int exec(int argc, char *argv[]);
};

class ResetCmd : public Command {
public:
        virtual char *getName() { return "reset"; }
        virtual char *getBrief() { return "reset the JTAG interface"; }
        virtual char *getDescr() { return "put the JTAG unit of the PXA250 in the run test/idle state\n"; }
        virtual int exec(int argc, char *argv[]);
};

class QuitCmd : public Command {
public:
        virtual char *getName() { return "quit"; }
        virtual char *getBrief() { return "quit this program"; }
        virtual char *getDescr() { return "terminate the execution of this program.\n"; }
        virtual int exec(int argc, char *argv[]);
};

class PutCmd : public Command {
public:
        virtual char *getName() { return "put"; }
        virtual char *getBrief() { return "put data in the device memory"; }
        virtual char *getDescr() { return "put <address> <value> [h]\n"
                "If the 3rd parameter 'h' is ommited, write the 32 bits word\n"
                "<value> at address <address>. If 'h' is present, write only 16 bits\n"; }
        virtual int exec(int argc, char *argv[]);
};

class GetCmd : public Command {
public:
        virtual char *getName() { return "get"; }
        virtual char *getBrief() { return "get data from the device memory"; }
        virtual char *getDescr() { return "get <address> [size in number of word of data]\
                \nIf size is ommited, it is assumed to be 1."; }
        virtual int exec(int argc, char *argv[]);
};

class LoadCmd : public Command {
public:
        virtual char *getName() { return "load"; }
        virtual char *getBrief() { return "load a binary into the device's memory"; }
        virtual char *getDescr() { return "load <filename> [address [h]]\
                 \nIf address is ommited, it is assumed to be 0xa0000000. If h is present,\n"
                "the write will be made in 16 bits words.\n"; }
        virtual int exec(int argc, char *argv[]);
};

class ProgramFlashCmd : public Command {
private:
        CmdLine cmdLine;
public:
        ProgramFlashCmd(CmdLine &cmdLine);
        virtual char *getName() { return "program"; }
        virtual char *getBrief() { return "program a binary into the device's flash memory"; }
        virtual char *getDescr() { return "program <filename> [address]\
                 \nIf address is ommited, it is assumed to be 0x00000000. Sectors are erased before.\n"
                         "partially programmed sectors are ok: old data is reflashed.\n"; }
        virtual int exec(int argc, char *argv[]);
};

class ExecCmd : public Command {
public:
        virtual char *getName() { return "exec"; }
        virtual char *getBrief() { return "exec a program from the device's memory"; }
        virtual char *getDescr() { return "exec [start address] [stack pointer address]\
                \nIf start addres is ommited, it is assumed to be 0xa0000000 \
                \nIf stack pointer addres is ommited, it is assumed to be 0xa2000000"; }
        virtual int exec(int argc, char *argv[]);
};

class EraseFlashCmd: public Command
{
public:
        virtual char *getName() { return "erase"; }
        virtual char *getBrief() { return "erase a sector or the whole flash"; }
        virtual char *getDescr() { return "erase [sector address] ... [sector address]\
                \nIf not sector is given, a whole flash erase if performed"; }
        virtual int exec(int argc, char *argv[]);
};

class HelpCmd: public Command {
private:
        std::vector<Command *> & cmds;

public:
        HelpCmd(std::vector<Command *> & cmds) : cmds(cmds) {}
        virtual char *getName() { return "help"; }
        virtual char *getBrief() { return "list all commands or gives help about a command"; }
        virtual char *getDescr() { return "help without argument lists all commands.\n"
                "Help <cmd> gives details about a precise command\n"; }
        virtual int exec(int argc, char *argv[]);
};

class ExtBreakCmd : public Command {
public:
        virtual char *getName() { return "extbreak"; }
        virtual char *getBrief() { return "sends an external break event to the processor"; }
        virtual char *getDescr() { return "extbreak\
                 \nThe program currently running is stoped, and a debug handling routine is called.\n"; }
        virtual int exec(int argc, char *argv[]);
};

class RebootCmd : public Command {
public:
        virtual char *getName() { return "reboot"; }
        virtual char *getBrief() { return "reboot the CPU"; }
        virtual char *getDescr() { return "reboot\
                 \nReboot the CPU, exactly like pressing the reset button on the PXA board.\n"; }
        virtual int exec(int argc, char *argv[]);
};

class ContinueCmd : public Command {
public:
        virtual char *getName() { return "continue"; }
        virtual char *getBrief() { return "continue the execution of a program"; }
        virtual char *getDescr() { return "continue\
                 \nAfter a breakpoint or an external break, continues the execution of the debugged program.\n"; }
        virtual int exec(int argc, char *argv[]);
};

class RegisterCmd : public Command {
public:
        virtual char *getName() { return "register"; }
        virtual char *getBrief() { return "read or write a register"; }
        virtual char *getDescr() { return "register <reg> [<hex value>]\
                 \nif only one parameter is given, this command will display the content of a register.\n"
                "if a value is given, it will be writen to the register.\n"; }
        virtual int exec(int argc, char *argv[]);
};

class HwBreakCmd : public Command {
public:
        virtual char *getName() { return "hwbreak"; }
        virtual char *getBrief() { return "control the hardware breakpoints"; }
        virtual char *getDescr() { return "hwbreak on|off [<address>] [0|1]\
                 \nset or remove a hardware breakpoint. If the address is omitted, PC + 4 will be used.\n"
                "the last parameter allow to switch between hardware breakpoint 0 and 1.\n"; }
        virtual int exec(int argc, char *argv[]);
};

class WaitCmd: public Command {
public:
        virtual char *getName() { return "wait"; }
        virtual char *getBrief() { return "wait for the debug handler"; }
        virtual char *getDescr() { return "wait until the debug handler is ready"
                "to execute more commands."; }
        virtual int exec(int argc, char *argv[]);
};

#endif

---