cmd.c

来自「ADS下的bios工程」· C语言 代码 · 共 863 行 · 第 1/2 页

#include <bios/s3c2410x.h>
#include <bios/stdio.h>
#include <bios/boot.h>
#include <bios/netdev.h>
#include <bios/time.h>
#include <bios/types.h>
#include <bios/string.h>
#include <bios/cmd.h>
#include <bios/error.h>
#include <bios/config.h>
#include <bios/ctype.h>
#include <bios/system.h>
//#include <bios/lcd.h>
#include <bios/flash_nand.h>
#include <bios/config_param.h>

#undef BDEBUG
#ifdef BDEBUG
#define BPRINTF(fmt, args...) printf("%s-%s()[%d]: " fmt, __FILE__, \
      __FUNCTION__, __LINE__, args)
#else
#define BPRINTF(fmt, args...)
#endif

/* external defined functions */
extern int bootFlag;
extern REG32 bios_recv_bytes;  
extern int boot_loader_size;
extern struct BOOT_LOADER boot_loader[];
extern struct netdev probed_net_devs;

struct config_params    sysconf;

extern void boot_image(int);
extern void Usb_Main(void);

/* function proto types */
static u32 SysParams(u8 argc, char (*argv)[MAX_LENGTHOF_ARGS],CMDPOOL *pCmd);
u32 sysconf_view(void); 
u32 sysconf_set(void);
void NandFlash(void);
int get_params(void);
void printfHelpMessage(char *cmd);

/* command structures */
BIOSCMD 
gBIOSCmdTable[MAX_NUMOF_COMMAND] = {
    {"help",        HelpCmdLi,      4, "Help for bios command.\0"},
    {"ls",          ListOfCmd,      2, "View bios command list.\0"},
    {"sysconf",     SysParams,      7, "System parameter configure.\0"},
    {"flash",       FlashUtils,     5, "Flash Device Utility.\0"},
    {"erase",       FlashUtils2,    5, "Flash Device Utility for JFFS.\0"},
    {"loadr",	DownLoadCmdLi,  5, "Image download & run.\0"},
    {"load",	DownLoadCmdLi,  4, "Image download.\0"},
    {"boot",        BootCmdLi,      4, "Booting the utlinux Image.\0"},
    {"dump",        MemDump,        4, "Memory Dump Command.\0"},
    { NULL, NULL, 0, NULL}
};

u32 
MemDump(u8 argc, char (*argv)[MAX_LENGTHOF_ARGS], CMDPOOL *pCmd)
{
    unsigned char    *SrcAddr;
    int    block, page = 0;

    printf("\nargc(%d)\n", argc);
    if (argc < 2) {
        printfHelpMessage(argv[0]);
        printf("Usage: %s [address(Hex value)]\n", argv[0]);
        printf("          [-n(nand) block(0~1023) page(0~15)]\n");

        return ERROR_MISS_ARGUMENTS;
    }

    if (!str_ncmp("-n", argv[1], strlen(argv[1]))) {
        block = (unsigned int)strtoint(argv[2], strlen(argv[2])); 
        if (argc < 4) 
            page = -1;
        else 
            page = (unsigned int)strtoint(argv[3], strlen(argv[3])); 

        debug_nand(block, page);
    } 
    else {
        SrcAddr = (unsigned char *)hexstrtohex(argv[1], strlen(argv[1])); 
        debug(SrcAddr);
    }

    return BIOS_SUCCESS;
}

void 
InitCommandPool(CMDPOOL *commandpool) 
{
    CMDPOOL    *pCmd, *pStart, *pEnd, *prevCmd = 0;
    int    i, j;

    pCmd = commandpool;
    pStart = commandpool;
    pEnd = commandpool + (MAX_COMMAND_LIST - 1);
    pEnd -> comlen = 0;

    for (i = 0; i < MAX_COMMAND_LIST; i ++) {
        for (j = 0; j < MAX_LENGTHOF_COMMANDLINE; j ++) {
            pCmd->commandline[j] = '\0';
        }

        pCmd -> comlen = 0;
        pCmd -> prevcmd = ((i == 0) ? pEnd : prevCmd);
        prevCmd = pCmd;
        pCmd -> nextcmd = ((i == MAX_COMMAND_LIST - 1) ? pStart : pCmd + 1);
        pCmd ++;
    }
}

