static conf_object_t* new_s3c6410_touchscreen(char* obj_name){
s3c6410_touchscreen_device* dev_ts = skyeye_mm_zero(sizeof(s3c6410_touchscreen_device));
touchscreen_reg_t* regs = skyeye_mm_zero(sizeof(touchscreen_reg_t));
s3c6410_touchscreen_status* status = skyeye_mm_zero(sizeof(s3c6410_touchscreen_status));
dev_ts->obj = new_conf_object(obj_name, dev_ts);
int *Pen_buffer = get_pen_buffer();
Pen_buffer[5] = 1;
status->stylus = Pen_buffer[5];
status->adc_con = -1;
/* init touchscreen regs */
regs->adccon = 0x3fc4;
regs->adctsc = 0x0058;
regs->adcdly = 0x00ff;
regs->adcupdn = 0x0000;
dev_ts->regs = regs;
dev_ts->status = status;
/* registe lcd_ts callback functions */
lcd_touchscreen_t* lcd_ts = skyeye_mm_zero(sizeof(lcd_touchscreen_t));
lcd_ts->touchscreen_update_status = touchscreen_update_status;
lcd_ts->obj = dev_ts->obj;
SKY_register_interface(lcd_ts, obj_name, LCD_TS_INTF_NAME);
/* Register io function to the object */
memory_space_intf* io_memory = skyeye_mm_zero(sizeof(memory_space_intf));
io_memory->conf_obj = dev_ts->obj;
io_memory->read = s3c6410_touchscreen_read;
io_memory->write = s3c6410_touchscreen_write;
SKY_register_interface(io_memory, obj_name, MEMORY_SPACE_INTF_NAME);
return dev_ts->obj;
}
static conf_object_t* create_16550_uart(const char *name){
uart_16550_t* uart = (uart_16550_t *)skyeye_mm_zero(sizeof(uart_16550_t));
/* register own cycle handler to scheduler.
* set the cycle to 1 ms, and periodic schedle
* */
if(!uart){
fprintf(stderr,"MM failed in %s\n",__FUNCTION__);
return NULL;
}
uint32 id;
create_timer_scheduler(1, Periodic_sched, uart_16550_io_do_cycle, uart, &id);
uart->obj = new_conf_object(name,(void *)uart);
reg_16550_t* reg = (reg_16550_t*)skyeye_mm_zero(sizeof(reg_16550_t));
uart->reg = reg;
uart->io_memory = (memory_space_intf *)skyeye_mm_zero(sizeof(*uart->io_memory));
uart->io_memory->conf_obj = uart->obj;
uart->io_memory->read = uart_16550_read;
uart->io_memory->write = uart_16550_write;
/*
* FIXME, we have the same bank data structure both in
* global_memmap and here. Should free one.
* */
return uart->obj;
}
/**
* @brief new instance for addr_space_t, Note that the instance is put to conf_obj hash table.
*
* @param obj_name the instance name
*
* @return new instance
*/
addr_space_t* new_addr_space(char* obj_name){
addr_space_t* space = skyeye_mm_zero(sizeof(addr_space_t));
space->obj = new_conf_object(obj_name, space);
space->memory_space = skyeye_mm_zero(sizeof(memory_space_intf));
space->memory_space->read = space_read;
space->memory_space->write = space_write;
return space;
}
/**
* @brief get the current running architecture
*
* @param arch_name
*
* @return
*/
generic_arch_t * get_arch_instance(const char* arch_name){
if(running_arch_list == NULL){
running_arch_list = skyeye_mm_zero(sizeof(generic_arch_t));
skyeye_config_t* config = get_current_config();
if(config->arch == NULL){
printf("No valid arch option is provided.\n");
asm("int $3");
return NULL;
}
running_arch_list->arch_name = config->arch->arch_name;
running_arch_list->init = config->arch->init;
running_arch_list->reset = config->arch->reset;
running_arch_list->step_once = config->arch->step_once;
running_arch_list->set_pc = config->arch->set_pc;
running_arch_list->get_pc = config->arch->get_pc;
running_arch_list->get_step = config->arch->get_step;
//running_arch_list->ICE_write_byte = config->arch->ICE_write_byte;
//running_arch_list->ICE_read_byte = config->arch->ICE_read_byte;
running_arch_list->get_regval_by_id = config->arch->get_regval_by_id;
running_arch_list->get_regname_by_id = config->arch->get_regname_by_id;
running_arch_list->set_regval_by_id = config->arch->set_regval_by_id;
running_arch_list->get_regnum = config->arch->get_regnum;
running_arch_list->mmu_read = config->arch->mmu_read;
running_arch_list->mmu_write = config->arch->mmu_write;
running_arch_list->signal = config->arch->signal;
}
return running_arch_list;
}
void register_mach(const char* mach_name, mach_init_t mach_init){
machine_config_t * mach;
mach = skyeye_mm_zero(sizeof(machine_config_t));
mach->machine_name = skyeye_strdup(mach_name);
mach->mach_init = mach_init;
mach->next = mach_list;
mach_list = mach;
//skyeye_log(Debug_log, __FUNCTION__, "regiser mach %s successfully.\n", mach->machine_name);
}
static conf_object_t* new_goldfish_pic_device(char* obj_name){
goldfish_pic_device* dev = (goldfish_pic_device *)skyeye_mm_zero(sizeof(goldfish_pic_device));
if(dev == NULL){
fprintf(stderr, "MM failed in %s\n", __FUNCTION__);
return NULL;
}
dev->obj = new_conf_object(obj_name, dev);
dev->slave = skyeye_mm_zero(sizeof(general_signal_intf));
dev->slave->raise_signal = goldfish_pic_raise;
dev->slave->lower_signal = goldfish_pic_lower;
dev->io_memory = skyeye_mm_zero(sizeof(memory_space_intf));
dev->io_memory->conf_obj = dev->obj;
dev->io_memory->read = pic_read;
dev->io_memory->write = pic_write;
dev->state = skyeye_mm_zero(sizeof(pic_state_t));
return dev->obj;
}
static bool arm_cpu_init()
{
skyeye_config_t* config = get_current_config();
machine_config_t *mach = config->mach;
ARM_CPU_State* cpu = (ARM_CPU_State*)skyeye_mm_zero(sizeof(ARM_CPU_State));
if(!cpu){
skyeye_log(Critical_log, __FUNCTION__, "Can not allocate the enough memory for cpu.\n");
skyeye_exit(-1);
}
mach->cpu_data = get_conf_obj_by_cast(cpu, "ARM_CPU_State");
cpu->core_num = 1;
if(!cpu->core_num){
skyeye_log(Critical_log, __FUNCTION__, "Can not get the core number or set wrong mach name?\n");
skyeye_exit(-1);
}
else
cpu->core = (arm_core_t*)skyeye_mm(sizeof(arm_core_t) * cpu->core_num);
/* TODO: zero the memory by malloc */
if(!cpu->core){
skyeye_log(Critical_log, __FUNCTION__, "Can not allocate memory for ppc core.\n");
skyeye_exit(-1);
}
else
skyeye_log(Info_log, __FUNCTION__, "Initilization for %d core\n", cpu->core_num);
int i;
for(i = 0; i < cpu->core_num; i++){
arm_core_t* core = &cpu->core[i];
arm_core_init(core, i);
arm_dyncom_init(core);
skyeye_exec_t* exec = create_exec();
//exec->priv_data = get_conf_obj_by_cast(core, "arm_core_t");
exec->priv_data = (conf_object_t*)core;
exec->run = (void (*)(conf_object_t*))per_cpu_step;
exec->stop = (void (*)(conf_object_t*))per_cpu_stop;
add_to_default_cell(exec);
}
cpu->boot_core_id = 0;
return true;
}
exception_t
init_arm_dyncom ()
{
arch_config_t* arm_arch = (arch_config_t*)skyeye_mm_zero(sizeof(arch_config_t));
arm_arch->arch_name = "arm_dyncom";
arm_arch->init = arm_init_state;
arm_arch->reset = arm_reset_state;
arm_arch->set_pc = arm_set_pc;
arm_arch->get_pc = arm_get_pc;
arm_arch->get_step = arm_get_step;
arm_arch->step_once = arm_step_once;
arm_arch->stop = arm_stop;
arm_arch->ICE_write_byte = arm_ICE_write_byte;
arm_arch->ICE_read_byte = arm_ICE_read_byte;
arm_arch->parse_cpu = arm_parse_cpu;
arm_arch->get_regval_by_id = arm_get_regval_by_id;
arm_arch->get_regname_by_id = arm_get_regname_by_id;
arm_arch->set_regval_by_id = arm_set_register_by_id;
register_arch (arm_arch);
return No_exp;
}
/**
* @brief initialization of a symbol table
*
* @param filename
* @param arch_name
*/
void init_symbol_table(char* filename, char* arch_name)
{
long i,j, digit;
ENTRY newentry, *oldentry;
SYM_FUNC *symp;
asymbol *symptr;
int key;
bfd *abfd;
if(!filename){
skyeye_info("Can not get correct kernel filename!Maybe your skyeye.conf have something wrong!\n");
return;
}
abfd = bfd_openr (filename, get_bfd_target(arch_name));
if (!bfd_check_format(abfd, bfd_object)) {
bfd_close(abfd);
skyeye_log(Debug_log, __FUNCTION__, "wrong bfd format\n");
return;
//exit(0);
}
storage_needed = bfd_get_symtab_upper_bound(abfd);
if (storage_needed < 0){
printf("FAIL\n");
exit(0);
}
symbol_table = (asymbol **) skyeye_mm_zero (storage_needed);
if(symbol_table == NULL){
fprintf(stderr, "Can not alloc memory for symbol table.\n");
exit(0);
}
number_of_symbols =
bfd_canonicalize_symtab (abfd, symbol_table);
kernel_number = number_of_symbols; /* <tktan> BUG200106022219 */
if (number_of_symbols < 0){
printf("FAIL\n");
exit(0);
}
if (!hcreate(number_of_symbols << 1)) {
printf("Not enough memory for hash table\n");
exit(0);
}
for (i = 0; i < number_of_symbols; i++) {
symptr = symbol_table[i] ;
key = symptr->value + symptr->section->vma; // adjust for section address
if (((i<kernel_number) && (symbol_table[i]->flags == 0x01)) || // <tktan> BUG200105172154, BUG200106022219
((i<kernel_number) && (symbol_table[i]->flags == 0x02)) || // <tktan> BUG200204051654
(symbol_table[i]->flags & 0x10)) { // Is a function symbol
// printf("%x %8x %s\n", symbol_table[i]->flags, key, symbol_table[i]->name);
// ***********************************************************
// This is converting the function symbol value to char string
// and use it as a key in the GNU hash table
// ********************************************************
newentry.key = (char *) skyeye_mm_zero(9);
for (j=0;j<8;j++) {
newentry.key[j] = itoa_tab[((key) >> (j << 2)) & 0xf] ;
}
newentry.key[8] = 0 ;
// *************************************************
// This is allocating memory for a struct funcsym
// *************************************************
symp = (SYM_FUNC *) skyeye_mm_zero(sizeof(SYM_FUNC));
newentry.data = (char *) symp;
symp->name = (char *) symbol_table[i]->name ;
symp->total_cycle = 0;
symp->total_energy = 0;
symp->instances = 0;
// ***********************************************
// Insert into hash table
// *******************************************
/* <tktan> BUG200106022219 */
oldentry = hsearch(newentry, FIND) ;
if (oldentry) { // was entered
// printf("Duplicate Symbol: %x %s\n", key, symp->name);
oldentry->data = (char *) symp ;
} else if (!hsearch(newentry, ENTER)) {
printf("Insufficient memory\n");
exit(0) ;
}
}
}
