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) ; } } }