void i82541_device::device_start()
{
pci_device::device_start();
add_map(128*1024, M_MEM, FUNC(i82541_device::registers_map));
add_map(128*1024, M_MEM, FUNC(i82541_device::flash_map));
add_map(32, M_IO, FUNC(i82541_device::registers_io_map));
}
void sega_lindbergh_baseboard_device::device_start()
{
pci_device::device_start();
add_map( 128*1024, M_MEM, FUNC(sega_lindbergh_baseboard_device::map1));
add_map( 1024*1024, M_MEM, FUNC(sega_lindbergh_baseboard_device::map2));
add_map(2*1024*1024, M_MEM, FUNC(sega_lindbergh_baseboard_device::map3));
}
void pci9050_device::device_start()
{
pci_device::device_start();
add_map(0x80, M_MEM, FUNC(pci9050_device::map)); // map 0 is our config registers, mem space
add_map(0x80, M_IO, FUNC(pci9050_device::map)); // map 1 is our config registers, i/o space
for(int i=0; i<4; i++)
if(!m_maps[i].isnull())
add_map(0, M_MEM | M_DISABLED, m_maps[i], m_devices[i]);
else
add_map(0, M_MEM | M_DISABLED, address_map_constructor(), nullptr);
m_user_input_handler.resolve();
m_user_output_handler.resolve();
// Save states
save_item(NAME(m_lasrr));
save_item(NAME(m_lasba));
save_item(NAME(m_lasbrd));
save_item(NAME(m_csbase));
save_item(NAME(m_eromrr));
save_item(NAME(m_eromba));
save_item(NAME(m_erombrd));
save_item(NAME(m_intcsr));
save_item(NAME(m_cntrl));
machine().save().register_postload(save_prepost_delegate(FUNC(pci9050_device::postload), this));
}
void voodoo_pci_device::device_start()
{
voodoo_device::static_set_cpu_tag(m_voodoo, m_cpu_tag);
voodoo_device::static_set_fbmem(m_voodoo, m_fbmem);
voodoo_device::static_set_tmumem(m_voodoo, m_tmumem0, m_tmumem1);
switch (m_type) {
//void set_ids(UINT32 main_id, UINT8 revision, UINT32 pclass, UINT32 subsystem_id);
case TYPE_VOODOO_1:
set_ids(0x121a0001, 0x02, 0x000000, 0x000000);
break;
case TYPE_VOODOO_2:
set_ids(0x121a0002, 0x02, 0x040000, 0x000000);
break;
case TYPE_VOODOO_BANSHEE:
set_ids(0x121a0003, 0x02, 0x000003, 0x000000);
break;
//case TYPE_VOODOO_3
default:
set_ids(0x121a0005, 0x02, 0x000003, 0x000000);
break;
}
pci_device::device_start();
if (m_type<=TYPE_VOODOO_2) {
add_map(16*1024*1024, M_MEM | M_PREF, FUNC(voodoo_pci_device::voodoo_reg_map));
} else {
add_map(32*1024*1024, M_MEM, FUNC(voodoo_pci_device::banshee_reg_map));
add_map(32*1024*1024, M_MEM, FUNC(voodoo_pci_device::lfb_map));
add_map(256, M_IO, FUNC(voodoo_pci_device::io_map));
}
}
void pci9050_device::device_start()
{
typedef void (pci9050_device::*tramp_t)(address_map &, device_t &);
static const tramp_t trampolines[4] = {
&pci9050_device::map_trampoline<0>,
&pci9050_device::map_trampoline<1>,
&pci9050_device::map_trampoline<2>,
&pci9050_device::map_trampoline<3>
};
pci_device::device_start();
add_map(0x80, M_MEM, FUNC(pci9050_device::map)); // map 0 is our config registers, mem space
add_map(0x80, M_IO, FUNC(pci9050_device::map)); // map 1 is our config registers, i/o space
for(int i=0; i<4; i++)
if(m_names[i])
// add_map(0, M_MEM | M_DISABLED, m_maps[i], m_names[i], m_devices[i]);
add_map(0, M_MEM | M_DISABLED, trampolines[i], m_names[i]);
else
add_map(0, M_MEM | M_DISABLED, FUNC(pci9050_device::empty));
m_user_input_handler.resolve();
m_user_output_handler.resolve();
}
void geforce_6800gt_device::device_start()
{
pci_device::device_start();
add_map( 16*1024*1024, M_MEM, FUNC(geforce_6800gt_device::map1));
add_map(256*1024*1024, M_MEM, FUNC(geforce_6800gt_device::map2));
add_map( 16*1024*1024, M_MEM, FUNC(geforce_6800gt_device::map3));
}
void ide_pci_device::device_start()
{
if (m_irq_num != -1)
m_cpu = machine().device<cpu_device>(m_cpu_tag);
pci_device::device_start();
add_map(8, M_IO, FUNC(ide_pci_device::chan1_data_command_map));
add_map(4, M_IO, FUNC(ide_pci_device::chan1_control_map));
add_map(8, M_IO, FUNC(ide_pci_device::chan2_data_command_map));
add_map(4, M_IO, FUNC(ide_pci_device::chan2_control_map));
add_map(16, M_IO, FUNC(ide_pci_device::bus_master_map));
// Setup stored BARs
pci_bar[0] = 0x1f0;
pci_bar[1] = 0x3f4;
pci_bar[2] = 0x170;
pci_bar[3] = 0x374;
pci_bar[4] = 0xf00;
m_irq_handler.resolve_safe();
intr_pin = 0x1;
intr_line = 0xe;
// Save states
save_item(NAME(pci_bar));
save_item(NAME(m_config_data));
}
void DataMap::console_map(char* p) { // todo - don't need this param
char* p1 = strtok(NULL, " ");
if(p1 == NULL) {
console_dump_map();
} else {
char* p2 = strtok(NULL, " ");
if(p2 == NULL) {
console->console_print("Command requires at least two parameters. Please retry\r\n");
} else {
char* p3 = strtok(NULL, " ");
if(p3 == NULL) {
if(!add_map(p1, p2, (char*)"1.0")) {
console->console_print("Command was not understood. Please check syntax and retry\r\n");
} else {
console->console_print("%s is now mapped to %s with a scale of 1.0\r\n", p1, p2);
}
} else {
if(!add_map(p1, p2, p3)) {
console->console_print("Command was not understood. Please check syntax and retry\r\n");
} else {
console->console_print("%s is now mapped to %s with a scale of %s\r\n", p1, p2, p3);
}
}
}
}
}
void geforce_7600gs_device::device_start()
{
pci_device::device_start();
add_map( 16*1024*1024, M_MEM, FUNC(geforce_7600gs_device::map1));
add_map(256*1024*1024, M_MEM, FUNC(geforce_7600gs_device::map2));
add_map( 16*1024*1024, M_MEM, FUNC(geforce_7600gs_device::map3));
add_rom_from_region();
}
void ac97_device::device_start()
{
pci_device::device_start();
add_map(256, M_IO, FUNC(ac97_device::native_audio_mixer_map));
add_map(64, M_IO, FUNC(ac97_device::native_audio_bus_mastering_map));
add_map(512, M_MEM, FUNC(ac97_device::mixer_map));
add_map(256, M_MEM, FUNC(ac97_device::bus_mastering_map));
}
void DataMap::write_factory_settings() {
EEPROM.write(EEPROM_ADDR_FRSKY_VFAS_ENABLE, 1);
add_map((char*)"bar_altitude", (char*)"vario_altitude", (char*)"100.0");
add_map((char*)"climb_rate", (char*)"vario_vertical_speed", (char*)"100.0");
EEPROM.write(EEPROM_LED_CODE_SIZE, (sizeof(default_program) << 8) & 0xff);
EEPROM.write(EEPROM_LED_CODE_SIZE + 1, sizeof(default_program) & 0xff);
for(uint16_t i=0; i<sizeof(default_program); i++) {
EEPROM.write(EEPROM_LED_CODE_BASE + i, default_program[i]);
}
}
void map_collector::do_edge(call_graph_edge* e) {
if (!e->is_fold_edge()) {
call_graph_node* n = e->callee;
if (n->is_method_node()) {
add_map(((method_node*) n)->receiverMapOop());
add_map(((method_node*) n)->methodHolder_map());
} else if (n->is_access_node()) {
add_map(((access_node*) n)->receiverMapOop());
add_map(((access_node*) n)->methodHolder_map());
}
}
}
static gint
lua_config_add_kv_map (lua_State *L)
{
struct rspamd_config *cfg = lua_check_config (L);
const gchar *map_line, *description;
GHashTable **r, ***ud;
if (cfg) {
map_line = luaL_checkstring (L, 2);
description = lua_tostring (L, 3);
r = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (GHashTable *));
*r = g_hash_table_new (rspamd_strcase_hash, rspamd_strcase_equal);
if (!add_map (cfg, map_line, description, read_kv_list, fin_kv_list,
(void **)r)) {
msg_warn ("invalid hash map %s", map_line);
g_hash_table_destroy (*r);
lua_pushnil (L);
return 1;
}
rspamd_mempool_add_destructor (cfg->cfg_pool,
(rspamd_mempool_destruct_t)g_hash_table_destroy,
*r);
ud = lua_newuserdata (L, sizeof (GHashTable *));
*ud = r;
rspamd_lua_setclass (L, "rspamd{hash_table}", -1);
return 1;
}
lua_pushnil (L);
return 1;
}
static gint
lua_config_add_radix_map (lua_State *L)
{
struct rspamd_config *cfg = lua_check_config (L);
const gchar *map_line, *description;
radix_compressed_t **r, ***ud;
if (cfg) {
map_line = luaL_checkstring (L, 2);
description = lua_tostring (L, 3);
r = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (radix_compressed_t *));
*r = radix_create_compressed ();
if (!add_map (cfg, map_line, description, read_radix_list,
fin_radix_list, (void **)r)) {
msg_warn ("invalid radix map %s", map_line);
radix_destroy_compressed (*r);
lua_pushnil (L);
return 1;
}
ud = lua_newuserdata (L, sizeof (radix_compressed_t *));
*ud = r;
rspamd_lua_setclass (L, "rspamd{radix}", -1);
return 1;
}
lua_pushnil (L);
return 1;
}
static int
add_map (CMap *cmap, mapDef *mtab,
unsigned char *codestr, int depth)
{
int c;
mapDef *mtab1;
for (c = 0; c < 256; c++) {
codestr[depth] = (unsigned char) (c & 0xff);
if (LOOKUP_CONTINUE(mtab[c].flag)) {
mtab1 = mtab[c].next;
add_map(cmap, mtab1, codestr, depth + 1);
} else {
if (MAP_DEFINED(mtab[c].flag)) {
switch (MAP_TYPE(mtab[c].flag)) {
case MAP_IS_CID: case MAP_IS_CODE:
CMap_add_bfchar(cmap,
codestr, depth + 1,
mtab[c].code, mtab[c].len);
break;
case MAP_IS_NAME:
ERROR("%s: Unexpected error...", CMAP_DEBUG_STR);
break;
case MAP_IS_NOTDEF:
break;
default:
ERROR("%s: Unknown mapping type: %d",
CMAP_DEBUG_STR, MAP_TYPE(mtab[c].flag));
}
}
}
}
return 0;
}
/*----------------------------------------------------------------------
* Check along a line to see which single characters may be added
* in each position
*----------------------------------------------------------------------*/
void find_allowed(const char *line, /* row or column of the board */
Map available, /* which letters the player has */
Map allow[]) /* which letters may be placed */
{
int k,i,j;
Map map;
char lline[15+1]; /* local copy of line */
strncpy(lline, line, 15); /* take local copy */
for (k=0; k<15; k++) {
if (line[k] != EMPTY) { /* already a tile there */
map = empty_map;
add_map(map, line[k]); /* allow just that letter */
}else{
i = k;
while (i>0 && line[i-1] != EMPTY) {
i--; /* find first preceding letter */
}
j = k;
while (j<15-1 && line[j+1] != EMPTY) {
j++; /* find last following letter */
}
if (i==j) { /* none adjacent */
map = available; /* so any letter will do */
}else{
map = try_gap(lline+i, j+1-i, k-i, available); /* try each letter */
}
}
allow[k] = map;
}
}
map_enumeration::map_enumeration(MapTable* gm)
: enumeration((unsigned long)AllBits) {
graph_maps = gm;
// add all maps in gm
for (fint i = 0; i < gm->size; i++) {
for (MapTableEntry* link = gm->table[i]; link; link = link->next) {
add_map(link->map->map_addr());
}
}
}
static struct ptr_valid_map *get_proc_maps(unsigned int *num)
{
char *buf, *p;
struct ptr_valid_map *map;
unsigned int max = 16;
buf = grab("/proc/self/maps");
if (!buf) {
*num = 0;
return NULL;
}
map = malloc(sizeof(*map) * max);
if (!map)
goto free_buf;
*num = 0;
for (p = buf; p && *p; p = skip_line(p)) {
unsigned long start, end;
char *endp;
/* Expect '<start-in-hex>-<end-in-hex> rw... */
start = strtoul(p, &endp, 16);
if (*endp != '-')
goto malformed;
end = strtoul(endp+1, &endp, 16);
if (*endp != ' ')
goto malformed;
endp++;
if (endp[0] != 'r' && endp[0] != '-')
goto malformed;
if (endp[1] != 'w' && endp[1] != '-')
goto malformed;
/* We only add readable mappings. */
if (endp[0] == 'r') {
map = add_map(map, num, &max, start, end,
endp[1] == 'w');
if (!map)
goto free_buf;
}
}
free(buf);
return map;
malformed:
free(map);
free_buf:
free(buf);
*num = 0;
return NULL;
}
void ide_pci_device::device_start()
{
if (m_irq_num != -1)
m_cpu = machine().device<cpu_device>(m_cpu_tag);
pci_device::device_start();
add_map(8, M_IO, FUNC(ide_pci_device::chan1_data_command_map));
bank_infos[0].adr = 0x1f0;
add_map(4, M_IO, FUNC(ide_pci_device::chan1_control_map));
bank_infos[1].adr = 0x3f4;
add_map(8, M_IO, FUNC(ide_pci_device::chan2_data_command_map));
bank_infos[2].adr = 0x170;
add_map(4, M_IO, FUNC(ide_pci_device::chan2_control_map));
bank_infos[3].adr = 0x374;
add_map(16, M_IO, FUNC(ide_pci_device::bus_master_map));
bank_infos[4].adr = 0xf00;
m_irq_handler.resolve_safe();
}
Map rack_map(Rack rack)
{
Map map;
if (rack.nblank != 0) {
map = allset_map;
}else{
char *s;
map = empty_map;
for (s=rack.tile; *s != '\0'; s++) {
add_map(map, *s);
}
}
return map;
}
static gint
lua_config_add_map (lua_State *L)
{
struct rspamd_config *cfg = lua_check_config (L);
const gchar *map_line, *description;
struct lua_map_callback_data *cbdata, **pcbdata;
int cbidx;
if (cfg) {
map_line = luaL_checkstring (L, 2);
if (lua_gettop (L) == 4) {
description = lua_tostring (L, 3);
cbidx = 4;
}
else {
description = NULL;
cbidx = 3;
}
if (lua_type (L, cbidx) == LUA_TFUNCTION) {
cbdata = g_slice_alloc (sizeof (*cbdata));
cbdata->L = L;
cbdata->data = NULL;
lua_pushvalue (L, cbidx);
/* Get a reference */
cbdata->ref = luaL_ref (L, LUA_REGISTRYINDEX);
pcbdata = rspamd_mempool_alloc (cfg->cfg_pool, sizeof (cbdata));
*pcbdata = cbdata;
if (!add_map (cfg, map_line, description, lua_map_read, lua_map_fin,
(void **)pcbdata)) {
msg_warn ("invalid hash map %s", map_line);
lua_pushboolean (L, false);
}
else {
lua_pushboolean (L, true);
}
}
else {
msg_warn ("invalid callback argument for map %s", map_line);
lua_pushboolean (L, false);
}
}
else {
lua_pushboolean (L, false);
}
return 1;
}
void voodoo_pci_device::device_start()
{
voodoo_device::static_set_cpu_tag(*m_voodoo, m_cpu_tag);
voodoo_device::static_set_fbmem(*m_voodoo, m_fbmem);
voodoo_device::static_set_tmumem(*m_voodoo, m_tmumem0, m_tmumem1);
switch (m_type) {
//void set_ids(uint32_t main_id, uint8_t revision, uint32_t pclass, uint32_t subsystem_id);
case TYPE_VOODOO_1:
set_ids(0x121a0001, 0x02, 0x030000, 0x000000);
break;
case TYPE_VOODOO_2:
set_ids(0x121a0002, 0x02, 0x038000, 0x000000);
break;
case TYPE_VOODOO_BANSHEE:
set_ids(0x121a0003, 0x02, 0x030000, 0x000000);
break;
//case TYPE_VOODOO_3
default:
set_ids(0x121a0005, 0x02, 0x030000, 0x000000);
break;
}
pci_device::device_start();
if (m_type<=TYPE_VOODOO_2) {
add_map(16*1024*1024, M_MEM | M_PREF, FUNC(voodoo_pci_device::voodoo_reg_map));
bank_infos[0].adr = 0xff000000;
} else {
add_map(32*1024*1024, M_MEM, FUNC(voodoo_pci_device::banshee_reg_map));
add_map(32*1024*1024, M_MEM, FUNC(voodoo_pci_device::lfb_map));
add_map(256, M_IO, FUNC(voodoo_pci_device::io_map));
bank_infos[0].adr = 0xf8000000;
bank_infos[1].adr = 0xf8000008;
bank_infos[2].adr = 0xfffffff0;
}
save_item(NAME(m_pcictrl_reg));
}
/*----------------------------------------------------------------------
* Try inserting every available character into a gap and see
* which of them make words.
*----------------------------------------------------------------------*/
static Map try_gap(char *word, int len, /* word containing a hole */
int pos, /* position of hole */
Map available) /* which letters the player has */
{
int c;
Map map;
map = empty_map;
for (c='A'; c<='Z'; c++) {
if (in_map(available, c)) { /* only try those available */
word[pos] = c;
if (Dict_isword(dict, word, len)) {
add_map(map, c); /* record word possible */
}
}
}
return map;
}
/**************************************************
*
* FUNCTION:
* update_symbol_table - "Update Symbol Table"
*
* DESCRIPTION:
* Adds an entry to the symbol table.
*
* RETURNS:
* Returns an error code
*
* ERRORS:
* * Returns SYM_NO_ERROR if there were
* no errors.
* * Returns SYM_UPDATE_ERROR if the
* table couldn't be updated.
*
**************************************************/
sym_table_error_t8 update_symbol_table
(
char *str, /* string to add */
struct token_type *data /* token corresponding to string */
)
{
/*---------------------------------
Local variables
---------------------------------*/
map_error_code_t8 error;
error = add_map( __id_table, str, data, sizeof( *data ) );
if( ERR_NO_ERROR != error )
{
return( SYM_UPDATE_ERROR );
}
return( SYM_NO_ERROR );
} /* update_symbol_table() */
ADDRESS_MAP_END
void sata_device::device_start()
{
pci_device::device_start();
add_map(8, M_IO, FUNC(sata_device::primary_command_map));
add_map(4, M_IO, FUNC(sata_device::primary_control_map));
add_map(8, M_IO, FUNC(sata_device::secondary_command_map));
add_map(4, M_IO, FUNC(sata_device::secondary_control_map));
add_map(16, M_IO, FUNC(sata_device::bus_master_map));
add_map(1024, M_MEM, FUNC(sata_device::ide_command_posting_map));
}
void i82875p_host_device::device_start()
{
pci_host_device::device_start();
cpu = machine().device<cpu_device>(cpu_tag);
memory_space = &cpu->space(AS_PROGRAM);
io_space = &cpu->space(AS_IO);
memory_window_start = 0;
memory_window_end = 0xffffffff;
memory_offset = 0;
io_window_start = 0;
io_window_end = 0xffff;
io_offset = 0;
status = 0x0010;
ram.resize(ram_size/4);
// Resizeable with the apsize register
add_map(256*1024*1024, M_MEM, FUNC(i82875p_host_device::agp_translation_map));
}
void usb_ehci_device::device_start()
{
pci_device::device_start();
add_map(1024, M_MEM, FUNC(usb_ehci_device::map));
}
void usb_uhci_device::device_start()
{
pci_device::device_start();
add_map(32, M_IO, FUNC(usb_uhci_device::map));
}
static error_t parse_arg( int key, char * arg, struct argp_state *state ) {
struct opdis_options * opts = state->input;
switch ( key ) {
case 'c':
if (! add_job( opts->jobs, job_cflow, arg ) ) {
argp_error( state, "Invalid argument for -c" );
}
break;
case 'l':
if (! add_job( opts->jobs, job_linear, arg ) ) {
argp_error( state, "Invalid argument for -l" );
}
break;
case 'a':
if (! set_arch( opts, arg ) ) {
argp_error( state, "Invalid argument for -s" );
}
break;
case 's':
if (! set_syntax( opts, arg ) ) {
argp_error( state, "Invalid argument for -s" );
}
break;
case 'f':
if (! set_format( opts, arg ) ) {
argp_error( state, "Invalid argument for -f" );
}
break;
case 'o':
if (! set_output_file( opts, arg ) ) {
argp_error( state, "Invalid argument for -o" );
}
break;
case 'b':
if (! tgt_list_add( opts->targets, tgt_bytes, arg ) ) {
argp_error( state, "Invalid argument for -b" );
}
break;
case 'm':
if (! add_map( opts->map, arg ) ) {
argp_error( state, "Invalid argument for -m" );
}
break;
case 'O':
opts->disasm_opts = arg;
break;
case 'B':
if (! set_bfd_target( opts, arg ) ) {
argp_error( state, "Invalid argument for -B" );
}
break;
case 'E':
add_bfd_job( opts, job_bfd_entry, NULL );
break;
case 'N':
if (! add_bfd_job( opts, job_bfd_symbol, arg ) ) {
argp_error( state, "Invalid argument for -N" );
}
break;
case 'S':
if (! add_bfd_job( opts, job_bfd_section, arg ) ) {
argp_error( state, "Invalid argument for -N" );
}
break;
case 'q': opts->quiet = 1; break;
case 1: opts->list_arch = 1; break;
case 2: opts->list_disasm_opt = 1; break;
case 3: opts->list_syntax = 1; break;
case 4: opts->list_format = 1; break;
case 5: opts->dry_run = 1; break;
case ARGP_KEY_ARG:
tgt_list_add( opts->targets, tgt_file, arg );
break;
default:
return ARGP_ERR_UNKNOWN;
}
return 0;
}
void sb0400_device::device_start()
{
pci_device::device_start();
add_map(64, M_IO, FUNC(sb0400_device::map));
}