u32 
ReadCommand(CMDPOOL *pCmd, u32 *CmdOffset)
{
    int    ch,i;
    static u32    cur_pos;
    static u32    flag;
    static CMDPOOL    *pCurCmd;

    cur_pos = 0;
    flag = 0;	
    pCurCmd = pCmd;

    /* Initialize the command line */
    for (i = 0; i < MAX_LENGTHOF_COMMANDLINE; i ++)
        pCurCmd -> commandline[i] = '\0';
        
    /* Initialize the command length */
    pCurCmd -> comlen = 0;
    if (bootFlag) {
        ch = getc_timed(BOOT_WAIT_TIME);
        if (ch < 0 || ch == CR) 
            return  (int)NULL;
        bootFlag = 0; 
    } 
    else  
        ch = getc();

    while(1) {
        switch (ch) {
            case CR: 
                if (!flag) 
                    PutPrompt(pCmd, CmdOffset, 3);
                else {
                    flag = cur_pos = 0;
                    return  BIOS_SUCCESS;
                }
                break;

            case BS:
                if (cur_pos > 0) {
                    putc(BS);
                    putc(SPACE);
                    pCurCmd -> commandline[-- cur_pos] = '\0';
                    if (cur_pos == 0){
                        putc(ch);
                    }
                }
                break;

            case ' ': 
                if (!flag) {
                    putc(ch);
                    break;
                }

            default: 
                pCurCmd -> commandline[cur_pos ++] = ch;
                pCurCmd -> comlen ++;	
                flag = 1;
        }

        if (cur_pos > 0) {
            putc(ch);
        }

        ch = getc();
        if (!flag) 
            pCurCmd = pCmd;
    }
}

CMDPOOL *
PutPrompt(CMDPOOL *pCmd, u32 *CmdOffset, u32 mode)
{
    switch (mode) {
        case 0:
            printf("%s ", pCmd -> commandline); 
            putc('\b');
            break ;

        case 1:
            printf("No more command!!!\n");
            break ;

        case 2:
            printf("\rNo next command!!!\n");
            break ;

        case 3:
            (*CmdOffset) ++;
            printf("\nBIOS(%ld)> ", *CmdOffset); 
    }

    return  pCmd;
}

u32 
RunCommand(CMDPOOL *pCmd)
{
    int    index;		
    u32    argc;
    char    argv[MAX_NUMOF_ARGS][MAX_LENGTHOF_ARGS] = {{0,},};

    memset(argv, 0, sizeof(argv[MAX_NUMOF_ARGS][MAX_LENGTHOF_ARGS]));

    argc = ParseCommandLine(argv,pCmd -> commandline); 
    index = LookUpCommand(argv[0]); /* argv[0] is command */

    if (gBIOSCmdTable[index].cmd_action == NULL || index < 0)
        return ERROR_BAD_COMMAND; 

    return  gBIOSCmdTable[index].cmd_action(argc,argv,pCmd); 
}

u32 
ParseCommandLine(char (*argv)[MAX_LENGTHOF_ARGS], char *commandline)
{
    u32    count = 1;
    u32    offset = 0;
    u32    i, j;
    char    cmd;

    for (j = 0; j < MAX_NUMOF_ARGS; j ++) {
        for (i = 0 ; i < MAX_LENGTHOF_ARGS; i ++) {
            if ((cmd = commandline[offset]) == SPACE) {
                offset ++;
                count ++;
                argv[j][i] = '\0';
                break ;
            }

            switch (cmd) {
                case NL: 
                case CR: 
                    argv[j][i] = '\0';
                    return  count;

                default: 
                    argv[j][i] = cmd;
                    offset ++;
                    break ;
            }
        }
    }

    return  count ;
}

u32 
LookUpCommand(char* cmd)
{
    u32    tableindex = 0;

    while (tableindex < MAX_NUMOF_COMMAND) {
        if (gBIOSCmdTable[tableindex].cmd_action == NULL) 
            return  -1;

        if (!str_ncmp(cmd, gBIOSCmdTable[tableindex].cmd_name,strlen(cmd)))
            if (strlen(cmd) == gBIOSCmdTable[tableindex].cmd_length)
                break;

        tableindex++;
    }

    return  tableindex;
}


void 
printfHelpMessage(char *cmd)
{
    u32    index;

    index = LookUpCommand(cmd);
    printf("\n%s\n", gBIOSCmdTable[index].cmd_help);
}

u32 
ListOfCmd(u8 argc, char (*argv)[MAX_LENGTHOF_ARGS], CMDPOOL *pCmd)
{
    int    index ;

    if (argc == 2)
        HelpCmdLi(1, NULL, NULL); 
    else {
        printf("\n");
        for (index = 0; index < MAX_NUMOF_COMMAND; index ++) {
            if (gBIOSCmdTable[index].cmd_name == NULL) 
                break ;
            printf("%-10s", gBIOSCmdTable[index].cmd_name);
        }
    }

    return  BIOS_SUCCESS;
}

