int arch_board_getclock(struct vmm_devtree_node * node, u32 * clock)
{
if (!node || !clock) {
return VMM_EFAIL;
}
if (vmm_strcmp(node->name, "uart0") == 0) {
*clock = 24000000;
} else if (vmm_strcmp(node->name, "uart1") == 0) {
*clock = 24000000;
} else {
*clock = 100000000;
}
return VMM_OK;
}
static int cmd_profile_exec(struct vmm_chardev * cdev, int argc, char **argv)
{
char *param = NULL;
int index = 0;
if (argc > 3) {
cmd_profile_usage(cdev);
return VMM_EFAIL;
}
if (argc == 3) {
param = argv[2];
}
while (command[index].name) {
if (vmm_strcmp(argv[1], command[index].name) == 0) {
return command[index].function(cdev, param);
}
index++;
}
cmd_profile_usage(cdev);
return VMM_EFAIL;
}
static int cmd_vcpu_exec(vmm_chardev_t *cdev, int argc, char **argv)
{
int id = -1;
int index = 0;
if (argc > 3) {
cmd_vcpu_usage(cdev);
return VMM_EFAIL;
}
if (argc == 3) {
id = vmm_str2int(argv[2], 10);
}
while (command[index].name) {
if (vmm_strcmp(argv[1], command[index].name) == 0) {
return command[index].function(cdev, id);
}
index++;
}
cmd_vcpu_usage(cdev);
return VMM_EFAIL;
}
int cmd_blockdev_exec(struct vmm_chardev *cdev, int argc, char **argv)
{
if (argc == 2) {
if (vmm_strcmp(argv[1], "help") == 0) {
cmd_blockdev_usage(cdev);
return VMM_OK;
} else if (vmm_strcmp(argv[1], "list") == 0) {
cmd_blockdev_list(cdev);
return VMM_OK;
}
}
if (argc < 3) {
cmd_blockdev_usage(cdev);
return VMM_EFAIL;
}
return VMM_OK;
}
int cmd_buddy_exec(struct vmm_chardev *cdev, int argc, char **argv)
{
if (argc <= 1) {
cmd_buddy_usage(cdev);
return -1;
}
if (!vmm_strcmp(argv[1], "state")) {
buddy_print_state(cdev);
} else if (!vmm_strcmp(argv[1], "hk-state")) {
buddy_print_hk_state(cdev);
} else {
vmm_cprintf(cdev, "buddy %s: Unknown command.\n");
cmd_buddy_usage(cdev);
return -1;
}
return VMM_OK;
}
const char* get_option_val(const cmdline_option_t *options,
char vals[][MAX_VALUE_LEN], const char *opt_name)
{
int i;
for (i = 0; options[i].name != NULL; i++ ) {
if ( vmm_strcmp(options[i].name, opt_name) == 0 )
return vals[i];
}
bprint("requested unknown option: %s\n", opt_name);
return NULL;
}
static int cmd_profile_name_cmp(void *m, size_t a, size_t b)
{
struct count_record *ptr = m;
int result = vmm_strcmp(&ptr[a].function_name[0], &ptr[b].function_name[0]);
if (result < 0) {
return 1;
} else {
return 0;
}
}
int cmd_rtcdev_exec(struct vmm_chardev *cdev, int argc, char **argv)
{
if (argc == 2) {
if (vmm_strcmp(argv[1], "help") == 0) {
cmd_rtcdev_usage(cdev);
return VMM_OK;
} else if (vmm_strcmp(argv[1], "list") == 0) {
cmd_rtcdev_list(cdev);
return VMM_OK;
}
}
if (argc < 3) {
cmd_rtcdev_usage(cdev);
return VMM_EFAIL;
}
if (vmm_strcmp(argv[1], "sync_wallclock") == 0) {
return cmd_rtcdev_sync_wallclock(cdev, argv[2]);
} else if (vmm_strcmp(argv[1], "sync_device") == 0) {
return cmd_rtcdev_sync_device(cdev, argv[2]);
} else if (vmm_strcmp(argv[1], "get_time") == 0) {
return cmd_rtcdev_get_time(cdev, argv[2]);
} else if ((vmm_strcmp(argv[1], "set_time") == 0) && argc == 7) {
return cmd_rtcdev_set_time(cdev, argv[2], argc - 3, &argv[3]);
}
cmd_rtcdev_usage(cdev);
return VMM_EFAIL;
}
int cmd_ram_exec(vmm_chardev_t *cdev, int argc, char **argv)
{
int colcnt;
if (1 < argc) {
if (vmm_strcmp(argv[1], "help") == 0) {
cmd_ram_usage(cdev);
return VMM_OK;
} else if (vmm_strcmp(argv[1], "stats") == 0) {
cmd_ram_stats(cdev);
return VMM_OK;
} else if (vmm_strcmp(argv[1], "bitmap") == 0) {
if (2 < argc) {
colcnt = vmm_str2int(argv[2], 10);
} else {
colcnt = 64;
}
cmd_ram_bitmap(cdev, colcnt);
return VMM_OK;
}
}
cmd_ram_usage(cdev);
return VMM_EFAIL;
}
struct fdt_property * libfdt_get_property(struct fdt_fileinfo * fdt,
struct fdt_node_header * fdt_node,
const char * property)
{
u32 len = 0x0;
struct fdt_property * ret = NULL;
char * data = NULL;
/* Sanity checks */
if (!fdt || !fdt_node || !property) {
return NULL;
}
/* Sanity checks */
if (fdt_node->tag != FDT_BEGIN_NODE)
return NULL;
/* Convert node to character stream */
data = (char *)fdt_node;
data += sizeof(fdt_cell_t);
/* Skip node name */
len = vmm_strlen(data);
data += len + 1;
while ((virtual_addr_t) (data) % sizeof(fdt_cell_t) != 0) {
data++;
}
/* Find node property and its value */
ret = NULL;
while (LIBFDT_DATA32(data) == FDT_PROP) {
data += sizeof(fdt_cell_t);
len = LIBFDT_DATA32(data);
data += sizeof(fdt_cell_t);
if (!vmm_strcmp(&fdt->str[LIBFDT_DATA32(data)],
property)) {
data -= sizeof(fdt_cell_t) * 2;
ret = (struct fdt_property *)data;
break;
}
data += sizeof(fdt_cell_t);
data += len;
while ((virtual_addr_t) (data) % sizeof(fdt_cell_t) != 0) {
(data)++;
}
}
return ret;
}
static int cmd_profile_count_cmp(void *m, size_t a, size_t b)
{
struct count_record *ptr = m;
if (ptr[a].count < ptr[b].count) {
return 1;
} else if (ptr[a].count == ptr[b].count) {
if (vmm_strcmp
(&ptr[a].function_name[0], &ptr[b].function_name[0]) < 0) {
return 1;
}
}
return 0;
}
int cmd_memory_exec(struct vmm_chardev *cdev, int argc, char **argv)
{
u32 tmp;
physical_addr_t addr, src_addr;
if (argc < 2) {
cmd_memory_usage(cdev);
return VMM_EFAIL;
} else {
if (argc == 2) {
if (vmm_strcmp(argv[1], "help") == 0) {
cmd_memory_usage(cdev);
return VMM_OK;
} else {
cmd_memory_usage(cdev);
return VMM_EFAIL;
}
} else if (argc < 4) {
cmd_memory_usage(cdev);
return VMM_EFAIL;
}
}
addr = (physical_addr_t)vmm_str2ulonglong(argv[2], 10);
if (vmm_strcmp(argv[1], "dump8") == 0) {
tmp = vmm_str2ulonglong(argv[3], 10);
return cmd_memory_dump(cdev, addr, 1, (u32)tmp);
} else if (vmm_strcmp(argv[1], "dump16") == 0) {
tmp = vmm_str2ulonglong(argv[3], 10);
return cmd_memory_dump(cdev, addr, 2, (u32)tmp);
} else if (vmm_strcmp(argv[1], "dump32") == 0) {
tmp = vmm_str2ulonglong(argv[3], 10);
return cmd_memory_dump(cdev, addr, 4, (u32)tmp);
} else if (vmm_strcmp(argv[1], "modify8") == 0) {
return cmd_memory_modify(cdev, addr, 1, argc - 3, &argv[3]);
} else if (vmm_strcmp(argv[1], "modify16") == 0) {
return cmd_memory_modify(cdev, addr, 2, argc - 3, &argv[3]);
} else if (vmm_strcmp(argv[1], "modify32") == 0) {
return cmd_memory_modify(cdev, addr, 4, argc - 3, &argv[3]);
} else if (vmm_strcmp(argv[1], "copy") == 0 && argc > 4) {
src_addr = (physical_addr_t)vmm_str2ulonglong(argv[3], 10);
tmp = vmm_str2uint(argv[4], 10);
return cmd_memory_copy(cdev, addr, src_addr, tmp);
}
cmd_memory_usage(cdev);
return VMM_EFAIL;
}
static int cmd_profile_dump(struct vmm_chardev * cdev, char *filter_mode)
{
int index = 0;
int (*cmp_function) (void *, size_t, size_t) = cmd_profile_count_cmp;
if (filter_mode != NULL) {
cmp_function = NULL;
while (filters[index].name) {
if (vmm_strcmp(filter_mode, filters[index].name) == 0) {
cmp_function = filters[index].function;
break;
}
index++;
}
}
if (cmp_function == NULL) {
cmd_profile_usage(cdev);
return VMM_EFAIL;
}
kallsyms_on_each_symbol(cmd_profile_count_iterator, count_array);
libsort_smoothsort(count_array, 0, kallsyms_num_syms, cmp_function,
cmd_profile_swap);
for (index = 0; index < kallsyms_num_syms; index++) {
if (count_array[index].count) {
vmm_printf("%-30s %-10u %-10u %u\n",
count_array[index].function_name,
count_array[index].count,
ns_to_micros(count_array[index].total_time),
ns_to_micros(count_array[index].time_per_call));
}
}
return VMM_OK;
}
int cmd_rtcdev_set_time(struct vmm_chardev *cdev, const char * name,
int targc, char **targv)
{
int rc;
char * s;
struct vmm_rtc_time tm;
struct vmm_rtcdev * rtc = vmm_rtcdev_find(name);
if (!rtc) {
vmm_cprintf(cdev, "Error: cannot find rtc %s\n", name);
return VMM_EFAIL;
}
s = targv[0];
rc = 0;
tm.tm_hour = 0;
tm.tm_min = 0;
tm.tm_sec = 0;
while (*s) {
if (*s == ':') {
rc++;
} else if ('0' <= *s && *s <= '9') {
switch(rc) {
case 0:
tm.tm_hour = tm.tm_hour * 10 + (*s - '0');
break;
case 1:
tm.tm_min = tm.tm_min * 10 + (*s - '0');
break;
case 2:
tm.tm_sec = tm.tm_sec * 10 + (*s - '0');
break;
default:
break;
};
}
s++;
}
rc = 0;
tm.tm_mday = vmm_str2int(targv[1], 10);
vmm_str2lower(targv[2]);
if (vmm_strcmp(targv[2], "jan") == 0) {
tm.tm_mon = 0;
} else if (vmm_strcmp(targv[2], "feb") == 0) {
tm.tm_mon = 1;
} else if (vmm_strcmp(targv[2], "mar") == 0) {
tm.tm_mon = 2;
} else if (vmm_strcmp(targv[2], "apr") == 0) {
tm.tm_mon = 3;
} else if (vmm_strcmp(targv[2], "may") == 0) {
tm.tm_mon = 4;
} else if (vmm_strcmp(targv[2], "jun") == 0) {
tm.tm_mon = 5;
} else if (vmm_strcmp(targv[2], "jul") == 0) {
tm.tm_mon = 6;
} else if (vmm_strcmp(targv[2], "aug") == 0) {
tm.tm_mon = 7;
} else if (vmm_strcmp(targv[2], "sep") == 0) {
tm.tm_mon = 8;
} else if (vmm_strcmp(targv[2], "oct") == 0) {
tm.tm_mon = 9;
} else if (vmm_strcmp(targv[2], "nov") == 0) {
tm.tm_mon = 10;
} else if (vmm_strcmp(targv[2], "dec") == 0) {
tm.tm_mon = 11;
} else {
tm.tm_mon = vmm_str2int(targv[2], 10);
}
tm.tm_year = vmm_str2int(targv[3], 10) - 1900;
if (!vmm_rtc_valid_tm(&tm)) {
vmm_cprintf(cdev, "Error: invalid date-time\n");
return VMM_EFAIL;
}
rc = vmm_rtcdev_set_time(rtc, &tm);
if (rc) {
vmm_cprintf(cdev, "Error: set_time failed for rtc %s\n", name);
return rc;
}
return VMM_OK;
}
int arch_vcpu_regs_init(struct vmm_vcpu * vcpu)
{
u32 ite, cpuid;
const char * attr;
/* Initialize User Mode Registers */
/* For both Orphan & Normal VCPUs */
vmm_memset(arm_regs(vcpu), 0, sizeof(arch_regs_t));
arm_regs(vcpu)->pc = vcpu->start_pc;
if (vcpu->is_normal) {
arm_regs(vcpu)->cpsr = CPSR_ZERO_MASK;
arm_regs(vcpu)->cpsr |= CPSR_ASYNC_ABORT_DISABLED;
arm_regs(vcpu)->cpsr |= CPSR_MODE_USER;
} else {
arm_regs(vcpu)->cpsr = CPSR_ZERO_MASK;
arm_regs(vcpu)->cpsr |= CPSR_ASYNC_ABORT_DISABLED;
arm_regs(vcpu)->cpsr |= CPSR_MODE_SUPERVISOR;
arm_regs(vcpu)->sp = vcpu->start_sp;
}
/* Initialize Supervisor Mode Registers */
/* For only Normal VCPUs */
if (!vcpu->is_normal) {
return VMM_OK;
}
attr = vmm_devtree_attrval(vcpu->node,
VMM_DEVTREE_COMPATIBLE_ATTR_NAME);
if (vmm_strcmp(attr, "ARMv7a,cortex-a8") == 0) {
cpuid = ARM_CPUID_CORTEXA8;
} else if (vmm_strcmp(attr, "ARMv5te,ARM926ej") == 0) {
cpuid = ARM_CPUID_ARM926;
} else {
return VMM_EFAIL;
}
if (!vcpu->reset_count) {
vcpu->arch_priv = vmm_malloc(sizeof(arm_priv_t));
vmm_memset(arm_priv(vcpu), 0, sizeof(arm_priv_t));
arm_priv(vcpu)->cpsr = CPSR_ASYNC_ABORT_DISABLED |
CPSR_IRQ_DISABLED |
CPSR_FIQ_DISABLED |
CPSR_MODE_SUPERVISOR;
} else {
for (ite = 0; ite < CPU_FIQ_GPR_COUNT; ite++) {
arm_priv(vcpu)->gpr_usr[ite] = 0x0;
arm_priv(vcpu)->gpr_fiq[ite] = 0x0;
}
arm_priv(vcpu)->sp_usr = 0x0;
arm_priv(vcpu)->lr_usr = 0x0;
arm_priv(vcpu)->sp_svc = 0x0;
arm_priv(vcpu)->lr_svc = 0x0;
arm_priv(vcpu)->spsr_svc = 0x0;
arm_priv(vcpu)->sp_mon = 0x0;
arm_priv(vcpu)->lr_mon = 0x0;
arm_priv(vcpu)->spsr_mon = 0x0;
arm_priv(vcpu)->sp_abt = 0x0;
arm_priv(vcpu)->lr_abt = 0x0;
arm_priv(vcpu)->spsr_abt = 0x0;
arm_priv(vcpu)->sp_und = 0x0;
arm_priv(vcpu)->lr_und = 0x0;
arm_priv(vcpu)->spsr_und = 0x0;
arm_priv(vcpu)->sp_irq = 0x0;
arm_priv(vcpu)->lr_irq = 0x0;
arm_priv(vcpu)->spsr_irq = 0x0;
arm_priv(vcpu)->sp_fiq = 0x0;
arm_priv(vcpu)->lr_fiq = 0x0;
arm_priv(vcpu)->spsr_fiq = 0x0;
cpu_vcpu_cpsr_update(vcpu,
arm_regs(vcpu),
(CPSR_ZERO_MASK |
CPSR_ASYNC_ABORT_DISABLED |
CPSR_IRQ_DISABLED |
CPSR_FIQ_DISABLED |
CPSR_MODE_SUPERVISOR),
CPSR_ALLBITS_MASK);
}
if (!vcpu->reset_count) {
arm_priv(vcpu)->features = 0;
switch (cpuid) {
case ARM_CPUID_ARM926:
arm_set_feature(vcpu, ARM_FEATURE_V4T);
arm_set_feature(vcpu, ARM_FEATURE_V5);
arm_set_feature(vcpu, ARM_FEATURE_VFP);
break;
case ARM_CPUID_CORTEXA8:
arm_set_feature(vcpu, ARM_FEATURE_V4T);
arm_set_feature(vcpu, ARM_FEATURE_V5);
arm_set_feature(vcpu, ARM_FEATURE_V6);
arm_set_feature(vcpu, ARM_FEATURE_V6K);
arm_set_feature(vcpu, ARM_FEATURE_V7);
arm_set_feature(vcpu, ARM_FEATURE_AUXCR);
arm_set_feature(vcpu, ARM_FEATURE_THUMB2);
arm_set_feature(vcpu, ARM_FEATURE_VFP);
arm_set_feature(vcpu, ARM_FEATURE_VFP3);
arm_set_feature(vcpu, ARM_FEATURE_NEON);
arm_set_feature(vcpu, ARM_FEATURE_THUMB2EE);
break;
case ARM_CPUID_CORTEXA9:
arm_set_feature(vcpu, ARM_FEATURE_V4T);
arm_set_feature(vcpu, ARM_FEATURE_V5);
arm_set_feature(vcpu, ARM_FEATURE_V6);
arm_set_feature(vcpu, ARM_FEATURE_V6K);
arm_set_feature(vcpu, ARM_FEATURE_V7);
arm_set_feature(vcpu, ARM_FEATURE_AUXCR);
arm_set_feature(vcpu, ARM_FEATURE_THUMB2);
arm_set_feature(vcpu, ARM_FEATURE_VFP);
arm_set_feature(vcpu, ARM_FEATURE_VFP3);
arm_set_feature(vcpu, ARM_FEATURE_VFP_FP16);
arm_set_feature(vcpu, ARM_FEATURE_NEON);
arm_set_feature(vcpu, ARM_FEATURE_THUMB2EE);
arm_set_feature(vcpu, ARM_FEATURE_V7MP);
break;
default:
break;
};
}
#ifdef CONFIG_ARM32_FUNCSTATS
for (ite=0; ite < ARM_FUNCSTAT_MAX; ite++) {
arm_priv(vcpu)->funcstat[ite].function_name = NULL;
arm_priv(vcpu)->funcstat[ite].entry_count = 0;
arm_priv(vcpu)->funcstat[ite].exit_count = 0;
arm_priv(vcpu)->funcstat[ite].time = 0;
}
#endif
return cpu_vcpu_cp15_init(vcpu, cpuid);
}
