command.c~

Intel PXA270的bootloader程序,在linux环境下运行的.

#include <config.h>
#include <stdio.h>
#include <command.h>
#include <time.h>
#include <stdarg.h>
#include <string.h>
#include <setup.h>
#include <hardware.h>

#define MAX_ARGS				20

#define report(fmt, args...)	printf(fmt, ##args)
#define assert(fmt, args...)	printf(fmt, ##args)
#define failed(fmt, args...)	printf(fmt, ##args)


/* src/cmddebug.c */
extern struct command_t cmd_memset;
extern struct command_t cmd_memcmp;
extern struct command_t cmd_memcpy;
extern struct command_t cmd_hexdump;
extern struct command_t cmd_ping;

/* src/command.c */
extern struct command_t cmd_boot;
extern struct command_t cmd_load;
extern struct command_t cmd_reboot;
extern struct command_t cmd_quit;

/* src/flash.c */
extern struct command_t cmd_flash;
extern struct command_t cmd_erase;

/* src/bootp.c */
extern struct command_t cmd_bootp;

/* src/tftp.c */
extern struct command_t cmd_tftp;

/* src/setup.c */
extern struct command_t cmd_config;


struct command_t cmd_bytedump;

static struct command_t *cmdlist[] = {
	&cmd_load,
	&cmd_ping,
	&cmd_bootp,
	&cmd_tftp,
	&cmd_flash,
	&cmd_erase,
	&cmd_config,
	&cmd_boot,
//	&cmd_memcpy,
//	&cmd_memcmp,
//	&cmd_memset,
//	&cmd_hexdump,
//        &cmd_bytedump,
	&cmd_reboot,
	&cmd_quit,
	0
};

//static int get_command(char *cmdbuff, int size);

static bool do_bytedump()
{

    return true;
}


static void bytedump_usage(void)
{
 usage_format("bytedump posi leng", "display the mem");

}

struct command_t com_bytedump = {
        .name = "bytedump",
        .run  = do_bytedump,        
        .usage = bytedump_usage
};










#define seperator				" \t"

extern bool autoboot_mode(void){
	int argc;
	bool res;
	char *argv[MAX_ARGS];
	uchar cmdbuff[sizeof(setup->autoboot)], *cmd, *s;

	strcpy(cmdbuff, setup->autoboot);
	cmd = cmdbuff;

	while ((s = strchr(cmd, ';'))){
		*s = '\0';											/* replace ';' with '\0' */
		while (*cmd && strchr(seperator, *cmd)) cmd++;		/* skip seperator */
		argc = get_args(cmd, argv);							/* run command */
		if (!argc) continue;
		res = do_command(argc, argv);
		if (!res) return false;
		cmd = s + 1;										/* for next */
	}
	while (cmd[0]){
		argc = get_args(cmd, argv);
		if (!argc) break;
		return do_command(argc, argv);
	}
	return true;
}

extern void command_mode(void){
	int argc=0;
	char *argv[MAX_ARGS];
	char cmdbuff[1024];

	while (1){
		printf(" " PACKAGE "> ");
		get_command(cmdbuff, sizeof(cmdbuff));
		argc = get_args(cmdbuff, argv);
		if (!argc) continue;
		if (!strcmp(argv[0], "quit"))
			break;
		else
			do_command(argc, argv);
	}
	return;
}

extern bool do_command(int argc, char **argv){
	bool res = true;
	struct command_t **cp;

	if (!strcmp(argv[0], "ls")){
		int cnt = 0;
		for (cp = cmdlist; *cp; cp++){
			if (cnt && (cnt % 8) == 0) printf("\n");
			printf("%-10s", (*cp)->name);
			cnt++;
		}
		printf("\n");
	} else if (!strcmp(argv[0], "help")){
		for (cp=cmdlist; *cp; cp++)
			(*cp)->usage();	
	} else {
		for (cp=cmdlist; *cp; cp++){
			if (!strcmp(argv[0], (*cp)->name)){
				res = (*cp)->run(argc, argv);
				return res;
			}
		}
		if (!*cp){ printf("  %s : unknown command\n", argv[0]); res = false; }
	}
	return res;
}

