static void load_symbols_without_infotype(int respect_args)
{
free_ioports(ports, numports);
respect_info = respect_args;
ports = read_ioports(&numports, cfgname, device, sizeof(device), callback);
create_mappings();
}
//------------------------------------------------------------------
static bool apply_config_file(int _respect_info)
{
if ( strcmp(device, NONEPROC) == 0 ) // processor not selected
return true;
char cfgfile[QMAXFILE];
char cfgpath[QMAXPATH];
get_cfg_filename(cfgfile, sizeof(cfgfile));
if ( getsysfile(cfgpath, sizeof(cfgpath), cfgfile, CFG_SUBDIR) == NULL )
{
#ifndef SILENT
warning("ICON ERROR\n"
"Can not open %s, I/O port definitions are not loaded", cfgfile);
#endif
return false;
}
deviceparams[0] = '\0';
if ( !CHECK_IORESP ) _respect_info = 0;
respect_info = _respect_info;
free_ioports(ports, numports);
ports = read_ioports(&numports, cfgpath, device, sizeof(device), callback);
if ( respect_info & IORESP_PORT )
{
for ( int i=0; i < numports; i++ )
{
ioport_t *p = ports + i;
#ifdef I8051
segment_t *s = get_segm_by_name("FSR");
if ( s != NULL )
{
set_name(p->address + s->startEA - 0x80, p->name);
set_cmt(p->address + s->startEA - 0x80, p->cmt, true);
}
#else
set_name(p->address, p->name);
set_cmt(p->address, p->cmt, true);
#endif
}
}
return true;
}
static void load_symbols(int _respect_info)
{
if ( cfgname != NULL )
{
deviceparams[0] = '\0';
respect_info = _respect_info;
if ( !inf.like_binary() ) respect_info &= ~2;
free_ioports(ports, numports);
ports = read_ioports(&numports, cfgname, device, sizeof(device), callback);
if ( respect_info )
{
for ( int i=0; i < numports; i++ )
{
ea_t ea = ports[i].address;
doByte(ea, 1);
const char *name = ports[i].name;
if ( !set_name(ea, name, SN_NOWARN) )
set_cmt(ea, name, 0);
else
set_cmt(ea, ports[i].cmt, true);
}
}
}
}
static void load_symbols(void)
{
free_ioports(ports, numports);
ports = read_ioports(&numports, cfgname, device, sizeof(device), NULL);
}
void hd_scan_misc(hd_data_t *hd_data)
{
hd_t *hd;
hd_res_t *res;
int fd, i;
char *s = NULL;
bios_info_t *bt = NULL;
char par[] = "parport0";
int fd_ser0, fd_ser1;
if(!hd_probe_feature(hd_data, pr_misc)) return;
hd_data->module = mod_misc;
/* some clean-up */
remove_hd_entries(hd_data);
hd_data->misc = free_misc(hd_data->misc);
PROGRESS(9, 0, "kernel log");
read_klog(hd_data);
if((hd_data->debug & HD_DEB_MISC)) dump_klog(hd_data);
PROGRESS(1, 0, "misc data");
hd_data->misc = new_mem(sizeof *hd_data->misc);
/* this is enough to load the module */
fd_ser0 = fd_ser1 = -1;
#if !defined(__sparc__)
/* On sparc, the close needs too long */
if(hd_probe_feature(hd_data, pr_misc_serial)) {
PROGRESS(1, 1, "open serial");
fd_ser0 = open("/dev/ttyS0", O_RDONLY | O_NONBLOCK);
fd_ser1 = open("/dev/ttyS1", O_RDONLY | O_NONBLOCK);
/* keep the devices open until the resources have been read */
}
#endif
/* this is enough to load the module */
if(!hd_data->flags.no_parport && hd_probe_feature(hd_data, pr_misc_par)) {
PROGRESS(1, 2, "open parallel");
/* what can the BIOS tell us? */
for(hd = hd_data->hd; hd; hd = hd->next) {
if(
hd->base_class.id == bc_internal &&
hd->sub_class.id == sc_int_bios &&
hd->detail &&
hd->detail->type == hd_detail_bios &&
hd->detail->bios.data
) break;
}
if(hd) {
bt = hd->detail->bios.data;
if(bt->par_port0) {
str_printf(&s, 0, "io=0x%x", bt->par_port0);
if(bt->par_port1) {
str_printf(&s, -1, ",0x%x", bt->par_port1);
if(bt->par_port2) str_printf(&s, -1, ",0x%x", bt->par_port2);
}
str_printf(&s, -1, " irq=none,none,none");
}
unload_module(hd_data, "parport_probe");
unload_module(hd_data, "lp");
unload_module(hd_data, "parport_pc");
unload_module(hd_data, "parport");
/* now load it with the right io */
load_module(hd_data, "parport");
load_module_with_params(hd_data, "parport_pc", s);
free_mem(s);
}
/* now load the rest of the modules */
fd = open("/dev/lp0", O_RDONLY | O_NONBLOCK);
if(fd >= 0) close(fd);
}
/*
* floppy driver resources are allocated only temporarily,
* so we access it just before we read the resources
*/
if(hd_probe_feature(hd_data, pr_misc_floppy)) {
/* look for a floppy *device* entry... */
for(hd = hd_data->hd; hd; hd = hd->next) {
if(
hd->base_class.id == bc_storage_device &&
hd->sub_class.id == sc_sdev_floppy &&
hd->unix_dev_name &&
!strncmp(hd->unix_dev_name, "/dev/fd", sizeof "/dev/fd" - 1)
) {
PROGRESS(1, 3, "read floppy");
i = 5;
hd->block0 = read_block0(hd_data, hd->unix_dev_name, &i);
hd->is.notready = hd->block0 ? 0 : 1;
if(i < 0) {
hd->tag.remove = 1;
ADD2LOG("misc.floppy: removing floppy entry %u (timed out)\n", hd->idx);
}
if(!hd->is.notready) {
struct hd_geometry geo;
int fd;
unsigned size, blk_size = 0x200;
fd = open(hd->unix_dev_name, O_RDONLY | O_NONBLOCK);
if(fd >= 0) {
if(!ioctl(fd, HDIO_GETGEO, &geo)) {
ADD2LOG("floppy ioctl(geo) ok\n");
res = add_res_entry(&hd->res, new_mem(sizeof *res));
res->disk_geo.type = res_disk_geo;
res->disk_geo.cyls = geo.cylinders;
res->disk_geo.heads = geo.heads;
res->disk_geo.sectors = geo.sectors;
res->disk_geo.geotype = geo_logical;
size = geo.cylinders * geo.heads * geo.sectors;
for(res = hd->res; res; res = res->next) {
if(res->any.type == res_size && res->size.unit == size_unit_sectors) {
res->size.val1 = size; res->size.val2 = blk_size;
break;
}
}
if(!res) {
res = add_res_entry(&hd->res, new_mem(sizeof *res));
res->size.type = res_size;
res->size.unit = size_unit_sectors;
res->size.val1 = size; res->size.val2 = blk_size;
}
}
close(fd);
}
}
break;
}
}
remove_tagged_hd_entries(hd_data);
}
PROGRESS(2, 1, "io");
read_ioports(hd_data->misc);
PROGRESS(2, 2, "dma");
read_dmas(hd_data->misc);
PROGRESS(2, 3, "irq");
read_irqs(hd_data->misc);
if((hd_data->debug & HD_DEB_MISC)) dump_misc_proc_data(hd_data);
if(fd_ser0 >= 0) close(fd_ser0);
if(fd_ser1 >= 0) close(fd_ser1);
/* now create some system generic entries */
/* FPU */
PROGRESS(3, 0, "FPU");
res = NULL;
gather_resources(hd_data->misc, &res, "fpu", 0);
if(res) {
hd = add_hd_entry(hd_data, __LINE__, 0);
hd->base_class.id = bc_internal;
hd->sub_class.id = sc_int_fpu;
hd->res = res;
}
/* DMA */
PROGRESS(3, 1, "DMA");
res = NULL;
gather_resources(hd_data->misc, &res, "dma1", 0);
gather_resources(hd_data->misc, &res, "dma2", 0);
gather_resources(hd_data->misc, &res, "dma page reg", 0);
gather_resources(hd_data->misc, &res, "cascade", W_DMA);
if(res) {
hd = add_hd_entry(hd_data, __LINE__, 0);
hd->base_class.id = bc_system;
hd->sub_class.id = sc_sys_dma;
hd->res = res;
}
/* PIC */
PROGRESS(3, 2, "PIC");
res = NULL;
gather_resources(hd_data->misc, &res, "pic1", 0);
gather_resources(hd_data->misc, &res, "pic2", 0);
gather_resources(hd_data->misc, &res, "cascade", W_IRQ);
if(res) {
hd = add_hd_entry(hd_data, __LINE__, 0);
hd->base_class.id = bc_system;
hd->sub_class.id = sc_sys_pic;
hd->res = res;
}
/* timer */
PROGRESS(3, 3, "timer");
res = NULL;
gather_resources(hd_data->misc, &res, "timer", 0);
if(res) {
hd = add_hd_entry(hd_data, __LINE__, 0);
hd->base_class.id = bc_system;
hd->sub_class.id = sc_sys_timer;
hd->res = res;
}
/* real time clock */
PROGRESS(3, 4, "RTC");
res = NULL;
gather_resources(hd_data->misc, &res, "rtc", 0);
if(res) {
hd = add_hd_entry(hd_data, __LINE__, 0);
hd->base_class.id = bc_system;
hd->sub_class.id = sc_sys_rtc;
hd->res = res;
}
/* keyboard */
res = NULL;
gather_resources(hd_data->misc, &res, "keyboard", 0);
if(res) {
hd = add_hd_entry(hd_data, __LINE__, 0);
hd->base_class.id = bc_input;
hd->sub_class.id = sc_inp_keyb;
hd->res = res;
}
/* parallel ports */
for(i = 0; i < 1; i++, par[sizeof par - 2]++) {
res = NULL;
gather_resources(hd_data->misc, &res, par, 0);
if(res) {
hd = add_hd_entry(hd_data, __LINE__, 0);
hd->base_class.id = bc_comm;
hd->sub_class.id = sc_com_par;
str_printf(&hd->unix_dev_name, 0, "/dev/lp%d", i);
hd->res = res;
}
}
/* floppy controller */
res = NULL;
gather_resources(hd_data->misc, &res, "floppy", 0);
gather_resources(hd_data->misc, &res, "floppy DIR", 0);
if(res) {
/* look for an existing entry */
for(hd = hd_data->hd; hd; hd = hd->next) {
if(hd->base_class.id == bc_storage && hd->sub_class.id == sc_sto_floppy) break;
}
/* missing, so create one */
if(!hd) {
hd = add_hd_entry(hd_data, __LINE__, 0);
hd->base_class.id = bc_storage;
hd->sub_class.id = sc_sto_floppy;
}
hd->res = res;
}
/*
* look for PS/2 port
*
* The catch is, that sometimes /dev/psaux is accessible only for root,
* so the open() may fail but there are irq events registered.
*
*/
fd = open(DEV_PSAUX, O_RDONLY | O_NONBLOCK);
if(fd >= 0) close(fd);
res = NULL;
gather_resources(hd_data->misc, &res, "PS/2 Mouse", 0);
if(res || fd >= 0) {
hd = add_hd_entry(hd_data, __LINE__, 0);
hd->base_class.id = bc_ps2;
if(res) {
hd->res = res;
}
}
}
static int notify(processor_t::idp_notify msgid, ...)
{
va_list va;
va_start(va, msgid);
// A well behaving processor module should call invoke_callbacks()
// in his notify() function. If this function returns 0, then
// the processor module should process the notification itself
// Otherwise the code should be returned to the caller:
int code = invoke_callbacks(HT_IDP, msgid, va);
if ( code ) return code;
switch(msgid)
{
case processor_t::init:
// __emit__(0xCC); // debugger trap
helper.create("$ hppa");
inf.mf = 1; // always big endian
syscalls = read_ioports(&nsyscalls, "hpux.cfg", NULL, 0, NULL);
break;
case processor_t::term:
free_ioports(syscalls, nsyscalls);
break;
case processor_t::newfile: // new file loaded
handle_new_flags();
setup_got();
break;
case processor_t::oldfile: // old file loaded
idpflags = helper.altval(-1);
handle_new_flags();
setup_got();
break;
case processor_t::newprc: // new processor type
break;
case processor_t::newasm: // new assembler type
break;
case processor_t::newseg: // new segment
{
segment_t *sptr = va_arg(va, segment_t *);
sptr->defsr[ rVds-ph.regFirstSreg] = find_selector(sptr->sel);
sptr->defsr[DPSEG-ph.regFirstSreg] = 0;
}
break;
case processor_t::is_sane_insn:
return is_sane_insn(va_arg(va, int));
case processor_t::may_be_func:
// can a function start here?
// arg: none, the instruction is in 'cmd'
// returns: probability 0..100
// 'cmd' structure is filled upon the entrace
// the idp module is allowed to modify 'cmd'
return may_be_func();
case processor_t::is_basic_block_end:
return is_basic_block_end() ? 2 : 0;
// +++ TYPE CALLBACKS (only 32-bit programs for the moment)
case processor_t::decorate_name:
{
const til_t *ti = va_arg(va, const til_t *);
const char *name = va_arg(va, const char *);
const type_t *type = va_arg(va, const type_t *);
char *outbuf = va_arg(va, char *);
size_t bufsize = va_arg(va, size_t);
bool mangle = va_argi(va, bool);
cm_t real_cc = va_argi(va, cm_t);
return gen_decorate_name(ti, name, type, outbuf, bufsize, mangle, real_cc);
}
case processor_t::max_ptr_size:
return 4+1;
case processor_t::based_ptr:
{
/*unsigned int ptrt =*/ va_arg(va, unsigned int);
char **ptrname = va_arg(va, char **);
*ptrname = NULL;
return 0; // returns: size of type
}
case processor_t::get_default_enum_size: // get default enum size
// args: cm_t cm
// returns: sizeof(enum)
{
// cm_t cm = va_arg(va, cm_t);
return inf.cc.size_e;
}
case processor_t::calc_arglocs:
{
const type_t **type = va_arg(va, const type_t **);
ulong *arglocs = va_arg(va, ulong *);
int maxn = va_arg(va, int);
return hppa_calc_arglocs(*type, arglocs, maxn);
}
// this callback is never used because the stack pointer does not
// change for each argument
// we use ph.use_arg_types instead
case processor_t::use_stkarg_type:
// use information about a stack argument
{
return false; // say failed all the time
// so that the kernel attaches a comment
}
case processor_t::use_regarg_type:
{
ea_t ea = va_arg(va, ea_t);
const type_t * const *types = va_arg(va, const type_t * const *);
const char * const *names = va_arg(va, const char * const *);
const ulong *regs = va_arg(va, const ulong *);
int n = va_arg(va, int);
return hppa_use_regvar_type(ea, types, names, regs, n);
}
case processor_t::use_arg_types:
{
ea_t ea = va_arg(va, ea_t);
const type_t * const *types = va_arg(va, const type_t * const *);
const char * const *names = va_arg(va, const char * const *);
const ulong *arglocs = va_arg(va, const ulong *);
int n = va_arg(va, int);
const type_t **rtypes = va_arg(va, const type_t **);
const char **rnames = va_arg(va, const char **);
ulong *regs = va_arg(va, ulong *);
int rn = va_arg(va, int);
return hppa_use_arg_types(ea, types, names, arglocs, n,
rtypes, rnames, regs, rn);
}
case processor_t::get_fastcall_regs:
{
const int **regs = va_arg(va, const int **);
static const int fregs[] = { R26, R25, R24, R23, -1 };
*regs = fregs;
return qnumber(fregs) - 1;
}
case processor_t::get_thiscall_regs:
{
const int **regs = va_arg(va, const int **);
*regs = NULL;
return 0;
}
case processor_t::calc_cdecl_purged_bytes:
// calculate number of purged bytes after call
{
// ea_t ea = va_arg(va, ea_t);
return 0;
}
case processor_t::get_stkarg_offset:
// get offset from SP to the first stack argument
// args: none
// returns: the offset
return -0x34;
// --- TYPE CALLBACKS
case processor_t::loader:
break;
}
va_end(va);
return 1;
}