u32 
HelpCmdLi(u8 argc, char (*argv)[MAX_LENGTHOF_ARGS], CMDPOOL *pCmd)
{
	int index ;

	printf("\n=======================================") ;
	printf("\n    BIOS Command line interface HELP   ") ;
	printf("\n=======================================") ;
	for (index = 0 ; index < MAX_NUMOF_COMMAND ; index++) 
	{
                if(gBIOSCmdTable[index].cmd_name == NULL) break;
		printf("\n %-8s: ",gBIOSCmdTable[index].cmd_name);
		printf("%s ",gBIOSCmdTable[index].cmd_help);
	}
	printf("\n=======================================\n") ;
	return BIOS_SUCCESS;
}

u32 
FlashUtils2(u8 argc, char (*argv)[MAX_LENGTHOF_ARGS], CMDPOOL *pCmd)
{
    struct BOOT_LOADER    *loader;
    int    block=0, i;
    int    branch;

    loader = &boot_loader[0];
    bios_recv_bytes = 0;
    load_addr = DOWNLOAD_BASE;      /* 0x30300000 */

    if (argc < 2) {
        printfHelpMessage(argv[0]);
        printf("Usage: %s <target>\n", argv[0]) ;
        printf("   <target> = [ kernel | disk | user_1 | user_2 ]\n") ;
        return  ERROR_MISS_ARGUMENTS;
    }

    if (!str_ncmp("kernel", argv[1], strlen(argv[1]))) {
        branch = 1;
        block = NAND_KERNEL_BLOCK;
        bios_recv_bytes = NAND_KERNEL_SIZE * 0x4000;
    } 
    else if (!str_ncmp("disk", argv[1], strlen(argv[1]))) {
        branch = 2;
        block = NAND_APPS_BLOCK;
        bios_recv_bytes = NAND_APPS_SIZE * 0x4000;
    } 
    else if (!str_ncmp("user_1", argv[1], strlen(argv[1]))) {
        branch = 2;
        block = NAND_USER_BLOCK;
        bios_recv_bytes = NAND_USER_SIZE * 0x4000;
    } 
    else if (!str_ncmp("user_2", argv[1], strlen(argv[1]))) {
        branch = 4;
        block = NAND_FREE_BLOCK;
        bios_recv_bytes = NAND_FREE_SIZE * 0x4000;
    }

    switch (branch) {
        case  1:
            printf("\nNow erasing the kernel area of NAND Flash!\n");
            break ;

        case  2:
            printf("\nNow erasing the disk area of NAND Flash!\n");
            break ;

        case  3:
            printf("\nNow erasing the user #1 partition area of NAND Flash!\n");
            break ;

        case  4:
            printf("\nNow erasing the user #2 partition area of NAND Flash!\n");
            break ;

        default:
            break ;
    }

    nand_flash_control(nand_erase, block, 0, (u8 *)load_addr, bios_recv_bytes);
    printf("Completed erasing the partition!!\n");

    return BIOS_SUCCESS;
}
	
u32 
FlashUtils(u8 argc, char (*argv)[MAX_LENGTHOF_ARGS], CMDPOOL *pCmd)
{
    struct BOOT_LOADER    *loader;
    int    block=0, i;
    int    branch;

    loader = &boot_loader[0];
    bios_recv_bytes = 0;
    load_addr = DOWNLOAD_BASE;      /* 0x30300000 */

    if (argc < 4) {
        printfHelpMessage(argv[0]);
        printf("Usage: %s <loader> <target> <file name>\n", argv[0]) ;
        printf("   <loader> = [ net | serial | usb ]\n") ;
        printf("   <target> = [ NAND Flash block Number(0-1024)]\n") ;
        printf("   <file name> = [ boot.bin | bios.bin | zImage | "
              "romdisk.img | ramdisk.gz | jffs.img | jffs2.img ]\n");

        return ERROR_MISS_ARGUMENTS;
    }

    for (i = 0; i < boot_loader_size; i ++) {
        if (!str_ncmp(loader -> fn -> name, argv[1], strlen(argv[1]))) {
            printf("\n%s trying to load image....\n",loader -> fn -> name);
            break ;
        }

        loader ++;
    }

    if (i == boot_loader_size) 
        return  ERROR_NOT_SUPPORT;

    sprintf(BOOT_FILE, "%s", "/home/tftp/");
    strcat(BOOT_FILE, argv[3]);