int get_command(char *buff, int size){
	int ch;
	char *s = buff;

	while (s < buff + size - 1){
		ch = getc();
		if (ch < 0) continue;

		if ((ch == '\r') || (ch == '\n')){
			printf("\n");
			break;
		} else if (ch == '\b'){
			if (s > buff){
				printf("\b \b");
				s--;
			}
		} else {
			printf("%c", ch);
			*s++ =  ch;
		}
	}
	*s = '\0';
	return s - buff;
}

/* values in s will be modified */
extern int get_args(char *cmd, char **argv){
	int argc=0;
	char *s;

	if (!cmd) goto out;
	for (s=cmd; *s; s++)
		if (strchr(seperator, *s)) *s = ' ';

	s = cmd;
	while (argc < MAX_ARGS){
		while (*s && *s==' ') s++;				// skip space(' ') in front.
		if (!*s) break;

		if (*s == '"'){							// "string"
			s++;
			argv[argc++] = s;
			while (*s && (*s != '"')){
				if (*s == '\\'){		// '\"'
					strcpy(s, s+1);
					if (!*s) goto out;
				}
				s++;
			}
			if (*s == '"') *s++ = '\0';
			if (!*s) break;
		} else {
			argv[argc++] = s;
			while (*s && (*s != ' ')) s++;
			if (!*s) break;
			*s++ = '\0';
		}
	}
out :
	argv[argc] = 0;
	return argc;
}

static void boot_usage(void){
	usage_format("boot", "booting the kernel");
	return;
}


static inline uint get_kernel_size(void *addr){
	int i;
	uint32 *p = addr;

	for (i=0; i < 8; i++){
		if (p[i] != 0xE1A00000)
			return 0;
	}
	if (p[9] != 0x016F2818)
		return 0;
	return p[11];
}

extern void create_tags(void);
static bool do_boot(int argc, char **argv){
	void (*kernel)(int zero, int arch);

	if (argc == 1){
		struct map *mp;
		mp = find_map("kernel");
		if (!mp){ printf(" can't found map for kernel.\n"); goto invalid; }
		kernel = (void *)mp->dramb;
	} else if (argc == 2){
		bool res;
		ulong tmp;

		res = strtoul(argv[1], &tmp, 16);
		if (!res) goto invalid;
		kernel = (void *)tmp;
	} else goto invalid;
	if (!get_kernel_size(kernel)){ printf(" error: kernel is not exists.\n"); return false; }
	create_tags();
	printf("starting kernel ...\n");
	kernel(0, 609);
	return true;
invalid :
	boot_usage();
	return false;
}

struct command_t cmd_boot = {
	.name  = "boot",
	.run   = do_boot,
	.usage = boot_usage
};


static void reboot_usage(void){
	usage_format("reboot", "software reboot");
	return;
}

static void quit_usage(void){
	usage_format("quit", "quit commandline mode");
	return;
}

static bool do_reboot(int argc, char **argv){
	void (*restart)(void) = 0;
	printf(" restarting...\n");
	restart();
	return true;
}

struct command_t cmd_reboot = {
	.name  = "reboot",
	.run   = do_reboot,
	.usage = reboot_usage
};


static void load_usage(void){
	usage_format("load {kernel/ramdisk}", "copy to sdram from flash in area");
	return;
}

static bool do_load(int argc, char **argv){
	struct map *mp;

	if (argc != 2) goto invalid;
	mp = find_map(argv[1]);
	if (!mp) goto invalid;

	printf(" loading %s image from flash...\n", mp->name);
	memcpy((void *)mp->dramb, (void *)mp->sramb, mp->srams);
	mp->drams = mp->srams;
	return true;
invalid :
	load_usage();
	return false;
}

struct command_t cmd_load = {
	.name  = "load",
	.run   = do_load,
	.usage = load_usage
};

struct command_t cmd_quit = {
	.name  = "quit",
	.run   = 0,
	.usage = quit_usage
};