MESS SVN History

15994 Revisions

r14947 Tuesday 17th April, 2012 at 07:39:04 UTC by Miodrag Milanović
AM_BASE -> AM_SHARE (no whatsnew)

[src/mess/drivers]	abc80x.c ace.c apricotf.c aquarius.c atom.c bk.c bw12.c c128.c c65.c cbmb.c cgc7900.c compis.c concept.c dgn_beta.c fm7.c galeb.c gamecom.c gba.c gp32.c hec2hrp.c huebler.c intv.c jtc.c jupiter.c kaypro.c lisa.c llc.c lynx.c mac.c mc1000.c mc80.c micronic.c microtan.c mikro80.c mpz80.c mz80.c nascom1.c orao.c osi.c p2000t.c pet.c phc25.c pokemini.c poly88.c portfoli.c psion.c px8.c sapi1.c special.c spectrum.c studio2.c svision.c sym1.c tandy2k.c tdv2324.c tmc2000e.c trs80.c ut88.c v1050.c victor9k.c vixen.c x68k.c xerox820.c z80ne.c
[src/mess/includes]	abc80x.h ace.h apricotf.h aquarius.h atom.h bk.h bw12.h cbmb.h cgc7900.h cgenie.h compis.h concept.h dgn_beta.h fm7.h galeb.h gamecom.h gba.h gp32.h hec2hrp.h huebler.h intv.h jtc.h kaypro.h lisa.h llc.h lynx.h mac.h mc1000.h mc80.h micronic.h microtan.h mikro80.h mpz80.h mz80.h nascom1.h orao.h oric.h osi.h p2000t.h pce.h pet.h phc25.h pokemini.h poly88.h portfoli.h psion.h px8.h sapi1.h special.h spectrum.h svision.h sym1.h tandy2k.h tdv2324.h tmc2000e.h trs80.h ut88.h v1050.h victor9k.h vixen.h x68k.h xerox820.h z80ne.h
[src/mess/machine]	dgn_beta.c llc.c lynx.c pet.c
[src/mess/video]	abc806.c cgc7900.c gba.c gbam345.c gbamode0.c gbamode1.c gbamode2.c mac.c mc80.c

src/mess/machine/dgn_beta.c
r14946	r14947
1098	1098	wd17xx_dden_w(fdc, CLEAR_LINE);
1099	1099	wd17xx_set_drive(fdc, 0);
1100	1100
1101		state->m_videoram = machine.device<ram_device>(RAM_TAG)->pointer(); /* Point video ram at the start of physical ram */
	1101	state->m_videoram.set_target(machine.device<ram_device>(RAM_TAG)->pointer(),state->m_videoram.bytes()); /* Point video ram at the start of physical ram */
1102	1102
1103	1103	wd17xx_reset(fdc);
1104	1104	state->m_wd2797_written=0;

src/mess/machine/pet.c
r14946	r14947
682	682	DRIVER_INIT( pet2001 )
683	683	{
684	684	pet_state *state = machine.driver_data<pet_state>();
685		state->m_memory = machine.device<ram_device>(RAM_TAG)->pointer();
	685	state->m_memory.set_target(machine.device<ram_device>(RAM_TAG)->pointer(),state->m_memory.bytes());
686	686	pet_common_driver_init(machine);
687	687	state->m_pet_basic1 = 1;
688	688	pet_vh_init(machine);
r14946	r14947
691	691	DRIVER_INIT( pet )
692	692	{
693	693	pet_state *state = machine.driver_data<pet_state>();
694		state->m_memory = machine.device<ram_device>(RAM_TAG)->pointer();
	694	state->m_memory.set_target(machine.device<ram_device>(RAM_TAG)->pointer(),state->m_memory.bytes());
695	695	pet_common_driver_init(machine);
696	696	pet_vh_init(machine);
697	697	}
r14946	r14947
699	699	DRIVER_INIT( pet80 )
700	700	{
701	701	pet_state *state = machine.driver_data<pet_state>();
702		state->m_memory = machine.region("maincpu")->base();
	702	state->m_memory.set_target(machine.region("maincpu")->base(),state->m_memory.bytes());
703	703
704	704	pet_common_driver_init(machine);
705	705	state->m_cbm8096 = 1;
706		state->m_videoram = &state->m_memory[0x8000];
	706	state->m_videoram.set_target(&state->m_memory[0x8000],state->m_videoram.bytes());
707	707	pet80_vh_init(machine);
708	708
709	709	}
r14946	r14947
711	711	DRIVER_INIT( superpet )
712	712	{
713	713	pet_state *state = machine.driver_data<pet_state>();
714		state->m_memory = machine.device<ram_device>(RAM_TAG)->pointer();
	714	state->m_memory.set_target(machine.device<ram_device>(RAM_TAG)->pointer(),state->m_memory.bytes());
715	715	pet_common_driver_init(machine);
716	716	state->m_superpet = 1;
717	717

src/mess/machine/llc.c
r14946	r14947
107	107	DRIVER_INIT(llc2)
108	108	{
109	109	llc_state *state = machine.driver_data<llc_state>();
110		state->m_video_ram = machine.device<ram_device>(RAM_TAG)->pointer() + 0xc000;
	110	state->m_video_ram.set_target( machine.device<ram_device>(RAM_TAG)->pointer() + 0xc000,state->m_video_ram.bytes());
111	111	}
112	112
113	113	MACHINE_RESET( llc2 )

src/mess/machine/lynx.c
r14946	r14947
1976	1976
1977	1977	int i;
1978	1978	state->save_item(NAME(state->m_memory_config));
1979		state->save_pointer(NAME(state->m_mem_fe00), state->m_mem_fe00~~_siz~~e);
	1979	state->save_pointer(NAME(state->m_mem_fe00.target()), state->m_mem_fe00.bytes());
1980	1980	machine.save().register_postload(save_prepost_delegate(FUNC(lynx_postload), state));
1981	1981
1982	1982	memory_configure_bank(machine, "bank3", 0, 1, machine.region("maincpu")->base() + 0x0000, 0);

src/mess/includes/gba.h
r14946	r14947
137	137	{
138	138	public:
139	139	gba_state(const machine_config &mconfig, device_type type, const char *tag)
140		: driver_device(mconfig, type, tag) { }
141
	140	: driver_device(mconfig, type, tag),
	141	m_gba_pram(*this, "gba_pram"),
	142	m_gba_vram(*this, "gba_vram"),
	143	m_gba_oam(*this, "gba_oam") { }
	144
	145	required_shared_ptr<UINT32> m_gba_pram;
	146	required_shared_ptr<UINT32> m_gba_vram;
	147	required_shared_ptr<UINT32> m_gba_oam;
	148
142	149	virtual void video_start();
143	150
144	151	UINT32 screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
r14946	r14947
180	187	INT32 m_gfxBG3X;
181	188	INT32 m_gfxBG3Y;
182	189
183		UINT32 *m_gba_pram;
184		UINT32 *m_gba_vram;
185		UINT32 *m_gba_oam;
186	190
	191
187	192	UINT32 m_dma_regs[16];
188	193	UINT32 m_dma_src[4], m_dma_dst[4], m_dma_cnt[4], m_dma_srcadd[4], m_dma_dstadd[4];
189	194	UINT32 m_timer_regs[4];

src/mess/includes/fm7.h
r14946	r14947
102	102	{
103	103	public:
104	104	fm7_state(const machine_config &mconfig, device_type type, const char *tag)
105		: driver_device(mconfig, type, tag) { }
	105	: driver_device(mconfig, type, tag) ,
	106	m_shared_ram(*this, "shared_ram"),
	107	m_boot_ram(*this, "boot_ram"){ }
106	108
107		UINT8* m_boot_ram;
	109	required_shared_ptr<UINT8> m_shared_ram;
	110	required_shared_ptr<UINT8> m_boot_ram;
	111
108	112	UINT8 m_irq_flags;
109	113	UINT8 m_irq_mask;
110	114	emu_timer* m_timer;
r14946	r14947
132	136	fm7_mmr_t m_mmr;
133	137	UINT8 m_cp_prev;
134	138	UINT8* m_video_ram;
135		UINT8* m_shared_ram;
136	139	emu_timer* m_fm77av_vsync_timer;
137	140	UINT8 m_type;
138	141	fm7_video_t m_video;

src/mess/includes/vixen.h
r14946	r14947
33	33	m_atn(1),
34	34	m_rxrdy(0),
35	35	m_txrdy(0)
36		{ }
	36	,
	37	m_video_ram(*this, "video_ram"){ }
37	38
38	39	required_device<cpu_device> m_maincpu;
39	40	required_device<device_t> m_fdc;
r14946	r14947
98	99	// video state
99	100	int m_alt;
100	101	int m_256;
101		UINT8 *m_video_ram;
	102	required_shared_ptr<UINT8> m_video_ram;
102	103	const UINT8 *m_sync_rom;
103	104	const UINT8 *m_char_rom;
104	105	};

src/mess/includes/compis.h
r14946	r14947
139	139	m_uart(*this, "uart"),
140	140	m_rtc(*this, "mm58274c"),
141	141	m_fdc(*this, "upd765"),
142		m_crtc(*this, "upd7220")
143		{ }
	142	m_crtc(*this, "upd7220"),
	143	m_video_ram(*this, "video_ram") { }
144	144
145	145	required_device<cpu_device> m_maincpu;
146	146	required_device<device_t> m_8253;
r14946	r14947
180	180	void handle_eoi(int data);
181	181	void compis_fdc_tc(int state);
182	182
183		UINT8 *m_video_ram;
	183	required_shared_ptr<UINT8> m_video_ram;
184	184	};
185	185
186	186

src/mess/includes/dgn_beta.h
r14946	r14947
86	86	public:
87	87	dgn_beta_state(const machine_config &mconfig, device_type type, const char *tag)
88	88	: driver_device(mconfig, type, tag),
89		m_mc6845(*this, "crtc")
90		{ }
	89	m_mc6845(*this, "crtc"),
	90	m_videoram(*this, "videoram"){ }
91	91
92		UINT8 *m_videoram;
	92	required_device<mc6845_device> m_mc6845;
	93	required_shared_ptr<UINT8> m_videoram;
	94
93	95	UINT8 *m_system_rom;
94	96	int m_LogDatWrites;
95	97	int m_Keyboard[NoKeyrows];
r14946	r14947
140	142	int m_ColourRAM[4];
141	143	int m_Field;
142	144	int m_DrawInterlace;
143
144		required_device<mc6845_device> m_mc6845;
145	145	};
146	146
147	147

src/mess/includes/z80ne.h
r14946	r14947
64	64	public:
65	65	z80ne_state(const machine_config &mconfig, device_type type, const char *tag)
66	66	: driver_device(mconfig, type, tag),
67		m_vdg(*this, "mc6847")
68		{}
	67	m_vdg(*this, "mc6847"),
	68	m_videoram(*this,"videoram") {}
69	69
70	70	optional_device<mc6847_base_device> m_vdg;
71		UINT8 *m_videoram;
	71	required_shared_ptr<UINT8> m_videoram;
72	72	UINT8 m_lx383_scan_counter;
73	73	UINT8 m_lx383_key[LX383_KEYS];
74	74	int m_lx383_downsampler;

src/mess/includes/mc1000.h
r14946	r14947
32	32	m_centronics(*this, CENTRONICS_TAG),
33	33	m_cassette(*this, CASSETTE_TAG),
34	34	m_ram(*this, RAM_TAG)
35		{ }
	35	,
	36	m_mc6845_video_ram(*this, "mc6845_video_ram"),
	37	m_mc6847_video_ram(*this, "mc6847_video_ram"){ }
36	38
37	39	required_device<cpu_device> m_maincpu;
38	40	required_device<mc6847_base_device> m_vdg;
r14946	r14947
72	74	/* video state */
73	75	int m_hsync;
74	76	int m_vsync;
75		UINT8 *m_mc6845_video_ram;
76		UINT8 *m_mc6847_video_ram;
	77	required_shared_ptr<UINT8> m_mc6845_video_ram;
	78	required_shared_ptr<UINT8> m_mc6847_video_ram;
77	79	UINT8 m_mc6847_attr;
78	80	};
79	81

src/mess/includes/mac.h
r14946	r14947
229	229	m_screen(*this, MAC_SCREEN_NAME),
230	230	m_539x_1(*this, MAC_539X_1_TAG),
231	231	m_539x_2(*this, MAC_539X_2_TAG),
232		m_mackbd(*this, MACKBD_TAG)
	232	m_mackbd(*this, MACKBD_TAG),
	233	m_vram(*this,"vram")
233	234	{ }
234	235
235	236	required_device<cpu_device> m_maincpu;
r14946	r14947
340	341	UINT32 m_dafb_base, m_dafb_stride;
341	342
342	343	// this is shared among all video setups with vram
343		UINT32 *m_vram;
	344	required_shared_ptr<UINT32> m_vram;
344	345
345	346	// interrupts
346	347	int m_scc_interrupt, m_via_interrupt, m_via2_interrupt, m_scsi_interrupt, m_asc_interrupt, m_last_taken_interrupt;

src/mess/includes/cbmb.h
r14946	r14947
21	21	public:
22	22	cbmb_state(const machine_config &mconfig, device_type type, const char *tag)
23	23	: driver_device(mconfig, type, tag),
24		m_ieee(*this, IEEE488_TAG)
25		{ }
	24	m_ieee(*this, IEEE488_TAG),
	25	m_basic(*this, "basic"),
	26	m_videoram(*this, "videoram"),
	27	m_kernal(*this, "kernal"),
	28	m_colorram(*this, "colorram"){ }
26	29
27	30	required_device<ieee488_device> m_ieee;
	31	required_shared_ptr<UINT8> m_basic;
	32	required_shared_ptr<UINT8> m_videoram;
	33	required_shared_ptr<UINT8> m_kernal;
	34	required_shared_ptr<UINT8> m_colorram;
28	35
29	36	DECLARE_READ8_MEMBER( vic_lightpen_x_cb );
30	37	DECLARE_READ8_MEMBER( vic_lightpen_y_cb );
r14946	r14947
41	48	int m_p500;
42	49	int m_cbm700;
43	50	int m_cbm_ntsc;
44		UINT8 *m_videoram;
45		UINT8 *m_basic;
46		UINT8 *m_kernal;
47		UINT8 *m_colorram;
48	51	int m_keyline_a;
49	52	int m_keyline_b;
50	53	int m_keyline_c;

src/mess/includes/mc80.h
r14946	r14947
17	17	{
18	18	public:
19	19	mc80_state(const machine_config &mconfig, device_type type, const char *tag)
20		: driver_device(mconfig, type, tag) { }
	20	: driver_device(mconfig, type, tag) ,
	21	m_p_videoram(*this, "p_videoram"){ }
21	22
22	23	DECLARE_WRITE8_MEMBER(mc8030_zve_write_protect_w);
23	24	DECLARE_WRITE8_MEMBER(mc8030_vis_w);
r14946	r14947
36	37	DECLARE_READ8_MEMBER(asp_port_b_r);
37	38	DECLARE_WRITE8_MEMBER(asp_port_a_w);
38	39	DECLARE_WRITE8_MEMBER(asp_port_b_w);
39		UINT8 *m_p_videoram;
	40	required_shared_ptr<UINT8> m_p_videoram;
40	41	};
41	42
42	43

src/mess/includes/bw12.h
r14946	r14947
33	33	m_floppy0(*this, FLOPPY_0),
34	34	m_floppy1(*this, FLOPPY_1),
35	35	m_floppy_timer(*this, FLOPPY_TIMER_TAG)
36		{ }
	36	,
	37	m_video_ram(*this, "video_ram"){ }
37	38
38	39	required_device<cpu_device> m_maincpu;
39	40	required_device<pia6821_device> m_pia;
r14946	r14947
71	72	int m_bank;
72	73
73	74	/* video state */
74		UINT8 *m_video_ram;
	75	required_shared_ptr<UINT8> m_video_ram;
75	76	UINT8 *m_char_rom;
76	77
77	78	/* PIT state */

src/mess/includes/pokemini.h
r14946	r14947
51	51	pokemini_state(const machine_config &mconfig, device_type type, const char *tag)
52	52	: driver_device(mconfig, type, tag),
53	53	m_maincpu(*this, "maincpu")
54		{ }
	54	,
	55	m_p_ram(*this, "p_ram"){ }
55	56
56	57	required_device<cpu_device> m_maincpu;
57		UINT8 *m_p_ram;
	58	required_shared_ptr<UINT8> m_p_ram;
58	59	UINT8 m_pm_reg[0x100];
59	60	PRC m_prc;
60	61	TIMERS m_timers;

src/mess/includes/concept.h
r14946	r14947
34	34	{
35	35	public:
36	36	concept_state(const machine_config &mconfig, device_type type, const char *tag)
37		: driver_device(mconfig, type, tag) { }
	37	: driver_device(mconfig, type, tag),
	38	m_videoram(*this,"videoram") { }
38	39
39		UINT16 *m_videoram;
	40	required_shared_ptr<UINT16> m_videoram;
40	41	UINT8 m_pending_interrupts;
41	42	char m_clock_enable;
42	43	char m_clock_address;

src/mess/includes/gamecom.h
r14946	r14947
210	210	public:
211	211	gamecom_state(const machine_config &mconfig, device_type type, const char *tag)
212	212	: driver_device(mconfig, type, tag),
213		m_maincpu(*this, "maincpu")
214		{ }
	213	m_maincpu(*this, "maincpu"),
	214	m_p_nvram(*this,"p_nvram"),
	215	m_p_videoram(*this,"p_videoram") { }
215	216
216	217	required_device<cpu_device> m_maincpu;
217	218	DECLARE_READ8_MEMBER( gamecom_internal_r );
218	219	DECLARE_READ8_MEMBER( gamecom_pio_r );
219	220	DECLARE_WRITE8_MEMBER( gamecom_internal_w );
220	221	DECLARE_WRITE8_MEMBER( gamecom_pio_w );
221		UINT8 *m_p_nvram;
	222	required_shared_ptr<UINT8> m_p_nvram;
222	223	UINT8 *m_p_ram;
223		UINT8 *m_p_videoram;
	224	required_shared_ptr<UINT8> m_p_videoram;
224	225	UINT8 *m_cartridge1;
225	226	UINT8 *m_cartridge2;
226	227	UINT8 *m_cartridge;

src/mess/includes/ace.h
r14946	r14947
28	28	m_cassette(*this, CASSETTE_TAG),
29	29	m_centronics(*this, CENTRONICS_TAG),
30	30	m_ram(*this, RAM_TAG)
31		{ }
	31	,
	32	m_video_ram(*this, "video_ram"),
	33	m_char_ram(*this, "char_ram"){ }
32	34
33	35	required_device<cpu_device> m_maincpu;
34	36	required_device<i8255_device> m_ppi;
r14946	r14947
54	56	DECLARE_READ8_MEMBER( pio_pa_r );
55	57	DECLARE_WRITE8_MEMBER( pio_pa_w );
56	58
57		UINT8 *m_video_ram;
58		UINT8 *m_char_ram;
	59	required_shared_ptr<UINT8> m_video_ram;
	60	required_shared_ptr<UINT8> m_char_ram;
59	61	};
60	62
61	63	#endif /* ACE_H_ */

src/mess/includes/lisa.h
r14946	r14947
92	92	{
93	93	public:
94	94	lisa_state(const machine_config &mconfig, device_type type, const char *tag)
95		: driver_device(mconfig, type, tag) { }
	95	: driver_device(mconfig, type, tag),
	96	m_fdc_rom(*this,"fdc_rom"),
	97	m_fdc_ram(*this,"fdc_ram") { }
96	98
97		UINT8 *m_fdc_rom;
98		UINT8 *m_fdc_ram;
	99	required_shared_ptr<UINT8> m_fdc_rom;
	100	required_shared_ptr<UINT8> m_fdc_ram;
99	101	UINT8 *m_ram_ptr;
100	102	UINT8 *m_rom_ptr;
101	103	UINT8 *m_videoROM_ptr;

src/mess/includes/sym1.h
r14946	r14947
24	24	{
25	25	public:
26	26	sym1_state(const machine_config &mconfig, device_type type, const char *tag)
27		: driver_device(mconfig, type, tag) { }
	27	: driver_device(mconfig, type, tag) ,
	28	m_ram_1k(*this, "ram_1k"),
	29	m_ram_2k(*this, "ram_2k"),
	30	m_ram_3k(*this, "ram_3k"),
	31	m_monitor(*this, "monitor"),
	32	m_riot_ram(*this, "riot_ram"){ }
28	33
29		UINT8 *m_ram_1k;
30		UINT8 *m_ram_2k;
31		UINT8 *m_ram_3k;
32		UINT8 *m_riot_ram;
33		UINT8 *m_monitor;
	34	required_shared_ptr<UINT8> m_ram_1k;
	35	required_shared_ptr<UINT8> m_ram_2k;
	36	required_shared_ptr<UINT8> m_ram_3k;
	37	required_shared_ptr<UINT8> m_monitor;
	38	required_shared_ptr<UINT8> m_riot_ram;
34	39	UINT8 m_riot_port_a;
35	40	UINT8 m_riot_port_b;
36	41	emu_timer *m_led_update;

src/mess/includes/cgenie.h
r14946	r14947
38	38	{
39	39	public:
40	40	cgenie_state(const machine_config &mconfig, device_type type, const char *tag)
41		: driver_device(mconfig, type, tag) { }
	41	: driver_device(mconfig, type, tag) ,
	42	m_colorram(*this, "colorram"),
	43	m_fontram(*this, "fontram"){ }
42	44
	45	required_shared_ptr<UINT8> m_colorram;
	46	required_shared_ptr<UINT8> m_fontram;
	47
43	48	UINT8 *m_videoram;
44		UINT8 *m_fontram;
45		UINT8 *m_colorram;
46	49	int m_tv_mode;
47	50	int m_font_offset[4];
48	51	int m_port_ff;

src/mess/includes/aquarius.h
r14946	r14947
11	11	{
12	12	public:
13	13	aquarius_state(const machine_config &mconfig, device_type type, const char *tag)
14		: driver_device(mconfig, type, tag) { }
	14	: driver_device(mconfig, type, tag) ,
	15	m_videoram(*this, "videoram"),
	16	m_colorram(*this, "colorram"){ }
15	17
16		UINT8 *m_videoram;
	18	required_shared_ptr<UINT8> m_videoram;
17	19	UINT8 m_scrambler;
18		UINT8 *m_colorram;
	20	required_shared_ptr<UINT8> m_colorram;
19	21	tilemap_t *m_tilemap;
20	22	};
21	23

src/mess/includes/lynx.h
r14946	r14947
96	96	{
97	97	public:
98	98	lynx_state(const machine_config &mconfig, device_type type, const char *tag)
99		: driver_device(mconfig, type, tag) { }
	99	: driver_device(mconfig, type, tag) ,
	100	m_mem_0000(*this, "mem_0000"),
	101	m_mem_fc00(*this, "mem_fc00"),
	102	m_mem_fd00(*this, "mem_fd00"),
	103	m_mem_fe00(*this, "m_mem_fe00"),
	104	m_mem_fffa(*this, "mem_fffa"){ }
100	105
101	106	virtual void video_start();
102	107
103	108	UINT32 screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
104	109
105		UINT8 *m_mem_0000;
106		UINT8 *m_mem_fc00;
107		UINT8 *m_mem_fd00;
108		UINT8 *m_mem_fe00;
109		UINT8 *m_mem_fffa;
110		size_t m_mem_fe00_size;
	110	required_shared_ptr<UINT8> m_mem_0000;
	111	required_shared_ptr<UINT8> m_mem_fc00;
	112	required_shared_ptr<UINT8> m_mem_fd00;
	113	required_shared_ptr<UINT8> m_mem_fe00;
	114	required_shared_ptr<UINT8> m_mem_fffa;
	115	//OBRISI.ME
111	116	UINT16 m_granularity;
112	117	int m_sign_AB;
113	118	int m_sign_CD;

src/mess/includes/x68k.h
r14946	r14947
44	44	x68k_base_state(const machine_config &mconfig, device_type type, const char *tag)
45	45	: driver_device(mconfig, type, tag),
46	46	m_mfpdev(*this, MC68901_TAG),
47		m_rtc(*this, RP5C15_TAG)
48		{ }
	47	m_rtc(*this, RP5C15_TAG),
	48	m_gvram(*this, "gvram"),
	49	m_tvram(*this, "tvram") { }
49	50
50	51	required_device<mc68901_device> m_mfpdev;
51	52	required_device<rp5c15_device> m_rtc;
r14946	r14947
226	227	emu_timer* m_scanline_timer;
227	228	emu_timer* m_raster_irq;
228	229	emu_timer* m_vblank_irq;
229		UINT16* m_gvram;
230		UINT16* m_tvram;
	230	required_shared_ptr<UINT16> m_gvram;
	231	required_shared_ptr<UINT16> m_tvram;
231	232	UINT16* m_spriteram;
232	233	UINT16* m_spritereg;
233	234	tilemap_t* m_bg0_8;

src/mess/includes/spectrum.h
r14946	r14947
66	66	{
67	67	public:
68	68	spectrum_state(const machine_config &mconfig, device_type type, const char *tag)
69		: driver_device(mconfig, type, tag) { }
	69	: driver_device(mconfig, type, tag) ,
	70	m_video_ram(*this, "video_ram"){ }
70	71
71	72	int m_port_fe_data;
72	73	int m_port_7ffd_data;
r14946	r14947
81	82	int m_frame_number; /* Used for handling FLASH 1 */
82	83	int m_flash_invert;
83	84	UINT8 m_retrace_cycles;
84		UINT8 *m_video_ram;
	85	required_shared_ptr<UINT8> m_video_ram;
85	86	UINT8 *m_screen_location;
86	87
87	88	int m_ROMSelection;

src/mess/includes/kaypro.h
r14946	r14947
26	26	m_fdc(*this, "wd1793"),
27	27	m_crtc(*this, "crtc"),
28	28	m_beep(*this, BEEPER_TAG)
29		{ }
	29	,
	30	m_p_videoram(*this, "p_videoram"){ }
30	31
31	32	required_device<cpu_device> m_maincpu;
32	33	optional_device<device_t> m_pio_g;
r14946	r14947
57	58	DECLARE_READ8_MEMBER(kaypro_videoram_r);
58	59	DECLARE_WRITE8_MEMBER(kaypro_videoram_w);
59	60	const UINT8 *m_p_chargen;
60		UINT8 *m_p_videoram;
	61	required_shared_ptr<UINT8> m_p_videoram;
61	62	UINT8 m_system_port;
62	63	UINT8 m_mc6845_cursor[16];
63	64	UINT8 m_mc6845_reg[32];

src/mess/includes/victor9k.h
r14946	r14947
55	55	m_floppy0(*this, FLOPPY_0),
56	56	m_floppy1(*this, FLOPPY_1),
57	57	m_kb(*this, VICTOR9K_KEYBOARD_TAG)
58		{ }
	58	,
	59	m_video_ram(*this, "video_ram"){ }
59	60
60	61	required_device<cpu_device> m_maincpu;
61	62	required_device<cpu_device> m_fdc_cpu;
r14946	r14947
105	106	DECLARE_WRITE_LINE_MEMBER( kbrdy_w );
106	107
107	108	/* video state */
108		UINT8 *m_video_ram;
	109	required_shared_ptr<UINT8> m_video_ram;
109	110	int m_brt;
110	111	int m_cont;
111	112

src/mess/includes/px8.h
r14946	r14947
32	32	m_maincpu(*this, UPD70008_TAG),
33	33	m_cassette(*this, CASSETTE_TAG),
34	34	m_ram(*this, RAM_TAG)
35		{ }
	35	,
	36	m_video_ram(*this, "video_ram"){ }
36	37
37	38	required_device<cpu_device> m_maincpu;
38	39	required_device<cassette_image_device> m_cassette;
39	40	required_device<ram_device> m_ram;
	41	/* video state */
	42	required_shared_ptr<UINT8> m_video_ram; /* LCD video RAM */
40	43
41	44	virtual void machine_start();
42	45	virtual void machine_reset();
r14946	r14947
74	77
75	78	/* keyboard state */
76	79	int m_ksc; /* keyboard scan column */
77
78		/* video state */
79		UINT8 m_video_ram; / LCD video RAM */
80	80	};
81	81
82	82	#endif

src/mess/includes/phc25.h
r14946	r14947
29	29	m_vdg(*this, MC6847_TAG),
30	30	m_centronics(*this, CENTRONICS_TAG),
31	31	m_cassette(*this, CASSETTE_TAG)
32		{ }
	32	,
	33	m_video_ram(*this, "video_ram"){ }
33	34
34	35	required_device<cpu_device> m_maincpu;
35	36	required_device<mc6847_base_device> m_vdg;
r14946	r14947
46	47	static UINT8 pal_char_rom_r(running_machine &machine, UINT8 ch, int line);
47	48
48	49	/* video state */
49		UINT8 *m_video_ram;
	50	required_shared_ptr<UINT8> m_video_ram;
50	51	UINT8 *m_char_rom;
51	52	};
52	53

src/mess/includes/p2000t.h
r14946	r14947
20	20	: driver_device(mconfig, type, tag),
21	21	m_maincpu(*this, "maincpu"),
22	22	m_speaker(*this, SPEAKER_TAG)
23		{ }
	23	,
	24	m_p_videoram(*this, "p_videoram"){ }
24	25
25	26	required_device<cpu_device> m_maincpu;
26	27	required_device<device_t> m_speaker;
r14946	r14947
33	34	DECLARE_WRITE8_MEMBER(p2000t_port_888b_w);
34	35	DECLARE_WRITE8_MEMBER(p2000t_port_8c90_w);
35	36	DECLARE_WRITE8_MEMBER(p2000t_port_9494_w);
36		UINT8 *m_p_videoram;
	37	required_shared_ptr<UINT8> m_p_videoram;
37	38	UINT8 m_port_101f;
38	39	UINT8 m_port_202f;
39	40	UINT8 m_port_303f;

src/mess/includes/pet.h
r14946	r14947
26	26	pet_state(const machine_config &mconfig, device_type type, const char *tag)
27	27	: driver_device(mconfig, type, tag),
28	28	m_ieee(*this, IEEE488_TAG)
29		{ }
	29	,
	30	m_videoram(*this, "videoram"),
	31	m_memory(*this, "memory"){ }
30	32
31	33	required_device<ieee488_device> m_ieee;
32	34
r14946	r14947
37	39	int m_pia0_irq;
38	40	int m_pia1_irq;
39	41	int m_via_irq;
40		UINT8 *m_videoram;
	42	required_shared_ptr<UINT8> m_videoram;
41	43	int m_font;
42		UINT8 *m_memory;
	44	required_shared_ptr<UINT8> m_memory;
43	45	UINT8 *m_supermemory;
44	46	UINT8 *m_pet80_bank1_base;
45	47	int m_keyline_select;

src/mess/includes/osi.h
r14946	r14947
34	34	m_cassette(*this, CASSETTE_TAG),
35	35	m_discrete(*this, DISCRETE_TAG),
36	36	m_ram(*this, RAM_TAG)
37		{ }
	37	,
	38	m_video_ram(*this, "video_ram"),
	39	m_color_ram(*this, "color_ram"){ }
38	40
39	41	required_device<cpu_device> m_maincpu;
40	42	required_device<cassette_image_device> m_cassette;
r14946	r14947
58	60	/* video state */
59	61	int m_32;
60	62	int m_coloren;
61		UINT8 *m_video_ram;
62		UINT8 *m_color_ram;
	63	required_shared_ptr<UINT8> m_video_ram;
	64	required_shared_ptr<UINT8> m_color_ram;
63	65
64	66	/* floppy state */
65	67	int m_fdc_index;

src/mess/includes/oric.h
r14946	r14947
58	58	{
59	59	public:
60	60	oric_state(const machine_config &mconfig, device_type type, const char *tag)
61		: driver_device(mconfig, type, tag) { }
	61	: driver_device(mconfig, type, tag),
	62	m_ram(*this, "ram") { }
62	63
63		UINT8 *m_ram;
	64	required_shared_ptr<UINT8> m_ram;
64	65	int m_is_telestrat;
65	66	unsigned char m_irqs;
66	67	char *m_ram_0x0c000;

src/mess/includes/portfoli.h
r14946	r14947
35	35	m_uart(*this, M82C50A_TAG),
36	36	m_speaker(*this, SPEAKER_TAG),
37	37	m_timer_tick(*this, TIMER_TICK_TAG)
38		{ }
	38	,
	39	m_contrast(*this, "contrast"){ }
39	40
40	41	required_device<cpu_device> m_maincpu;
41	42	required_device<hd61830_device> m_lcdc;
r14946	r14947
79	80	UINT8 m_keylatch;
80	81
81	82	/* video state */
82		UINT8 m_contrast;
	83	required_shared_ptr<UINT8> m_contrast;
83	84
84	85	/* peripheral state */
85	86	UINT8 m_pid; /* peripheral identification */

src/mess/includes/atom.h
r14946	r14947
48	48	m_cassette(*this, CASSETTE_TAG),
49	49	m_centronics(*this, CENTRONICS_TAG),
50	50	m_speaker(*this, SPEAKER_TAG)
51		{ }
	51	,
	52	m_video_ram(*this, "video_ram"){ }
52	53
53	54	required_device<cpu_device> m_maincpu;
54	55	required_device<mc6847_base_device> m_vdg;
r14946	r14947
76	77	int m_eprom;
77	78
78	79	/* video state */
79		UINT8 *m_video_ram;
	80	required_shared_ptr<UINT8> m_video_ram;
80	81
81	82	/* keyboard state */
82	83	int m_keylatch;

src/mess/includes/orao.h
r14946	r14947
12	12	{
13	13	public:
14	14	orao_state(const machine_config &mconfig, device_type type, const char *tag)
15		: driver_device(mconfig, type, tag) { }
	15	: driver_device(mconfig, type, tag) ,
	16	m_memory(*this, "memory"),
	17	m_video_ram(*this, "video_ram"){ }
16	18
17		UINT8 *m_memory;
18		UINT8 *m_video_ram;
	19	required_shared_ptr<UINT8> m_memory;
	20	required_shared_ptr<UINT8> m_video_ram;
19	21	};
20	22
21	23

src/mess/includes/galeb.h
r14946	r14947
12	12	{
13	13	public:
14	14	galeb_state(const machine_config &mconfig, device_type type, const char *tag)
15		: driver_device(mconfig, type, tag) { }
	15	: driver_device(mconfig, type, tag) ,
	16	m_video_ram(*this, "video_ram"){ }
16	17
17		UINT8 *m_video_ram;
	18	required_shared_ptr<UINT8> m_video_ram;
18	19	};
19	20
20	21	/----------- defined in video/galeb.c -----------/

src/mess/includes/v1050.h
r14946	r14947
76	76	m_timer_ack(*this, TIMER_ACK_TAG),
77	77	m_timer_rst(*this, TIMER_RST_TAG),
78	78	m_sasibus(*this, SASIBUS_TAG)
79		{ }
	79	,
	80	m_video_ram(*this, "video_ram"){ }
80	81
81	82	required_device<cpu_device> m_maincpu;
82	83	required_device<cpu_device> m_subcpu;
r14946	r14947
154	155	UINT8 m_bank; // bank register
155	156
156	157	// video state
157		UINT8 *m_video_ram; // video RAM
	158	required_shared_ptr<UINT8> m_video_ram; // video RAM
158	159	UINT8 *m_attr_ram; // attribute RAM
159	160	UINT8 m_attr; // attribute latch
160	161	};

src/mess/includes/gp32.h
r14946	r14947
86	86	{
87	87	public:
88	88	gp32_state(const machine_config &mconfig, device_type type, const char *tag)
89		: driver_device(mconfig, type, tag) { }
	89	: driver_device(mconfig, type, tag) ,
	90	m_s3c240x_ram(*this, "s3c240x_ram"){ }
90	91
91	92	virtual void video_start();
92	93
93		UINT32 *m_s3c240x_ram;
	94	required_shared_ptr<UINT32> m_s3c240x_ram;
94	95	UINT8 *m_eeprom_data;
95	96	UINT32 m_s3c240x_lcd_regs[0x400/4];
96	97	emu_timer *m_s3c240x_lcd_timer;

src/mess/includes/cgc7900.h
r14946	r14947
27	27	public:
28	28	cgc7900_state(const machine_config &mconfig, device_type type, const char *tag)
29	29	: driver_device(mconfig, type, tag),
30		m_maincpu(*this, M68000_TAG)
31		{ }
	30	m_maincpu(*this, M68000_TAG),
	31	m_chrom_ram(*this, "chrom_ram"),
	32	m_plane_ram(*this, "plane_ram"),
	33	m_clut_ram(*this, "clut_ram"),
	34	m_overlay_ram(*this, "overlay_ram"),
	35	m_roll_bitmap(*this, "roll_bitmap"),
	36	m_pan_x(*this, "pan_x"),
	37	m_pan_y(*this, "pan_y"),
	38	m_zoom(*this, "zoom"),
	39	m_blink_select(*this, "blink_select"),
	40	m_plane_select(*this, "plane_select"),
	41	m_plane_switch(*this, "plane_switch"),
	42	m_color_status_fg(*this, "color_status_fg"),
	43	m_color_status_bg(*this, "color_status_bg"),
	44	m_roll_overlay(*this, "roll_overlay"){ }
32	45
33	46	required_device<cpu_device> m_maincpu;
34	47
r14946	r14947
58	71	UINT16 m_int_mask;
59	72
60	73	/* video state */
61		UINT16 *m_plane_ram;
62		UINT16 *m_clut_ram;
63		UINT16 *m_overlay_ram;
	74	required_shared_ptr<UINT16> m_chrom_ram;
	75	required_shared_ptr<UINT16> m_plane_ram;
	76	required_shared_ptr<UINT16> m_clut_ram;
	77	required_shared_ptr<UINT16> m_overlay_ram;
64	78	UINT8 *m_char_rom;
65		UINT16 m_roll_bitmap;
66		UINT16 m_pan_x;
67		UINT16 m_pan_y;
68		UINT16 m_zoom;
69		UINT16 m_blink_select;
70		UINT16 m_plane_select;
71		UINT16 m_plane_switch;
72		UINT16 m_color_status_fg;
73		UINT16 m_color_status_bg;
74		UINT16 m_roll_overlay;
	79	required_shared_ptr<UINT16> m_roll_bitmap;
	80	required_shared_ptr<UINT16> m_pan_x;
	81	required_shared_ptr<UINT16> m_pan_y;
	82	required_shared_ptr<UINT16> m_zoom;
	83	required_shared_ptr<UINT16> m_blink_select;
	84	required_shared_ptr<UINT16> m_plane_select;
	85	required_shared_ptr<UINT16> m_plane_switch;
	86	required_shared_ptr<UINT16> m_color_status_fg;
	87	required_shared_ptr<UINT16> m_color_status_bg;
	88	required_shared_ptr<UINT16> m_roll_overlay;
75	89	int m_blink;
76		UINT16* m_chrom_ram;
77	90	};
78	91
79	92	/----------- defined in video/cgc7900.c -----------/

src/mess/includes/abc80x.h
r14946	r14947
79	79	m_dart(*this, Z80DART_TAG),
80	80	m_sio(*this, Z80SIO_TAG),
81	81	m_discrete(*this, "discrete"),
82		m_ram(*this, RAM_TAG)
83		{ }
	82	m_ram(*this, RAM_TAG),
	83	m_video_ram(*this, "video_ram"),
	84	m_char_ram(*this, "char_ram"){ }
84	85
85	86	required_device<cpu_device> m_maincpu;
86	87	required_device<z80ctc_device> m_ctc;
r14946	r14947
112	113	int m_fetch_charram; // opcode fetched from character RAM region (0x7800-0x7fff)
113	114
114	115	// video state
115		UINT8 *m_char_ram; // character RAM
116		UINT8 *m_video_ram; // HR video RAM
	116	required_shared_ptr<UINT8> m_video_ram; // HR video RAM
	117	required_shared_ptr<UINT8> m_char_ram; // character RAM
117	118	const UINT8 *m_char_rom; // character generator ROM
118	119	const UINT8 *m_fgctl_prom; // foreground control PROM
119	120	UINT8 m_hrs; // HR picture start scanline

src/mess/includes/tmc2000e.h
r14946	r14947
28	28	m_maincpu(*this, CDP1802_TAG),
29	29	m_cti(*this, CDP1864_TAG),
30	30	m_cassette(*this, CASSETTE_TAG)
31		{ }
	31	,
	32	m_colorram(*this, "colorram"){ }
32	33
33	34	required_device<cpu_device> m_maincpu;
34	35	required_device<cdp1864_device> m_cti;
r14946	r14947
59	60
60	61	/* video state */
61	62	int m_cdp1864_efx; /* EFx */
62		UINT8 m_colorram; / color memory */
	63	required_shared_ptr<UINT8> m_colorram; /* color memory */
63	64	UINT8 m_color;
64	65
65	66	/* keyboard state */

src/mess/includes/hec2hrp.h
r14946	r14947
70	70	{
71	71	public:
72	72	hec2hrp_state(const machine_config &mconfig, device_type type, const char *tag)
73		: driver_device(mconfig, type, tag) { }
	73	: driver_device(mconfig, type, tag),
	74	m_videoram(*this,"videoram"),
	75	m_hector_videoram(*this,"hector_videoram") { }
74	76
75		UINT8 *m_videoram;
76		UINT8 *m_hector_videoram;
	77	required_shared_ptr<UINT8> m_videoram;
	78	required_shared_ptr<UINT8> m_hector_videoram;
77	79	UINT8 m_hector_flag_hr;
78	80	UINT8 m_hector_flag_80c;
79	81	UINT8 m_hector_color[4];

src/mess/includes/bk.h
r14946	r14947
12	12	{
13	13	public:
14	14	bk_state(const machine_config &mconfig, device_type type, const char *tag)
15		: driver_device(mconfig, type, tag) { }
	15	: driver_device(mconfig, type, tag) ,
	16	m_bk0010_video_ram(*this, "bk0010_video_ram"){ }
16	17
17	18	UINT16 m_scrool;
18		UINT16 *m_bk0010_video_ram;
	19	required_shared_ptr<UINT16> m_bk0010_video_ram;
19	20	UINT16 m_kbd_state;
20	21	UINT16 m_key_code;
21	22	UINT16 m_key_pressed;

src/mess/includes/nascom1.h
r14946	r14947
28	28	{
29	29	public:
30	30	nascom1_state(const machine_config &mconfig, device_type type, const char *tag)
31		: driver_device(mconfig, type, tag) { }
	31	: driver_device(mconfig, type, tag) ,
	32	m_videoram(*this, "videoram"){ }
32	33
33		UINT8 *m_videoram;
	34	required_shared_ptr<UINT8> m_videoram;
34	35	device_t *m_hd6402;
35	36	int m_tape_size;
36	37	UINT8 *m_tape_image;

src/mess/includes/apricotf.h
r14946	r14947
49	49	m_floppy0(*this, FLOPPY_0),
50	50	m_centronics(*this, CENTRONICS_TAG),
51	51	m_ctc_int(CLEAR_LINE),
52		m_sio_int(CLEAR_LINE)
53		{ }
	52	m_sio_int(CLEAR_LINE),
	53	m_p_scrollram(*this, "p_scrollram"),
	54	m_p_paletteram(*this, "p_paletteram"){ }
54	55
55	56	required_device<cpu_device> m_maincpu;
56	57	required_device<z80ctc_device> m_ctc;
r14946	r14947
58	59	required_device<device_t> m_fdc;
59	60	required_device<device_t> m_floppy0;
60	61	required_device<centronics_device> m_centronics;
	62	int m_ctc_int;
	63	int m_sio_int;
	64	required_shared_ptr<UINT16> m_p_scrollram;
	65	required_shared_ptr<UINT16> m_p_paletteram;
61	66
62	67	UINT32 screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
63	68
r14946	r14947
69	74	DECLARE_WRITE_LINE_MEMBER( ctc_z1_w );
70	75	DECLARE_WRITE_LINE_MEMBER( ctc_z2_w );
71	76
72		int m_ctc_int;
73		int m_sio_int;
74
75		UINT16 *m_p_paletteram;
76		UINT16 *m_p_scrollram;
77	77	int m_40_80;
78	78	int m_200_256;
79	79	};

src/mess/includes/microtan.h
r14946	r14947
23	23	{
24	24	public:
25	25	microtan_state(const machine_config &mconfig, device_type type, const char *tag)
26		: driver_device(mconfig, type, tag) { }
	26	: driver_device(mconfig, type, tag) ,
	27	m_videoram(*this, "videoram"){ }
27	28
28		UINT8 *m_videoram;
	29	required_shared_ptr<UINT8> m_videoram;
29	30	UINT8 m_chunky_graphics;
30	31	UINT8 *m_chunky_buffer;
31	32	UINT8 m_keypad_column;

src/mess/includes/sapi1.h
r14946	r14947
11	11	{
12	12	public:
13	13	sapi1_state(const machine_config &mconfig, device_type type, const char *tag)
14		: driver_device(mconfig, type, tag) { }
	14	: driver_device(mconfig, type, tag) ,
	15	m_sapi_video_ram(*this, "sapi_video_ram"){ }
15	16
16		UINT8* m_sapi_video_ram;
	17	required_shared_ptr<UINT8> m_sapi_video_ram;
17	18	UINT8 m_keyboard_mask;
18	19	UINT8 m_refresh_counter;
19	20	UINT8 m_zps3_25;

src/mess/includes/intv.h
r14946	r14947
36	36	m_intellivoice(*this, "sp0256_speech"),
37	37	m_sound(*this, "ay8914.1"),
38	38	m_ecs_sound(*this, "ay8914.2")
39		{ }
	39	,
	40	m_intvkbd_dualport_ram(*this, "intvkbd_dualport_ram"),
	41	m_videoram(*this, "videoram"){ }
40	42
41	43	required_device<cpu_device> m_maincpu;
42	44	required_device<device_t> m_intellivoice;
43	45	required_device<device_t> m_sound;
44	46	optional_device<device_t> m_ecs_sound;
	47	required_shared_ptr<UINT16> m_intvkbd_dualport_ram;
	48	required_shared_ptr<UINT8> m_videoram;
45	49
46	50
47
48	51	DECLARE_READ16_MEMBER(intv_stic_r);
49	52	DECLARE_WRITE16_MEMBER(intv_stic_w);
50	53	DECLARE_READ16_MEMBER(intv_gram_r);
r14946	r14947
61	64	DECLARE_READ8_MEMBER( intv_left_control_r );
62	65
63	66	bitmap_ind16 m_bitmap;
64		~~UINT8 *m_videoram;~~
	67
65	68	intv_sprite_type m_sprite[STIC_MOBS];
66	69	UINT8 m_sprite_buffers[STIC_MOBS][STIC_CARD_WIDTH2][STIC_CARD_HEIGHT422];
67	70	UINT16 m_backtab_buffer[STIC_BACKTAB_HEIGHT][STIC_BACKTAB_WIDTH];
r14946	r14947
116	119	UINT8 m_tms9927_last_row;
117	120
118	121	int m_intvkbd_text_blanked;
119		UINT16 *m_intvkbd_dualport_ram;
120	122	int m_intvkbd_keyboard_col;
121	123	int m_tape_int_pending;
122	124	int m_tape_interrupts_enabled;

src/mess/includes/special.h
r14946	r14947
34	34	m_dac(*this, "dac"),
35	35	m_cass(*this, CASSETTE_TAG),
36	36	m_ram(*this, RAM_TAG)
37		{ }
	37	,
	38	m_p_videoram(*this, "p_videoram"){ }
38	39
39	40	DECLARE_WRITE8_MEMBER(specimx_select_bank);
40	41	DECLARE_WRITE8_MEMBER(video_memory_w);
r14946	r14947
63	64	UINT8 m_erik_color_1;
64	65	UINT8 m_erik_color_2;
65	66	UINT8 m_erik_background;
66		UINT8 *m_p_videoram;
67	67	UINT8 m_specimx_color;
68	68	device_t *m_specimx_audio;
69	69	int m_specialist_8255_porta;
r14946	r14947
77	77	optional_device<device_t> m_dac;
78	78	optional_device<cassette_image_device> m_cass;
79	79	optional_device<ram_device> m_ram;
	80	required_shared_ptr<UINT8> m_p_videoram;
80	81	};
81	82
82	83

src/mess/includes/mikro80.h
r14946	r14947
13	13	{
14	14	public:
15	15	mikro80_state(const machine_config &mconfig, device_type type, const char *tag)
16		: driver_device(mconfig, type, tag) { }
	16	: driver_device(mconfig, type, tag) ,
	17	m_cursor_ram(*this, "cursor_ram"),
	18	m_video_ram(*this, "video_ram"){ }
17	19
18		UINT8 *m_video_ram;
19		UINT8 *m_cursor_ram;
	20	required_shared_ptr<UINT8> m_cursor_ram;
	21	required_shared_ptr<UINT8> m_video_ram;
20	22	int m_keyboard_mask;
21	23	int m_key_mask;
22	24	};

src/mess/includes/mz80.h
r14946	r14947
25	25	m_ppi(*this, "ppi8255"),
26	26	m_cass(*this, CASSETTE_TAG),
27	27	m_speaker(*this, SPEAKER_TAG)
28		{ }
	28	,
	29	m_p_ram(*this, "p_ram"),
	30	m_p_videoram(*this, "p_videoram"){ }
29	31
30	32	required_device<cpu_device> m_maincpu;
31	33	required_device<device_t> m_pit;
r14946	r14947
46	48	bool m_prev_state;
47	49	UINT8 m_mz80k_cursor_cnt;
48	50	UINT8 m_mz80k_keyboard_line;
49		const UINT8 *m_p_ram;
	51	required_shared_ptr<const UINT8> m_p_ram;
50	52	const UINT8 *m_p_chargen;
51		const UINT8 *m_p_videoram;
	53	required_shared_ptr<const UINT8> m_p_videoram;
52	54	};
53	55
54	56

src/mess/includes/poly88.h
r14946	r14947
14	14	{
15	15	public:
16	16	poly88_state(const machine_config &mconfig, device_type type, const char *tag)
17		: driver_device(mconfig, type, tag) { }
	17	: driver_device(mconfig, type, tag) ,
	18	m_video_ram(*this, "video_ram"){ }
18	19
19		UINT8 *m_video_ram;
	20	required_shared_ptr<UINT8> m_video_ram;
20	21	UINT8 *m_FNT;
21	22	UINT8 m_intr;
22	23	UINT8 m_last_code;

src/mess/includes/ut88.h
r14946	r14947
23	23	m_cass(*this, CASSETTE_TAG),
24	24	m_ppi(*this, "ppi8255"),
25	25	m_dac(*this, "dac")
26		{ }
	26	,
	27	m_p_videoram(*this, "p_videoram"){ }
27	28
28	29	required_device<cassette_image_device> m_cass;
29	30	optional_device<i8255_device> m_ppi;
r14946	r14947
37	38	DECLARE_READ8_MEMBER(ut88_8255_portb_r);
38	39	DECLARE_READ8_MEMBER(ut88_8255_portc_r);
39	40	DECLARE_WRITE8_MEMBER(ut88_8255_porta_w);
40		UINT8 *m_p_videoram;
	41	required_shared_ptr<UINT8> m_p_videoram;
41	42	int m_keyboard_mask;
42	43	int m_lcd_digit[6];
43	44	};

src/mess/includes/llc.h
r14946	r14947
14	14	{
15	15	public:
16	16	llc_state(const machine_config &mconfig, device_type type, const char *tag)
17		: driver_device(mconfig, type, tag) { }
	17	: driver_device(mconfig, type, tag) ,
	18	m_video_ram(*this, "video_ram"){ }
18	19
19		UINT8 *m_video_ram;
	20	required_shared_ptr<UINT8> m_video_ram;
20	21	UINT8 m_s_code;
21	22	UINT8 m_llc1_key_state;
22	23	};

src/mess/includes/mpz80.h
r14946	r14947
40	40	m_trap_int(1),
41	41	m_trap_stop(1),
42	42	m_trap_aux(1)
43		{ }
	43	,
	44	m_map_ram(*this, "map_ram"){ }
44	45
45	46	required_device<cpu_device> m_maincpu;
46	47	required_device<ram_device> m_ram;
r14946	r14947
74	75
75	76	// memory state
76	77	UINT32 m_addr;
77		UINT8 *m_map_ram;
78	78	UINT8 m_task;
79	79	UINT8 m_mask;
80	80
r14946	r14947
96	96	int m_trap_int;
97	97	int m_trap_stop;
98	98	int m_trap_aux;
	99	required_shared_ptr<UINT8> m_map_ram;
99	100	};
100	101
101	102	#endif

src/mess/includes/jtc.h
r14946	r14947
27	27	m_cassette(*this, CASSETTE_TAG),
28	28	m_speaker(*this, SPEAKER_TAG),
29	29	m_centronics(*this, CENTRONICS_TAG)
30		{ }
	30	,
	31	m_video_ram(*this, "video_ram"){ }
31	32
32	33	required_device<cpu_device> m_maincpu;
33	34	required_device<cassette_image_device> m_cassette;
r14946	r14947
43	44	DECLARE_READ8_MEMBER( p3_r );
44	45	DECLARE_WRITE8_MEMBER( p3_w );
45	46
46		UINT8 *m_video_ram;
	47	required_shared_ptr<UINT8> m_video_ram;
47	48	};
48	49
49	50	class jtces88_state : public jtc_state

src/mess/includes/trs80.h
r14946	r14947
33	33	m_fdc(*this, "wd179x"),
34	34	m_speaker(*this, SPEAKER_TAG),
35	35	m_cass(*this, CASSETTE_TAG)
36		{ }
	36	,
	37	m_p_videoram(*this, "p_videoram"){ }
37	38
38	39	required_device<cpu_device> m_maincpu;
39	40	optional_device<centronics_device> m_printer;
r14946	r14947
80	81	DECLARE_WRITE8_MEMBER( trs80_gfxram_w );
81	82	DECLARE_READ8_MEMBER (trs80_wd179x_r);
82	83	const UINT8 *m_p_chargen;
83		UINT8 *m_p_videoram;
	84	required_shared_ptr<UINT8> m_p_videoram;
84	85	UINT8 *m_p_gfxram;
85	86	UINT8 m_model4;
86	87	UINT8 m_mode;

src/mess/includes/svision.h
r14946	r14947
32	32	{
33	33	public:
34	34	svision_state(const machine_config &mconfig, device_type type, const char *tag)
35		: driver_device(mconfig, type, tag) { }
	35	: driver_device(mconfig, type, tag) ,
	36	m_reg(*this, "reg"),
	37	m_videoram(*this, "videoram"){ }
36	38
37		UINT8 *m_videoram;
38		UINT8 *m_reg;
	39	required_shared_ptr<UINT8> m_reg;
	40	required_shared_ptr<UINT8> m_videoram;
39	41	device_t *m_sound;
40	42	int *m_dma_finished;
41	43	svision_t m_svision;

src/mess/includes/xerox820.h
r14946	r14947
29	29	m_ram(*this, RAM_TAG),
30	30	m_floppy0(*this, FLOPPY_0),
31	31	m_floppy1(*this, FLOPPY_1)
32		{ }
	32	,
	33	m_video_ram(*this, "video_ram"){ }
33	34
34	35	virtual void machine_start();
35	36	virtual void machine_reset();
r14946	r14947
62	63	int m_keydata; /* keyboard data */
63	64
64	65	/* video state */
65		UINT8 m_video_ram; / video RAM */
	66	required_shared_ptr<UINT8> m_video_ram; /* video RAM */
66	67	UINT8 m_char_rom; / character ROM */
67	68	UINT8 m_scroll; /* vertical scroll */
68	69	UINT8 m_framecnt;

src/mess/includes/micronic.h
r14946	r14947
28	28	m_beep(*this, BEEPER_TAG),
29	29	m_rtc(*this, MC146818_TAG),
30	30	m_ram(*this, RAM_TAG)
31		{ }
	31	,
	32	m_ram_base(*this, "ram_base"){ }
32	33
33	34	required_device<cpu_device> m_maincpu;
34	35	required_device<hd61830_device> m_lcdc;
r14946	r14947
53	54	DECLARE_WRITE8_MEMBER( rtc_data_w );
54	55	DECLARE_WRITE_LINE_MEMBER( mc146818_irq );
55	56
56		UINT8 *m_ram_base;
	57	required_shared_ptr<UINT8> m_ram_base;
57	58	UINT8 m_banks_num;
58	59	UINT8 m_kp_matrix;
59	60	UINT8 m_lcd_contrast;

src/mess/includes/pce.h
r14946	r14947
107	107	{
108	108	public:
109	109	pce_state(const machine_config &mconfig, device_type type, const char *tag)
110		: driver_device(mconfig, type, tag) { }
	110	: driver_device(mconfig, type, tag) ,
	111	m_cd_ram(*this, "cd_ram"),
	112	m_user_ram(*this, "user_ram"){ }
111	113
112		unsigned char *m_user_ram;
113		UINT8 *m_cd_ram;
	114	required_shared_ptr<UINT8> m_cd_ram;
	115	required_shared_ptr<unsigned char> m_user_ram;
114	116	UINT8 m_io_port_options;
115	117	UINT8 m_sys3_card;
116	118	UINT8 m_acard;

src/mess/includes/tdv2324.h
r14946	r14947
57	57	m_pic(*this, P8259A_TAG),
58	58	m_pit0(*this, P8253_5_0_TAG),
59	59	m_pit1(*this, P8253_5_1_TAG)
60		{ }
	60	,
	61	m_video_ram(*this, "video_ram"){ }
61	62
62	63	required_device<cpu_device> m_maincpu;
63	64	required_device<cpu_device> m_subcpu;
r14946	r14947
78	79	UINT8 m_sub_data;
79	80
80	81	// video state
81		UINT8 *m_video_ram;
	82	required_shared_ptr<UINT8> m_video_ram;
82	83	};
83	84
84	85

src/mess/includes/tandy2k.h
r14946	r14947
58	58	m_floppy1(*this, FLOPPY_1),
59	59	m_kb(*this, TANDY2K_KEYBOARD_TAG),
60	60	m_kbdclk(0)
61		{ }
	61	,
	62	m_hires_ram(*this, "hires_ram"),
	63	m_char_ram(*this, "char_ram"){ }
62	64
63	65	required_device<cpu_device> m_maincpu;
64	66	required_device<i8251_device> m_uart;
r14946	r14947
123	125	int m_pb_sel;
124	126
125	127	/* video state */
126		UINT16 *m_char_ram;
127		UINT16 *m_hires_ram;
	128	required_shared_ptr<UINT16> m_hires_ram;
	129	required_shared_ptr<UINT16> m_char_ram;
128	130	UINT16 m_palette[16];
129	131	UINT8 m_vram_base;
130	132	int m_vidouts;

src/mess/includes/huebler.h
r14946	r14947
19	19	m_key_d6(0),
20	20	m_key_d7(0),
21	21	m_key_a8(1)
22		{ }
	22	,
	23	m_video_ram(*this, "video_ram"){ }
23	24
24	25	required_device<cassette_image_device> m_cassette;
25	26
r14946	r14947
41	42	int m_key_a8;
42	43
43	44	// video state
44		UINT8 *m_video_ram;
	45	required_shared_ptr<UINT8> m_video_ram;
45	46	const UINT8 *m_char_rom;
46	47	};
47	48

src/mess/includes/psion.h
r14946	r14947
19	19	m_beep(*this, BEEPER_TAG),
20	20	m_pack1(*this, "pack1"),
21	21	m_pack2(*this, "pack2")
22		{ }
	22	,
	23	m_sys_register(*this, "sys_register"),
	24	m_ram(*this, "m_ram"){ }
23	25
24	26	required_device<cpu_device> m_maincpu;
25	27	required_device<hd44780_device> m_lcdc;
r14946	r14947
29	31
30	32	UINT16 m_kb_counter;
31	33	UINT8 m_enable_nmi;
32		UINT8 *m_sys_register;
	34	required_shared_ptr<UINT8> m_sys_register;
33	35	UINT8 m_tcsr_value;
34	36	UINT8 m_stby_pwr;
35	37	UINT8 m_pulse;
r14946	r14947
40	42	UINT8 m_port6; // datapack control lines
41	43
42	44	// RAM/ROM banks
43		UINT8 *m_ram;
44		size_t m_ram_size;
	45	required_shared_ptr<UINT8> m_ram;
	46	//OBRISI.ME
45	47	UINT8 *m_paged_ram;
46	48	UINT8 m_rom_bank;
47	49	UINT8 m_ram_bank;

src/mess/video/gbamode0.c
r14946	r14947
11	11	static void draw_mode0_scanline(running_machine &machine, gba_state state, int y, UINT32 line0, UINT32* line1, UINT32* line2, UINT32* line3, UINT32* lineOBJ, UINT32* lineOBJWin, UINT32* lineMix, int bpp)
12	12	{
13	13	int x = 0;
14		UINT32 backdrop = ((UINT16*)state->m_gba_pram)[0] \| 0x30000000;
	14	UINT32 backdrop = ((UINT16*)state->m_gba_pram.target())[0] \| 0x30000000;
15	15
16	16	draw_bg_scanline(state, line0, y, DISPCNT_BG0_EN, state->m_BG0CNT, state->m_BG0HOFS, state->m_BG0VOFS);
17	17	draw_bg_scanline(state, line1, y, DISPCNT_BG1_EN, state->m_BG1CNT, state->m_BG1HOFS, state->m_BG1VOFS);
r14946	r14947
114	114	static void draw_mode0_scanline_nowindow(running_machine &machine, gba_state state, int y, UINT32 line0, UINT32* line1, UINT32* line2, UINT32* line3, UINT32* lineOBJ, UINT32* lineOBJWin, UINT32* lineMix, int bpp)
115	115	{
116	116	int x = 0;
117		UINT32 backdrop = ((UINT16*)state->m_gba_pram)[0] \| 0x30000000;
	117	UINT32 backdrop = ((UINT16*)state->m_gba_pram.target())[0] \| 0x30000000;
118	118	int effect = state->m_BLDCNT & BLDCNT_SFX;
119	119
120	120	draw_bg_scanline(state, line0, y, DISPCNT_BG0_EN, state->m_BG0CNT, state->m_BG0HOFS, state->m_BG0VOFS);
r14946	r14947
294	294	static void draw_mode0_scanline_all(running_machine &machine, gba_state state, int y, UINT32 line0, UINT32* line1, UINT32* line2, UINT32* line3, UINT32* lineOBJ, UINT32* lineOBJWin, UINT32* lineMix, int bpp)
295	295	{
296	296	int x = 0;
297		UINT32 backdrop = ((UINT16*)state->m_gba_pram)[0] \| 0x30000000;
	297	UINT32 backdrop = ((UINT16*)state->m_gba_pram.target())[0] \| 0x30000000;
298	298	int inWindow0 = 0;
299	299	int inWindow1 = 0;
300	300	UINT8 inWin0Mask = state->m_WININ & 0x00ff;

src/mess/video/mac.c
r14946	r14947
142	142	int y, x, b;
143	143	mac_state *state = screen.machine().driver_data<mac_state>();
144	144
145		video_ram = (const UINT16 *) state->m_vram;
	145	video_ram = (const UINT16 *) state->m_vram.target();
146	146
147	147	for (y = 0; y < 400; y++)
148	148	{
r14946	r14947
168	168	int y, x, b;
169	169	mac_state *state = screen.machine().driver_data<mac_state>();
170	170
171		video_ram = (const UINT16 *) state->m_vram;
	171	video_ram = (const UINT16 *) state->m_vram.target();
172	172
173	173	for (y = 0; y < 400; y++)
174	174	{
r14946	r14947
192	192	int y, x;
193	193	UINT8 pixels;
194	194	mac_state *state = screen.machine().driver_data<mac_state>();
195		UINT8 vram8 = (UINT8 )state->m_vram;
	195	UINT8 vram8 = (UINT8 )state->m_vram.target();
196	196
197	197	for (y = 0; y < 400; y++)
198	198	{
r14946	r14947
526	526	{
527	527	case 0: // 1bpp
528	528	{
529		UINT8 vram8 = (UINT8 )mac->m_vram;
	529	UINT8 vram8 = (UINT8 )mac->m_vram.target();
530	530	UINT8 pixels;
531	531
532	532	if (mac->m_rbv_type == RBV_TYPE_SONORA)
r14946	r14947
574	574
575	575	case 1: // 2bpp
576	576	{
577		UINT8 vram8 = (UINT8 )mac->m_vram;
	577	UINT8 vram8 = (UINT8 )mac->m_vram.target();
578	578	UINT8 pixels;
579	579
580	580	for (y = 0; y < 480; y++)
r14946	r14947
595	595
596	596	case 2: // 4bpp
597	597	{
598		UINT8 vram8 = (UINT8 )mac->m_vram;
	598	UINT8 vram8 = (UINT8 )mac->m_vram.target();
599	599	UINT8 pixels;
600	600
601	601	for (y = 0; y < 480; y++)
r14946	r14947
615	615
616	616	case 3: // 8bpp
617	617	{
618		UINT8 vram8 = (UINT8 )mac->m_vram;
	618	UINT8 vram8 = (UINT8 )mac->m_vram.target();
619	619	UINT8 pixels;
620	620
621	621	if (mac->m_rbv_type == RBV_TYPE_SONORA)
r14946	r14947
879	879	{
880	880	case 0: // 1bpp
881	881	{
882		UINT8 vram8 = (UINT8 )mac->m_vram;
	882	UINT8 vram8 = (UINT8 )mac->m_vram.target();
883	883	UINT8 pixels;
884	884	vram8 += mac->m_dafb_base;
885	885
r14946	r14947
905	905
906	906	case 1: // 2bpp
907	907	{
908		UINT8 vram8 = (UINT8 )mac->m_vram;
	908	UINT8 vram8 = (UINT8 )mac->m_vram.target();
909	909	UINT8 pixels;
910	910	vram8 += mac->m_dafb_base;
911	911
r14946	r14947
927	927
928	928	case 2: // 4bpp
929	929	{
930		UINT8 vram8 = (UINT8 )mac->m_vram;
	930	UINT8 vram8 = (UINT8 )mac->m_vram.target();
931	931	UINT8 pixels;
932	932	vram8 += mac->m_dafb_base;
933	933
r14946	r14947
948	948
949	949	case 3: // 8bpp
950	950	{
951		UINT8 vram8 = (UINT8 )mac->m_vram;
	951	UINT8 vram8 = (UINT8 )mac->m_vram.target();
952	952	UINT8 pixels;
953	953	vram8 += mac->m_dafb_base;
954	954
r14946	r14947
988	988	UINT32 *scanline;
989	989	int x, y;
990	990	mac_state *mac = screen.machine().driver_data<mac_state>();
991		UINT8 vram8 = (UINT8 )mac->m_vram;
	991	UINT8 vram8 = (UINT8 )mac->m_vram.target();
992	992	UINT8 pixels;
993	993
994	994	// vram8 += 0x40000;

src/mess/video/mc80.c
r14946	r14947
140	140	VIDEO_START( mc8030 )
141	141	{
142	142	mc80_state *state = machine.driver_data<mc80_state>();
143		state->m_p_videoram = machine.region("vram")->base();
	143	state->m_p_videoram.set_target(machine.region("vram")->base(),state->m_p_videoram.bytes());
144	144	}
145	145
146	146	SCREEN_UPDATE_IND16( mc8030 )

src/mess/video/gbamode1.c
r14946	r14947
11	11	static void draw_mode1_scanline(running_machine &machine, gba_state state, int y, UINT32 line0, UINT32* line1, UINT32* line2, UINT32* line3, UINT32* lineOBJ, UINT32* lineOBJWin, UINT32* lineMix, int bpp)
12	12	{
13	13	int x = 0;
14		UINT32 backdrop = ((UINT16*)state->m_gba_pram)[0] \| 0x30000000;
	14	UINT32 backdrop = ((UINT16*)state->m_gba_pram.target())[0] \| 0x30000000;
15	15
16	16	draw_bg_scanline(state, line0, y, DISPCNT_BG0_EN, state->m_BG0CNT, state->m_BG0HOFS, state->m_BG0VOFS);
17	17	draw_bg_scanline(state, line1, y, DISPCNT_BG1_EN, state->m_BG1CNT, state->m_BG1HOFS, state->m_BG1VOFS);
r14946	r14947
102	102	static void draw_mode1_scanline_nowindow(running_machine &machine, gba_state state, int y, UINT32 line0, UINT32* line1, UINT32* line2, UINT32* line3, UINT32* lineOBJ, UINT32* lineOBJWin, UINT32* lineMix, int bpp)
103	103	{
104	104	int x = 0;
105		UINT32 backdrop = ((UINT16*)state->m_gba_pram)[0] \| 0x30000000;
	105	UINT32 backdrop = ((UINT16*)state->m_gba_pram.target())[0] \| 0x30000000;
106	106	int effect = state->m_BLDCNT & BLDCNT_SFX;
107	107
108	108	draw_bg_scanline(state, line0, y, DISPCNT_BG0_EN, state->m_BG0CNT, state->m_BG0HOFS, state->m_BG0VOFS);
r14946	r14947
261	261	static void draw_mode1_scanline_all(running_machine &machine, gba_state state, int y, UINT32 line0, UINT32* line1, UINT32* line2, UINT32* line3, UINT32* lineOBJ, UINT32* lineOBJWin, UINT32* lineMix, int bpp)
262	262	{
263	263	int x = 0;
264		UINT32 backdrop = ((UINT16*)state->m_gba_pram)[0] \| 0x30000000;
	264	UINT32 backdrop = ((UINT16*)state->m_gba_pram.target())[0] \| 0x30000000;
265	265	int inWindow0 = 0;
266	266	int inWindow1 = 0;
267	267	UINT8 inWin0Mask = state->m_WININ & 0x00ff;

src/mess/video/gbam345.c
r14946	r14947
11	11	static void draw_roz_bitmap_mode_scanline(running_machine &machine, gba_state state, int y, UINT32 line0, UINT32* line1, UINT32* line2, UINT32* line3, UINT32* lineOBJ, UINT32* lineOBJWin, UINT32* lineMix, int bpp)
12	12	{
13	13	int x = 0;
14		UINT32 backdrop = ((UINT16*)state->m_gba_pram)[0] \| 0x30000000;
	14	UINT32 backdrop = ((UINT16*)state->m_gba_pram.target())[0] \| 0x30000000;
15	15
16	16	draw_roz_bitmap_scanline(state, line2, y, DISPCNT_BG2_EN, state->m_BG2CNT, state->m_BG2X, state->m_BG2Y, state->m_BG2PA, state->m_BG2PB, state->m_BG2PC, state->m_BG2PD, &state->m_gfxBG2X, &state->m_gfxBG2Y, state->m_gfxBG2Changed, bpp);
17	17	draw_gba_oam(state, machine, lineOBJ, y);
r14946	r14947
76	76	static void draw_roz_bitmap_mode_scanline_nowindow(running_machine &machine, gba_state state, int y, UINT32 line0, UINT32* line1, UINT32* line2, UINT32* line3, UINT32* lineOBJ, UINT32* lineOBJWin, UINT32* lineMix, int bpp)
77	77	{
78	78	int x = 0;
79		UINT32 backdrop = ((UINT16*)state->m_gba_pram)[0] \| 0x30000000;
	79	UINT32 backdrop = ((UINT16*)state->m_gba_pram.target())[0] \| 0x30000000;
80	80	int effect = state->m_BLDCNT & BLDCNT_SFX;
81	81
82	82	draw_roz_bitmap_scanline(state, line2, y, DISPCNT_BG2_EN, state->m_BG2CNT, state->m_BG2X, state->m_BG2Y, state->m_BG2PA, state->m_BG2PB, state->m_BG2PC, state->m_BG2PD, &state->m_gfxBG2X, &state->m_gfxBG2Y, state->m_gfxBG2Changed, bpp);
r14946	r14947
191	191	static void draw_roz_bitmap_mode_scanline_all(running_machine &machine, gba_state state, int y, UINT32 line0, UINT32* line1, UINT32* line2, UINT32* line3, UINT32* lineOBJ, UINT32* lineOBJWin, UINT32* lineMix, int bpp)
192	192	{
193	193	int x = 0;
194		UINT32 backdrop = ((UINT16*)state->m_gba_pram)[0] \| 0x30000000;
	194	UINT32 backdrop = ((UINT16*)state->m_gba_pram.target())[0] \| 0x30000000;
195	195	int inWindow0 = 0;
196	196	int inWindow1 = 0;
197	197	UINT8 inWin0Mask = state->m_WININ & 0x00ff;

src/mess/video/cgc7900.c
r14946	r14947
18	18	#define OVERLAY_FB BIT(cell, 8) /* turns on Blue in background if SET */
19	19	#define OVERLAY_DATA (cell & 0xff) /* ASCII or Plot Dot character */
20	20
21		#define IMAGE_SELECT BIT(m_roll_overlay, 13)
22		#define OVERLAY_CURSOR_BLINK BIT(m_roll_overlay, 12)
23		#define OVERLAY_CHARACTER_BLINK BIT(m_roll_overlay, 11)
	21	#define IMAGE_SELECT BIT(m_roll_overlay[0], 13)
	22	#define OVERLAY_CURSOR_BLINK BIT(m_roll_overlay[0], 12)
	23	#define OVERLAY_CHARACTER_BLINK BIT(m_roll_overlay[0], 11)
24	24
25	25	/***************************************************************************
26	26	READ/WRITE HANDLERS

src/mess/video/gbamode2.c
r14946	r14947
11	11	static void draw_mode2_scanline(running_machine &machine, gba_state state, int y, UINT32 line0, UINT32* line1, UINT32* line2, UINT32* line3, UINT32* lineOBJ, UINT32* lineOBJWin, UINT32* lineMix, int bpp)
12	12	{
13	13	int x = 0;
14		UINT32 backdrop = ((UINT16*)state->m_gba_pram)[0] \| 0x30000000;
	14	UINT32 backdrop = ((UINT16*)state->m_gba_pram.target())[0] \| 0x30000000;
15	15
16	16	draw_roz_scanline(state, line2, y, DISPCNT_BG2_EN, state->m_BG2CNT, state->m_BG2X, state->m_BG2Y, state->m_BG2PA, state->m_BG2PB, state->m_BG2PC, state->m_BG2PD, &state->m_gfxBG2X, &state->m_gfxBG2Y, state->m_gfxBG2Changed);
17	17	draw_roz_scanline(state, line3, y, DISPCNT_BG3_EN, state->m_BG3CNT, state->m_BG3X, state->m_BG3Y, state->m_BG3PA, state->m_BG3PB, state->m_BG3PC, state->m_BG3PD, &state->m_gfxBG3X, &state->m_gfxBG3Y, state->m_gfxBG3Changed);
r14946	r14947
90	90	static void draw_mode2_scanline_nowindow(running_machine &machine, gba_state state, int y, UINT32 line0, UINT32* line1, UINT32* line2, UINT32* line3, UINT32* lineOBJ, UINT32* lineOBJWin, UINT32* lineMix, int bpp)
91	91	{
92	92	int x = 0;
93		UINT32 backdrop = ((UINT16*)state->m_gba_pram)[0] \| 0x30000000;
	93	UINT32 backdrop = ((UINT16*)state->m_gba_pram.target())[0] \| 0x30000000;
94	94	int effect = state->m_BLDCNT & BLDCNT_SFX;
95	95
96	96	draw_roz_scanline(state, line2, y, DISPCNT_BG2_EN, state->m_BG2CNT, state->m_BG2X, state->m_BG2Y, state->m_BG2PA, state->m_BG2PB, state->m_BG2PC, state->m_BG2PD, &state->m_gfxBG2X, &state->m_gfxBG2Y, state->m_gfxBG2Changed);
r14946	r14947
228	228	static void draw_mode2_scanline_all(running_machine &machine, gba_state state, int y, UINT32 line0, UINT32* line1, UINT32* line2, UINT32* line3, UINT32* lineOBJ, UINT32* lineOBJWin, UINT32* lineMix, int bpp)
229	229	{
230	230	int x = 0;
231		UINT32 backdrop = ((UINT16*)state->m_gba_pram)[0] \| 0x30000000;
	231	UINT32 backdrop = ((UINT16*)state->m_gba_pram.target())[0] \| 0x30000000;
232	232	int inWindow0 = 0;
233	233	int inWindow1 = 0;
234	234	UINT8 inWin0Mask = state->m_WININ & 0x00ff;

src/mess/video/abc806.c
r14946	r14947
480	480	m_hru2_prom = machine().region("hru2")->base();
481	481
482	482	// allocate memory
483		m_char_ram = auto_alloc_array(machine(), UINT8, ABC806_CHAR_RAM_SIZE);
	483	//m_char_ram = auto_alloc_array(machine(), UINT8, ABC806_CHAR_RAM_SIZE);
484	484	m_color_ram = auto_alloc_array(machine(), UINT8, ABC806_ATTR_RAM_SIZE);
485	485
486	486	// register for state saving
487		save_pointer(NAME(m_char_ram), ABC806_CHAR_RAM_SIZE);
	487	save_pointer(NAME(m_char_ram.target()), ABC806_CHAR_RAM_SIZE);
488	488	save_pointer(NAME(m_color_ram), ABC806_ATTR_RAM_SIZE);
489		save_pointer(NAME(m_video_ram), ABC806_VIDEO_RAM_SIZE);
	489	save_pointer(NAME(m_video_ram.target()), ABC806_VIDEO_RAM_SIZE);
490	490	save_item(NAME(m_txoff));
491	491	save_item(NAME(m_40));
492	492	save_item(NAME(m_flshclk_ctr));

src/mess/video/gba.c
r14946	r14947
102	102
103	103	static void draw_roz_bitmap_scanline(gba_state state, UINT32 scanline, int ypos, UINT32 enablemask, UINT32 ctrl, INT32 X, INT32 Y, INT32 PA, INT32 PB, INT32 PC, INT32 PD, INT32 currentx, INT32 currenty, int changed, int depth)
104	104	{
105		UINT8 src8 = (UINT8 )state->m_gba_vram;
106		UINT16 src16 = (UINT16 )state->m_gba_vram;
107		UINT16 palette = (UINT16 )state->m_gba_pram;
	105	UINT8 src8 = (UINT8 )state->m_gba_vram.target();
	106	UINT16 src16 = (UINT16 )state->m_gba_vram.target();
	107	UINT16 palette = (UINT16 )state->m_gba_pram.target();
108	108	INT32 sx = (depth == 4) ? 160 : 240;
109	109	INT32 sy = (depth == 4) ? 128 : 160;
110	110	UINT32 prio = ((ctrl & BGCNT_PRIORITY) << 25) + 0x1000000;
r14946	r14947
211	211	UINT32 base, mapbase, size;
212	212	static const INT32 sizes[4] = { 128, 256, 512, 1024 };
213	213	INT32 cx, cy, x, pixx, pixy;
214		UINT8 mgba_vram = (UINT8 )state->m_gba_vram;
	214	UINT8 mgba_vram = (UINT8 )state->m_gba_vram.target();
215	215	UINT32 tile;
216		UINT16 pgba_pram = (UINT16 )state->m_gba_pram;
	216	UINT16 pgba_pram = (UINT16 )state->m_gba_pram.target();
217	217	UINT16 pixel;
218	218	UINT32 prio = ((ctrl & BGCNT_PRIORITY) << 25) + 0x1000000;
219	219
r14946	r14947
393	393
394	394	static void draw_bg_scanline(gba_state state, UINT32 scanline, int ypos, UINT32 enablemask, UINT32 ctrl, UINT32 hofs, UINT32 vofs)
395	395	{
396		UINT8 vram = (UINT8)state->m_gba_vram;
397		UINT16 palette = (UINT16)state->m_gba_pram;
	396	UINT8 vram = (UINT8)state->m_gba_vram.target();
	397	UINT16 palette = (UINT16)state->m_gba_pram.target();
398	398	UINT8 chardata = &vram[((ctrl & BGCNT_CHARBASE) >> BGCNT_CHARBASE_SHIFT) 0x4000];
399	399	UINT16 screendata = (UINT16)&vram[((ctrl & BGCNT_SCREENBASE) >> BGCNT_SCREENBASE_SHIFT) * 0x800];
400	400	UINT32 priority = ((ctrl & BGCNT_PRIORITY) << 25) + 0x1000000;
r14946	r14947
620	620	INT16 gba_oamindex;
621	621	UINT32 tilebytebase, tileindex, tiledrawindex;
622	622	UINT32 width, height;
623		UINT16 pgba_oam = (UINT16 )state->m_gba_oam;
	623	UINT16 pgba_oam = (UINT16 )state->m_gba_oam.target();
624	624	int x = 0;
625		UINT8 src = (UINT8)state->m_gba_vram;
	625	UINT8 src = (UINT8)state->m_gba_vram.target();
626	626
627	627	for(x = 0; x < 240; x++)
628	628	{
r14946	r14947
1069	1069	INT32 mosaicx = ((state->m_MOSAIC & 0x0f00) >> 8) + 1;
1070	1070	UINT32 tileindex, tiledrawindex; //, tilebytebase
1071	1071	UINT8 width, height;
1072		UINT16 pgba_oam = (UINT16 )state->m_gba_oam;
1073		UINT8 src = (UINT8 )state->m_gba_vram;
1074		UINT16 palette = (UINT16)state->m_gba_pram;
	1072	UINT16 pgba_oam = (UINT16 )state->m_gba_oam.target();
	1073	UINT8 src = (UINT8 )state->m_gba_vram.target();
	1074	UINT16 palette = (UINT16)state->m_gba_pram.target();
1075	1075	int x = 0;
1076	1076
1077	1077	for(x = 0; x < 240; x++)

src/mess/drivers/dgn_beta.c
r14946	r14947
141	141	AM_RANGE(0x3000, 0x3FFF) AM_RAMBANK("bank4")
142	142	AM_RANGE(0x4000, 0x4FFF) AM_RAMBANK("bank5")
143	143	AM_RANGE(0x5000, 0x5FFF) AM_RAMBANK("bank6")
144		AM_RANGE(0x6000, 0x6FFF) AM_RAMBANK("bank7") AM_BASE(m_videoram)
	144	AM_RANGE(0x6000, 0x6FFF) AM_RAMBANK("bank7") AM_SHARE("videoram")
145	145	AM_RANGE(0x7000, 0x7FFF) AM_RAMBANK("bank8")
146	146	AM_RANGE(0x8000, 0x8FFF) AM_RAMBANK("bank9")
147	147	AM_RANGE(0x9000, 0x9FFF) AM_RAMBANK("bank10")

src/mess/drivers/c65.c
r14946	r14947
79	79	AM_RANGE(0x0dc00, 0x0dfff) AM_READ_BANK("bank8") AM_WRITE_BANK("bank9")
80	80	AM_RANGE(0x0e000, 0x0ffff) AM_READ_BANK("bank10") AM_WRITE_BANK("bank15")
81	81	AM_RANGE(0x10000, 0x1f7ff) AM_RAM
82		AM_RANGE(0x1f800, 0x1ffff) AM_RAM AM_BASE(m_colorram)
	82	AM_RANGE(0x1f800, 0x1ffff) AM_RAM AM_SHARE("colorram")
83	83
84	84	AM_RANGE(0x20000, 0x23fff) AM_ROM /* &c65_dos, maps to 0x8000 */
85	85	AM_RANGE(0x24000, 0x28fff) AM_ROM /* reserved */
86		AM_RANGE(0x29000, 0x29fff) AM_ROM AM_BASE(m_chargen)
87		AM_RANGE(0x2a000, 0x2bfff) AM_ROM AM_BASE(m_basic)
88		AM_RANGE(0x2c000, 0x2cfff) AM_ROM AM_BASE(m_interface)
89		AM_RANGE(0x2d000, 0x2dfff) AM_ROM AM_BASE(m_chargen)
90		AM_RANGE(0x2e000, 0x2ffff) AM_ROM AM_BASE(m_kernal)
	86	AM_RANGE(0x29000, 0x29fff) AM_ROM AM_SHARE("chargen")
	87	AM_RANGE(0x2a000, 0x2bfff) AM_ROM AM_SHARE("basic")
	88	AM_RANGE(0x2c000, 0x2cfff) AM_ROM AM_SHARE("interface")
	89	AM_RANGE(0x2d000, 0x2dfff) AM_ROM AM_SHARE("chargen")
	90	AM_RANGE(0x2e000, 0x2ffff) AM_ROM AM_SHARE("kernal")
91	91
92	92	AM_RANGE(0x30000, 0x31fff) AM_ROM /&c65_monitor, monitor maps to 0x6000 /
93	93	AM_RANGE(0x32000, 0x37fff) AM_ROM /&c65_basic, /

src/mess/drivers/mc1000.c
r14946	r14947
123	123
124	124	static ADDRESS_MAP_START( mc1000_mem, AS_PROGRAM, 8, mc1000_state )
125	125	AM_RANGE(0x0000, 0x1fff) AM_RAMBANK("bank1")
126		AM_RANGE(0x2000, 0x27ff) AM_RAMBANK("bank2") AM_BASE(m_mc6845_video_ram)
	126	AM_RANGE(0x2000, 0x27ff) AM_RAMBANK("bank2") AM_SHARE("mc6845_video_ram")
127	127	AM_RANGE(0x2800, 0x3fff) AM_RAM
128	128	AM_RANGE(0x4000, 0x7fff) AM_RAMBANK("bank3")
129		AM_RANGE(0x8000, 0x97ff) AM_RAMBANK("bank4") AM_BASE(m_mc6847_video_ram)
	129	AM_RANGE(0x8000, 0x97ff) AM_RAMBANK("bank4") AM_SHARE("mc6847_video_ram")
130	130	AM_RANGE(0x9800, 0xbfff) AM_RAMBANK("bank5")
131	131	AM_RANGE(0xc000, 0xffff) AM_ROM
132	132	ADDRESS_MAP_END

src/mess/drivers/cbmb.c
r14946	r14947
132	132	AM_RANGE(0xf2000, 0xf3fff) AM_ROM /* cartridges or ram */
133	133	AM_RANGE(0xf4000, 0xf5fff) AM_ROM
134	134	AM_RANGE(0xf6000, 0xf7fff) AM_ROM
135		AM_RANGE(0xf8000, 0xfbfff) AM_ROM AM_BASE(m_basic)
136		AM_RANGE(0xfd000, 0xfd7ff) AM_RAM AM_BASE(m_videoram) /* VIDEORAM */
	135	AM_RANGE(0xf8000, 0xfbfff) AM_ROM AM_SHARE("basic")
	136	AM_RANGE(0xfd000, 0xfd7ff) AM_RAM AM_SHARE("videoram") /* VIDEORAM */
137	137	AM_RANGE(0xfd800, 0xfd800) AM_MIRROR(0xfe) AM_DEVWRITE("crtc", mc6845_device, address_w)
138	138	AM_RANGE(0xfd801, 0xfd801) AM_MIRROR(0xfe) AM_DEVREADWRITE("crtc", mc6845_device, register_r, register_w)
139	139	/* disk units */
r14946	r14947
143	143	/* dd00 acia */
144	144	AM_RANGE(0xfde00, 0xfdeff) AM_DEVREADWRITE_LEGACY("tpi6525_0", tpi6525_r, tpi6525_w)
145	145	AM_RANGE(0xfdf00, 0xfdfff) AM_DEVREADWRITE_LEGACY("tpi6525_1", tpi6525_r, tpi6525_w)
146		AM_RANGE(0xfe000, 0xfffff) AM_ROM AM_BASE(m_kernal)
	146	AM_RANGE(0xfe000, 0xfffff) AM_ROM AM_SHARE("kernal")
147	147	ADDRESS_MAP_END
148	148
149	149	static ADDRESS_MAP_START(p500_mem , AS_PROGRAM, 8, cbmb_state )
r14946	r14947
159	159	AM_RANGE(0xf2000, 0xf3fff) AM_ROM /* cartridges or ram */
160	160	AM_RANGE(0xf4000, 0xf5fff) AM_ROM
161	161	AM_RANGE(0xf6000, 0xf7fff) AM_ROM
162		AM_RANGE(0xf8000, 0xfbfff) AM_ROM AM_BASE(m_basic)
163		AM_RANGE(0xfd000, 0xfd3ff) AM_RAM AM_BASE(m_videoram) /* videoram */
164		AM_RANGE(0xfd400, 0xfd7ff) AM_RAM_WRITE_LEGACY(cbmb_colorram_w) AM_BASE(m_colorram) /* colorram */
	162	AM_RANGE(0xf8000, 0xfbfff) AM_ROM AM_SHARE("basic")
	163	AM_RANGE(0xfd000, 0xfd3ff) AM_RAM AM_SHARE("videoram") /* videoram */
	164	AM_RANGE(0xfd400, 0xfd7ff) AM_RAM_WRITE_LEGACY(cbmb_colorram_w) AM_SHARE("colorram") /* colorram */
165	165	AM_RANGE(0xfd800, 0xfd8ff) AM_DEVREADWRITE_LEGACY("vic6567", vic2_port_r, vic2_port_w)
166	166	/* disk units */
167	167	AM_RANGE(0xfda00, 0xfdaff) AM_DEVREADWRITE_LEGACY("sid6581", sid6581_r, sid6581_w)
r14946	r14947
170	170	/* dd00 acia */
171	171	AM_RANGE(0xfde00, 0xfdeff) AM_DEVREADWRITE_LEGACY("tpi6525_0", tpi6525_r, tpi6525_w)
172	172	AM_RANGE(0xfdf00, 0xfdfff) AM_DEVREADWRITE_LEGACY("tpi6525_1", tpi6525_r, tpi6525_w)
173		AM_RANGE(0xfe000, 0xfffff) AM_ROM AM_BASE(m_kernal)
	173	AM_RANGE(0xfe000, 0xfffff) AM_ROM AM_SHARE("kernal")
174	174	ADDRESS_MAP_END
175	175
176	176

src/mess/drivers/mc80.c
r14946	r14947
15	15	static ADDRESS_MAP_START(mc8020_mem, AS_PROGRAM, 8, mc80_state)
16	16	ADDRESS_MAP_UNMAP_HIGH
17	17	AM_RANGE(0x0000, 0x0bff) AM_ROM
18		AM_RANGE(0x0c00, 0x0fff) AM_RAM AM_BASE(m_p_videoram)// 1KB RAM ZRE
	18	AM_RANGE(0x0c00, 0x0fff) AM_RAM AM_SHARE("p_videoram")// 1KB RAM ZRE
19	19	AM_RANGE(0x2000, 0x5fff) AM_ROM
20	20	AM_RANGE(0x6000, 0xffff) AM_RAM
21	21	ADDRESS_MAP_END

src/mess/drivers/pokemini.c
r14946	r14947
12	12
13	13	static ADDRESS_MAP_START( pokemini_mem_map, AS_PROGRAM, 8, pokemini_state )
14	14	AM_RANGE( 0x000000, 0x000FFF ) AM_ROM /* bios */
15		AM_RANGE( 0x001000, 0x001FFF ) AM_RAM AM_BASE(m_p_ram) /* VRAM/RAM */
	15	AM_RANGE( 0x001000, 0x001FFF ) AM_RAM AM_SHARE("p_ram") /* VRAM/RAM */
16	16	AM_RANGE( 0x002000, 0x0020FF ) AM_DEVREADWRITE_LEGACY("i2cmem", pokemini_hwreg_r, pokemini_hwreg_w ) /* hardware registers */
17	17	AM_RANGE( 0x002100, 0x1FFFFF ) AM_ROM /* cartridge area */
18	18	ADDRESS_MAP_END

src/mess/drivers/gamecom.c
r14946	r14947
29	29	AM_RANGE( 0x4000, 0x5FFF ) AM_ROMBANK("bank2") /* External ROM/Flash. Controlled by MMU2 */
30	30	AM_RANGE( 0x6000, 0x7FFF ) AM_ROMBANK("bank3") /* External ROM/Flash. Controlled by MMU3 */
31	31	AM_RANGE( 0x8000, 0x9FFF ) AM_ROMBANK("bank4") /* External ROM/Flash. Controlled by MMU4 */
32		AM_RANGE( 0xA000, 0xDFFF ) AM_RAM AM_BASE(m_p_videoram) /* VRAM */
33		AM_RANGE( 0xE000, 0xFFFF ) AM_RAM AM_BASE(m_p_nvram) AM_SHARE("nvram") /* Extended I/O, Extended RAM */
	32	AM_RANGE( 0xA000, 0xDFFF ) AM_RAM AM_SHARE("p_videoram") /* VRAM */
	33	AM_RANGE( 0xE000, 0xFFFF ) AM_RAM AM_SHARE("p_nvram") AM_SHARE("nvram") /* Extended I/O, Extended RAM */
34	34	ADDRESS_MAP_END
35	35
36	36	static const SM8500_CONFIG gamecom_cpu_config = {

src/mess/drivers/ace.c
r14946	r14947
217	217
218	218	static ADDRESS_MAP_START( ace_mem, AS_PROGRAM, 8, ace_state )
219	219	AM_RANGE(0x0000, 0x1fff) AM_ROM
220		AM_RANGE(0x2000, 0x23ff) AM_MIRROR(0x0400) AM_RAM AM_BASE(m_video_ram)
221		AM_RANGE(0x2800, 0x2bff) AM_MIRROR(0x0400) AM_RAM AM_BASE(m_char_ram) AM_REGION(Z80_TAG, 0xfc00)
	220	AM_RANGE(0x2000, 0x23ff) AM_MIRROR(0x0400) AM_RAM AM_SHARE("video_ram")
	221	AM_RANGE(0x2800, 0x2bff) AM_MIRROR(0x0400) AM_RAM AM_SHARE("char_ram") AM_REGION(Z80_TAG, 0xfc00)
222	222	AM_RANGE(0x3000, 0x33ff) AM_MIRROR(0x0c00) AM_RAM
223	223	AM_RANGE(0x4000, 0xffff) AM_RAM
224	224	ADDRESS_MAP_END

src/mess/drivers/spectrum.c
r14946	r14947
435	435
436	436	static ADDRESS_MAP_START (spectrum_mem, AS_PROGRAM, 8, spectrum_state )
437	437	AM_RANGE(0x0000, 0x3fff) AM_ROM
438		AM_RANGE(0x4000, 0x5aff) AM_RAM AM_BASE(m_video_ram)
	438	AM_RANGE(0x4000, 0x5aff) AM_RAM AM_SHARE("video_ram")
439	439	// AM_RANGE(0x5b00, 0x7fff) AM_RAM
440	440	// AM_RANGE(0x8000, 0xffff) AM_RAM
441	441	ADDRESS_MAP_END

src/mess/drivers/c128.c
r14946	r14947
233	233	#if 0
234	234	AM_RANGE(0x10000, 0x1ffff) AM_WRITEONLY
235	235	AM_RANGE(0x20000, 0xfffff) AM_WRITEONLY /* or nothing */
236		AM_RANGE(0x100000, 0x107fff) AM_BASE(m_c128_basic) /* maps to 0x4000 */
237		AM_RANGE(0x108000, 0x109fff) AM_BASE(m_basic) /* maps to 0xa000 */
238		AM_RANGE(0x10a000, 0x10bfff) AM_BASE(m_kernal) /* maps to 0xe000 */
239		AM_RANGE(0x10c000, 0x10cfff) AM_BASE(m_editor)
240		AM_RANGE(0x10d000, 0x10dfff) AM_BASE(m_z80) /* maps to z80 0 */
241		AM_RANGE(0x10e000, 0x10ffff) AM_BASE(m_c128_kernal)
242		AM_RANGE(0x110000, 0x117fff) AM_BASE(m_internal_function)
243		AM_RANGE(0x118000, 0x11ffff) AM_BASE(m_external_function)
244		AM_RANGE(0x120000, 0x120fff) AM_BASE(m_chargen)
245		AM_RANGE(0x121000, 0x121fff) AM_BASE(m_c128_chargen)
246		AM_RANGE(0x122000, 0x1227ff) AM_BASE(m_colorram)
247		AM_RANGE(0x122800, 0x1327ff) AM_BASE(m_vdcram)
	236	AM_RANGE(0x100000, 0x107fff) AM_SHARE("c128_basic") /* maps to 0x4000 */
	237	AM_RANGE(0x108000, 0x109fff) AM_SHARE("basic") /* maps to 0xa000 */
	238	AM_RANGE(0x10a000, 0x10bfff) AM_SHARE("kernal") /* maps to 0xe000 */
	239	AM_RANGE(0x10c000, 0x10cfff) AM_SHARE("editor")
	240	AM_RANGE(0x10d000, 0x10dfff) AM_SHARE("z80") /* maps to z80 0 */
	241	AM_RANGE(0x10e000, 0x10ffff) AM_SHARE("c128_kernal")
	242	AM_RANGE(0x110000, 0x117fff) AM_SHARE("internal_function")
	243	AM_RANGE(0x118000, 0x11ffff) AM_SHARE("external_function")
	244	AM_RANGE(0x120000, 0x120fff) AM_SHARE("chargen")
	245	AM_RANGE(0x121000, 0x121fff) AM_SHARE("c128_chargen")
	246	AM_RANGE(0x122000, 0x1227ff) AM_SHARE("colorram")
	247	AM_RANGE(0x122800, 0x1327ff) AM_SHARE("vdcram")
248	248	/* 2 kbyte by 8 bits, only 1 kbyte by 4 bits used) */
249	249	#endif
250	250	ADDRESS_MAP_END

src/mess/drivers/px8.c
r14946	r14947
531	531	AM_RANGE(0x0020, 0x0023) AM_READWRITE(gah40s_r, gah40s_w)
532	532	// AM_RANGE(0x0024, 0x0027) AM_DEVREADWRITE_LEGACY(SED1320_TAG, )
533	533	AM_RANGE(0x0028, 0x0028) AM_WRITE(gah40s_ier_w)
534		AM_RANGE(0x8000, 0x97ff) AM_RAM AM_BASE(m_video_ram)
	534	AM_RANGE(0x8000, 0x97ff) AM_RAM AM_SHARE("video_ram")
535	535	AM_RANGE(0x9800, 0xefff) AM_NOP
536	536	AM_RANGE(0xf000, 0xffff) AM_ROM AM_REGION(HD6303_TAG, 0) /* internal mask rom */
537	537	ADDRESS_MAP_END

src/mess/drivers/phc25.c
r14946	r14947
117	117	static ADDRESS_MAP_START( phc25_mem, AS_PROGRAM, 8, phc25_state )
118	118	ADDRESS_MAP_UNMAP_HIGH
119	119	AM_RANGE(0x0000, 0x5fff) AM_ROM AM_REGION(Z80_TAG, 0)
120		AM_RANGE(0x6000, 0x77ff) AM_RAM AM_BASE(m_video_ram)
	120	AM_RANGE(0x6000, 0x77ff) AM_RAM AM_SHARE("video_ram")
121	121	AM_RANGE(0xc000, 0xffff) AM_RAM
122	122	ADDRESS_MAP_END
123	123

src/mess/drivers/p2000t.c
r14946	r14947
55	55	static ADDRESS_MAP_START( p2000m_mem, AS_PROGRAM, 8, p2000t_state )
56	56	AM_RANGE(0x0000, 0x0fff) AM_ROM
57	57	AM_RANGE(0x1000, 0x4fff) AM_ROM
58		AM_RANGE(0x5000, 0x5fff) AM_RAM AM_BASE(m_p_videoram)
	58	AM_RANGE(0x5000, 0x5fff) AM_RAM AM_SHARE("p_videoram")
59	59	AM_RANGE(0x6000, 0x9fff) AM_RAM
60	60	AM_RANGE(0xa000, 0xffff) AM_NOP
61	61	ADDRESS_MAP_END

src/mess/drivers/pet.c
r14946	r14947
401	401	*************************************/
402	402
403	403	static ADDRESS_MAP_START(pet_mem , AS_PROGRAM, 8, pet_state )
404		AM_RANGE(0x8000, 0x83ff) AM_MIRROR(0x0c00) AM_RAM AM_BASE(m_videoram)
	404	AM_RANGE(0x8000, 0x83ff) AM_MIRROR(0x0c00) AM_RAM AM_SHARE("videoram")
405	405	AM_RANGE(0xa000, 0xe7ff) AM_ROM
406	406	AM_RANGE(0xe810, 0xe813) AM_DEVREADWRITE("pia_0", pia6821_device, read, write)
407	407	AM_RANGE(0xe820, 0xe823) AM_DEVREADWRITE("pia_1", pia6821_device, read, write)
r14946	r14947
411	411	ADDRESS_MAP_END
412	412
413	413	static ADDRESS_MAP_START( pet40_mem , AS_PROGRAM, 8, pet_state )
414		AM_RANGE(0x8000, 0x83ff) AM_MIRROR(0x0c00) AM_RAM AM_BASE(m_videoram)
	414	AM_RANGE(0x8000, 0x83ff) AM_MIRROR(0x0c00) AM_RAM AM_SHARE("videoram")
415	415	AM_RANGE(0xa000, 0xe7ff) AM_ROM
416	416	AM_RANGE(0xe810, 0xe813) AM_DEVREADWRITE("pia_0", pia6821_device, read, write)
417	417	AM_RANGE(0xe820, 0xe823) AM_DEVREADWRITE("pia_1", pia6821_device, read, write)
r14946	r14947
458	458
459	459	*/
460	460	static ADDRESS_MAP_START( superpet_mem , AS_PROGRAM, 8, pet_state )
461		AM_RANGE(0x0000, 0x7fff) AM_RAM AM_SHARE("share1") AM_BASE(m_memory)
462		AM_RANGE(0x8000, 0x87ff) AM_RAM AM_SHARE("share2") AM_BASE(m_videoram)
	461	AM_RANGE(0x0000, 0x7fff) AM_RAM AM_SHARE("share1") AM_SHARE("memory")
	462	AM_RANGE(0x8000, 0x87ff) AM_RAM AM_SHARE("share2") AM_SHARE("videoram")
463	463	AM_RANGE(0xa000, 0xe7ff) AM_ROM
464	464	AM_RANGE(0xe810, 0xe813) AM_DEVREADWRITE("pia_0", pia6821_device, read, write)
465	465	AM_RANGE(0xe820, 0xe823) AM_DEVREADWRITE("pia_1", pia6821_device, read, write)

src/mess/drivers/studio2.c
r14946	r14947
233	233	static ADDRESS_MAP_START( visicom_map, AS_PROGRAM, 8, visicom_state )
234	234	AM_RANGE(0x0000, 0x07ff) AM_ROM
235	235	AM_RANGE(0x1000, 0x10ff) AM_RAM
236		AM_RANGE(0x1100, 0x11ff) AM_RAM AM_BASE(m_color_ram)
237		AM_RANGE(0x1300, 0x13ff) AM_RAM AM_BASE(m_color_ram1)
	236	AM_RANGE(0x1100, 0x11ff) AM_RAM AM_SHARE("color_ram")
	237	AM_RANGE(0x1300, 0x13ff) AM_RAM AM_SHARE("color_ram1")
238	238	ADDRESS_MAP_END
239	239
240	240	static ADDRESS_MAP_START( visicom_io_map, AS_IO, 8, visicom_state )
r14946	r14947
245	245	static ADDRESS_MAP_START( mpt02_map, AS_PROGRAM, 8, mpt02_state )
246	246	AM_RANGE(0x0000, 0x07ff) AM_ROM
247	247	AM_RANGE(0x0800, 0x09ff) AM_RAM
248		AM_RANGE(0x0b00, 0x0b3f) AM_RAM AM_BASE(m_color_ram)
	248	AM_RANGE(0x0b00, 0x0b3f) AM_RAM AM_SHARE("color_ram")
249	249	AM_RANGE(0x0c00, 0x0fff) AM_ROM
250	250	ADDRESS_MAP_END
251	251

src/mess/drivers/osi.c
r14946	r14947
437	437	static ADDRESS_MAP_START( osi600_mem, AS_PROGRAM, 8, sb2m600_state )
438	438	AM_RANGE(0x0000, 0x1fff) AM_RAMBANK("bank1")
439	439	AM_RANGE(0xa000, 0xbfff) AM_ROM
440		AM_RANGE(0xd000, 0xd3ff) AM_RAM AM_BASE(m_video_ram)
	440	AM_RANGE(0xd000, 0xd3ff) AM_RAM AM_SHARE("video_ram")
441	441	AM_RANGE(0xdf00, 0xdf00) AM_READWRITE(keyboard_r, keyboard_w)
442	442	AM_RANGE(0xf000, 0xf000) AM_DEVREADWRITE("acia_0", acia6850_device, status_read, control_write)
443	443	AM_RANGE(0xf001, 0xf001) AM_DEVREADWRITE("acia_0", acia6850_device, data_read, data_write)
r14946	r14947
447	447	static ADDRESS_MAP_START( uk101_mem, AS_PROGRAM, 8, uk101_state )
448	448	AM_RANGE(0x0000, 0x1fff) AM_RAMBANK("bank1")
449	449	AM_RANGE(0xa000, 0xbfff) AM_ROM
450		AM_RANGE(0xd000, 0xd3ff) AM_RAM AM_BASE(m_video_ram)
	450	AM_RANGE(0xd000, 0xd3ff) AM_RAM AM_SHARE("video_ram")
451	451	AM_RANGE(0xdf00, 0xdf00) AM_MIRROR(0x03ff) AM_READ(keyboard_r) AM_WRITE(keyboard_w)
452	452	AM_RANGE(0xf000, 0xf000) AM_MIRROR(0x00fe) AM_DEVREADWRITE("acia_0", acia6850_device, status_read, control_write)
453	453	AM_RANGE(0xf001, 0xf001) AM_MIRROR(0x00fe) AM_DEVREADWRITE("acia_0", acia6850_device, data_read, data_write)
r14946	r14947
460	460	AM_RANGE(0xc704, 0xc707) AM_DEVREADWRITE("pia_1", pia6821_device, read, write)
461	461	AM_RANGE(0xc708, 0xc70b) AM_DEVREADWRITE("pia_2", pia6821_device, read, write)
462	462	AM_RANGE(0xc70c, 0xc70f) AM_DEVREADWRITE("pia_3", pia6821_device, read, write)
463		AM_RANGE(0xd000, 0xd3ff) AM_RAM AM_BASE(m_video_ram)
464		AM_RANGE(0xd400, 0xd7ff) AM_RAM AM_BASE(m_color_ram)
	463	AM_RANGE(0xd000, 0xd3ff) AM_RAM AM_SHARE("video_ram")
	464	AM_RANGE(0xd400, 0xd7ff) AM_RAM AM_SHARE("color_ram")
465	465	AM_RANGE(0xd800, 0xd800) AM_WRITE(ctrl_w)
466	466	AM_RANGE(0xdf00, 0xdf00) AM_READWRITE(keyboard_r, keyboard_w)
467	467	AM_RANGE(0xf000, 0xf000) AM_DEVREADWRITE("acia_0", acia6850_device, status_read, control_write)
r14946	r14947
480	480	AM_RANGE(0xc704, 0xc707) AM_DEVREADWRITE("pia_1", pia6821_device, read, write)
481	481	AM_RANGE(0xc708, 0xc70b) AM_DEVREADWRITE("pia_2", pia6821_device, read, write)
482	482	AM_RANGE(0xc70c, 0xc70f) AM_DEVREADWRITE("pia_3", pia6821_device, read, write)
483		AM_RANGE(0xd000, 0xd3ff) AM_RAM AM_BASE(m_video_ram)
484		AM_RANGE(0xd400, 0xd7ff) AM_RAM AM_BASE(m_color_ram)
	483	AM_RANGE(0xd000, 0xd3ff) AM_RAM AM_SHARE("video_ram")
	484	AM_RANGE(0xd400, 0xd7ff) AM_RAM AM_SHARE("color_ram")
485	485	AM_RANGE(0xd800, 0xd800) AM_WRITE(ctrl_w)
486	486	AM_RANGE(0xdf00, 0xdf00) AM_READWRITE(keyboard_r, keyboard_w)
487	487	AM_RANGE(0xf000, 0xf000) AM_DEVREADWRITE("acia_0", acia6850_device, status_read, control_write)
r14946	r14947
657	657
658	658	/* register for state saving */
659	659	save_item(NAME(m_keylatch));
660		save_pointer(NAME(m_video_ram), OSI600_VIDEORAM_SIZE);
	660	save_pointer(NAME(m_video_ram.target()), OSI600_VIDEORAM_SIZE);
661	661	}
662	662
663	663	void c1p_state::machine_start()
r14946	r14947
684	684	save_item(NAME(m_keylatch));
685	685	save_item(NAME(m_32));
686	686	save_item(NAME(m_coloren));
687		save_pointer(NAME(m_video_ram), OSI600_VIDEORAM_SIZE);
688		save_pointer(NAME(m_color_ram), OSI630_COLORRAM_SIZE);
	687	save_pointer(NAME(m_video_ram.target()), OSI600_VIDEORAM_SIZE);
	688	save_pointer(NAME(m_color_ram.target()), OSI630_COLORRAM_SIZE);
689	689	}
690	690
691	691	void c1pmf_state::machine_start()

src/mess/drivers/orao.c
r14946	r14947
20	20
21	21	/* Address maps */
22	22	static ADDRESS_MAP_START(orao_mem, AS_PROGRAM, 8, orao_state )
23		AM_RANGE( 0x0000, 0x5fff ) AM_RAM AM_BASE(m_memory)
24		AM_RANGE( 0x6000, 0x7fff ) AM_RAM AM_BASE(m_video_ram) // video ram
	23	AM_RANGE( 0x0000, 0x5fff ) AM_RAM AM_SHARE("memory")
	24	AM_RANGE( 0x6000, 0x7fff ) AM_RAM AM_SHARE("video_ram") // video ram
25	25	AM_RANGE( 0x8000, 0x9fff ) AM_READWRITE_LEGACY(orao_io_r, orao_io_w )
26	26	AM_RANGE( 0xa000, 0xafff ) AM_RAM // extension
27	27	AM_RANGE( 0xb000, 0xbfff ) AM_RAM // DOS

src/mess/drivers/galeb.c
r14946	r14947
34	34	AM_RANGE( 0x0000, 0x1fff ) AM_RAM // RAM
35	35	AM_RANGE( 0xbfe0, 0xbfe7 ) AM_READ_LEGACY(galeb_keyboard_r )
36	36	AM_RANGE( 0xbfe0, 0xbfe0 ) AM_DEVWRITE_LEGACY("dac", galeb_dac_data_w )
37		AM_RANGE( 0xb000, 0xb3ff ) AM_RAM AM_BASE(m_video_ram) // video ram
	37	AM_RANGE( 0xb000, 0xb3ff ) AM_RAM AM_SHARE("video_ram") // video ram
38	38	AM_RANGE( 0xc000, 0xc7ff ) AM_ROM // BASIC 01 ROM
39	39	AM_RANGE( 0xc800, 0xcfff ) AM_ROM // BASIC 02 ROM
40	40	AM_RANGE( 0xd000, 0xd7ff ) AM_ROM // BASIC 03 ROM

src/mess/drivers/v1050.c
r14946	r14947
454	454	ADDRESS_MAP_END
455	455
456	456	static ADDRESS_MAP_START( v1050_crt_mem, AS_PROGRAM, 8, v1050_state )
457		AM_RANGE(0x0000, 0x7fff) AM_READWRITE(videoram_r, videoram_w) AM_BASE(m_video_ram)
	457	AM_RANGE(0x0000, 0x7fff) AM_READWRITE(videoram_r, videoram_w) AM_SHARE("video_ram")
458	458	AM_RANGE(0x8000, 0x8000) AM_DEVWRITE(H46505_TAG, mc6845_device, address_w)
459	459	AM_RANGE(0x8001, 0x8001) AM_DEVREADWRITE(H46505_TAG, mc6845_device, register_r, register_w)
460	460	AM_RANGE(0x9000, 0x9003) AM_DEVREADWRITE(I8255A_M6502_TAG, i8255_device, read, write)

src/mess/drivers/cgc7900.c
r14946	r14947
226	226	static ADDRESS_MAP_START( cgc7900_mem, AS_PROGRAM, 16, cgc7900_state )
227	227	ADDRESS_MAP_UNMAP_HIGH
228	228	AM_RANGE(0x000000, 0x000007) AM_ROM AM_REGION(M68000_TAG, 0)
229		AM_RANGE(0x000008, 0x1fffff) AM_RAM AM_BASE(m_chrom_ram)
	229	AM_RANGE(0x000008, 0x1fffff) AM_RAM AM_SHARE("chrom_ram")
230	230	AM_RANGE(0x800000, 0x80ffff) AM_ROM AM_REGION(M68000_TAG, 0)
231	231	AM_RANGE(0xa00000, 0xbfffff) AM_READWRITE(z_mode_r, z_mode_w)
232		AM_RANGE(0xc00000, 0xdfffff) AM_RAM AM_BASE(m_plane_ram)
	232	AM_RANGE(0xc00000, 0xdfffff) AM_RAM AM_SHARE("plane_ram")
233	233	AM_RANGE(0xe00000, 0xe1ffff) AM_WRITE(color_status_w)
234	234	// AM_RANGE(0xe20000, 0xe23fff) Raster Processor
235		AM_RANGE(0xe30000, 0xe303ff) AM_RAM AM_BASE(m_clut_ram)
236		AM_RANGE(0xe38000, 0xe3bfff) AM_RAM AM_BASE(m_overlay_ram)
237		AM_RANGE(0xe40000, 0xe40001) AM_RAM AM_BASE(m_roll_bitmap)
238		AM_RANGE(0xe40002, 0xe40003) AM_RAM AM_BASE(m_pan_x)
239		AM_RANGE(0xe40004, 0xe40005) AM_RAM AM_BASE(m_pan_y)
240		AM_RANGE(0xe40006, 0xe40007) AM_RAM AM_BASE(m_zoom)
	235	AM_RANGE(0xe30000, 0xe303ff) AM_RAM AM_SHARE("clut_ram")
	236	AM_RANGE(0xe38000, 0xe3bfff) AM_RAM AM_SHARE("overlay_ram")
	237	AM_RANGE(0xe40000, 0xe40001) AM_RAM AM_SHARE("roll_bitmap")
	238	AM_RANGE(0xe40002, 0xe40003) AM_RAM AM_SHARE("pan_x")
	239	AM_RANGE(0xe40004, 0xe40005) AM_RAM AM_SHARE("pan_y")
	240	AM_RANGE(0xe40006, 0xe40007) AM_RAM AM_SHARE("zoom")
241	241	AM_RANGE(0xe40008, 0xe40009) AM_RAM
242	242	AM_RANGE(0xe4000a, 0xe4000f) AM_RAM // Raster Processor
243		AM_RANGE(0xe40010, 0xe40011) AM_RAM AM_BASE(m_blink_select)
244		AM_RANGE(0xe40012, 0xe40013) AM_RAM AM_BASE(m_plane_select)
245		AM_RANGE(0xe40014, 0xe40015) AM_RAM AM_BASE(m_plane_switch)
246		AM_RANGE(0xe40016, 0xe40017) AM_RAM AM_BASE(m_color_status_fg)
247		AM_RANGE(0xe40018, 0xe40019) AM_RAM AM_BASE(m_color_status_bg)
248		AM_RANGE(0xe4001a, 0xe4001b) AM_RAM AM_BASE(m_roll_overlay)
	243	AM_RANGE(0xe40010, 0xe40011) AM_RAM AM_SHARE("blink_select")
	244	AM_RANGE(0xe40012, 0xe40013) AM_RAM AM_SHARE("plane_select")
	245	AM_RANGE(0xe40014, 0xe40015) AM_RAM AM_SHARE("plane_switch")
	246	AM_RANGE(0xe40016, 0xe40017) AM_RAM AM_SHARE("color_status_fg")
	247	AM_RANGE(0xe40018, 0xe40019) AM_RAM AM_SHARE("color_status_bg")
	248	AM_RANGE(0xe4001a, 0xe4001b) AM_RAM AM_SHARE("roll_overlay")
249	249	AM_RANGE(0xe4001c, 0xe40fff) AM_RAM
250	250	// AM_RANGE(0xefc440, 0xefc441) HVG Load X
251	251	// AM_RANGE(0xefc442, 0xefc443) HVG Load Y
r14946	r14947
398	398	void cgc7900_state::machine_start()
399	399	{
400	400	/* register for state saving */
401		save_pointer(NAME(m_overlay_ram), 0x4000);
	401	save_pointer(NAME(m_overlay_ram.target()), 0x4000);
402	402	}
403	403
404	404	/*-------------------------------------------------

src/mess/drivers/abc80x.c
r14946	r14947
425	425
426	426	static ADDRESS_MAP_START( abc800c_mem, AS_PROGRAM, 8, abc800_state )
427	427	ADDRESS_MAP_UNMAP_HIGH
428		AM_RANGE(0x0000, 0x3fff) AM_RAM AM_BASE(m_video_ram)
	428	AM_RANGE(0x0000, 0x3fff) AM_RAM AM_SHARE("video_ram")
429	429	AM_RANGE(0x4000, 0x7bff) AM_ROM
430	430	AM_RANGE(0x7c00, 0x7fff) AM_DEVREADWRITE_LEGACY(SAA5052_TAG, saa5050_videoram_r, saa5050_videoram_w)
431	431	AM_RANGE(0x8000, 0xffff) AM_RAM
r14946	r14947
460	460
461	461	static ADDRESS_MAP_START( abc800m_mem, AS_PROGRAM, 8, abc800_state )
462	462	ADDRESS_MAP_UNMAP_HIGH
463		AM_RANGE(0x0000, 0x3fff) AM_RAM AM_BASE(m_video_ram)
	463	AM_RANGE(0x0000, 0x3fff) AM_RAM AM_SHARE("video_ram")
464	464	AM_RANGE(0x4000, 0x77ff) AM_ROM
465		AM_RANGE(0x7800, 0x7fff) AM_RAM AM_BASE(m_char_ram)
	465	AM_RANGE(0x7800, 0x7fff) AM_RAM AM_SHARE("char_ram")
466	466	AM_RANGE(0x8000, 0xffff) AM_RAM
467	467	ADDRESS_MAP_END
468	468
r14946	r14947
486	486	static ADDRESS_MAP_START( abc802_mem, AS_PROGRAM, 8, abc802_state )
487	487	ADDRESS_MAP_UNMAP_HIGH
488	488	AM_RANGE(0x0000, 0x77ff) AM_ROM
489		AM_RANGE(0x7800, 0x7fff) AM_RAM AM_BASE(m_char_ram)
	489	AM_RANGE(0x7800, 0x7fff) AM_RAM AM_SHARE("char_ram")
490	490	AM_RANGE(0x8000, 0xffff) AM_RAM
491	491	ADDRESS_MAP_END
492	492
r14946	r14947
995	995	void abc806_state::machine_start()
996	996	{
997	997	UINT8 *mem = machine().region(Z80_TAG)->base();
998		UINT32 videoram_size = m_ram->size() - (32 * 1024);
	998	//UINT32 videoram_size = m_ram->size() - (32 * 1024);
999	999	int bank;
1000	1000	char bank_name[10];
1001	1001
1002	1002	// setup memory banking
1003		m_video_ram = auto_alloc_array(machine(), UINT8, videoram_size);
	1003	//FIXME
	1004	//m_video_ram = auto_alloc_array(machine(), UINT8, videoram_size);
1004	1005
1005	1006	for (bank = 1; bank <= 16; bank++)
1006	1007	{

src/mess/drivers/bk.c
r14946	r14947
18	18	static ADDRESS_MAP_START(bk0010_mem, AS_PROGRAM, 16, bk_state )
19	19	ADDRESS_MAP_UNMAP_HIGH
20	20	AM_RANGE( 0x0000, 0x3fff ) AM_RAM // RAM
21		AM_RANGE( 0x4000, 0x7fff ) AM_RAM AM_BASE(m_bk0010_video_ram) // Video RAM
	21	AM_RANGE( 0x4000, 0x7fff ) AM_RAM AM_SHARE("bk0010_video_ram") // Video RAM
22	22	AM_RANGE( 0x8000, 0x9fff ) AM_ROM // ROM
23	23	AM_RANGE( 0xa000, 0xbfff ) AM_ROM // ROM
24	24	AM_RANGE( 0xc000, 0xdfff ) AM_ROM // ROM
r14946	r14947
32	32	static ADDRESS_MAP_START(bk0010fd_mem, AS_PROGRAM, 16, bk_state )
33	33	ADDRESS_MAP_UNMAP_HIGH
34	34	AM_RANGE( 0x0000, 0x3fff ) AM_RAM // RAM
35		AM_RANGE( 0x4000, 0x7fff ) AM_RAM AM_BASE(m_bk0010_video_ram) // Video RAM
	35	AM_RANGE( 0x4000, 0x7fff ) AM_RAM AM_SHARE("bk0010_video_ram") // Video RAM
36	36	AM_RANGE( 0x8000, 0x9fff ) AM_ROM // ROM
37	37	AM_RANGE( 0xa000, 0xdfff ) AM_RAM // RAM
38	38	AM_RANGE( 0xe000, 0xfdff ) AM_ROM // ROM

src/mess/drivers/nascom1.c
r14946	r14947
74	74
75	75	static ADDRESS_MAP_START( nascom1_mem, AS_PROGRAM, 8, nascom1_state )
76	76	AM_RANGE(0x0000, 0x07ff) AM_ROM
77		AM_RANGE(0x0800, 0x0bff) AM_RAM AM_BASE(m_videoram)
	77	AM_RANGE(0x0800, 0x0bff) AM_RAM AM_SHARE("videoram")
78	78	AM_RANGE(0x0c00, 0x0fff) AM_RAM
79	79	AM_RANGE(0x1000, 0x13ff) AM_RAM /* 1Kb */
80	80	AM_RANGE(0x1400, 0x4fff) AM_RAM /* 16Kb */

src/mess/drivers/microtan.c
r14946	r14947
54	54
55	55	static ADDRESS_MAP_START( microtan_map, AS_PROGRAM, 8, microtan_state )
56	56	AM_RANGE(0x0000, 0x01ff) AM_RAM
57		AM_RANGE(0x0200, 0x03ff) AM_RAM_WRITE_LEGACY(microtan_videoram_w) AM_BASE(m_videoram)
	57	AM_RANGE(0x0200, 0x03ff) AM_RAM_WRITE_LEGACY(microtan_videoram_w) AM_SHARE("videoram")
58	58	AM_RANGE(0xbc00, 0xbc00) AM_DEVWRITE_LEGACY("ay8910.1", ay8910_address_w)
59	59	AM_RANGE(0xbc01, 0xbc01) AM_DEVREADWRITE_LEGACY("ay8910.1", ay8910_r, ay8910_data_w)
60	60	AM_RANGE(0xbc02, 0xbc02) AM_DEVWRITE_LEGACY("ay8910.2", ay8910_address_w)

src/mess/drivers/sapi1.c
r14946	r14947
52	52	//AM_RANGE(0x2800, 0x2bff) AM_NOP // PORT 1
53	53	//AM_RANGE(0x2c00, 0x2fff) AM_NOP // PORT 2
54	54	//AM_RANGE(0x3000, 0x33ff) AM_NOP // 3214
55		AM_RANGE(0x3800, 0x3fff) AM_RAM AM_BASE(m_sapi_video_ram) // AND-1 (video RAM)
	55	AM_RANGE(0x3800, 0x3fff) AM_RAM AM_SHARE("sapi_video_ram") // AND-1 (video RAM)
56	56	AM_RANGE(0x4000, 0x7fff) AM_RAM // REM-1
57	57	ADDRESS_MAP_END
58	58
r14946	r14947
64	64	ADDRESS_MAP_UNMAP_HIGH
65	65	AM_RANGE(0x0000, 0x07ff) AM_RAM AM_RAMBANK("bank1")
66	66	AM_RANGE(0x0800, 0xe7ff) AM_RAM
67		AM_RANGE(0xe800, 0xefff) AM_RAM AM_BASE(m_sapi_video_ram)
	67	AM_RANGE(0xe800, 0xefff) AM_RAM AM_SHARE("sapi_video_ram")
68	68	AM_RANGE(0xf000, 0xf7ff) AM_RAM
69	69	AM_RANGE(0xf800, 0xfdff) AM_ROM
70	70	AM_RANGE(0xfe00, 0xffff) AM_RAM

src/mess/drivers/poly88.c
r14946	r14947
20	20	AM_RANGE(0x1000, 0x1fff) AM_ROM // System Expansion area
21	21	AM_RANGE(0x2000, 0x3fff) AM_RAM // Minimal user RAM area
22	22	AM_RANGE(0x4000, 0xf7ff) AM_RAM
23		AM_RANGE(0xf800, 0xfbff) AM_RAM AM_BASE(m_video_ram) // Video RAM
	23	AM_RANGE(0xf800, 0xfbff) AM_RAM AM_SHARE("video_ram") // Video RAM
24	24	ADDRESS_MAP_END
25	25
26	26	static ADDRESS_MAP_START( poly88_io, AS_IO, 8, poly88_state )
r14946	r14947
38	38	AM_RANGE(0x0000, 0x03ff) AM_ROM // Monitor ROM
39	39	AM_RANGE(0x0400, 0x0bff) AM_ROM // Disk System ROM
40	40	AM_RANGE(0x0c00, 0x0fff) AM_RAM // System RAM
41		AM_RANGE(0x1800, 0x1bff) AM_RAM AM_BASE(m_video_ram) // Video RAM
	41	AM_RANGE(0x1800, 0x1bff) AM_RAM AM_SHARE("video_ram") // Video RAM
42	42	AM_RANGE(0x2000, 0xffff) AM_RAM // RAM
43	43	ADDRESS_MAP_END
44	44

src/mess/drivers/llc.c
r14946	r14947
20	20	AM_RANGE(0x0000, 0x07ff) AM_ROM // Monitor ROM
21	21	AM_RANGE(0x0800, 0x13ff) AM_ROM // BASIC ROM
22	22	AM_RANGE(0x1400, 0x1bff) AM_RAM // RAM
23		AM_RANGE(0x1c00, 0x1fff) AM_RAM AM_BASE(m_video_ram) // Video RAM
	23	AM_RANGE(0x1c00, 0x1fff) AM_RAM AM_SHARE("video_ram") // Video RAM
24	24	AM_RANGE(0x2000, 0xffff) AM_RAM // RAM
25	25	ADDRESS_MAP_END
26	26

src/mess/drivers/trs80.c
r14946	r14947
139	139	static ADDRESS_MAP_START( trs80_map, AS_PROGRAM, 8, trs80_state )
140	140	AM_RANGE(0x0000, 0x0fff) AM_ROM
141	141	AM_RANGE(0x3800, 0x38ff) AM_READ(trs80_keyboard_r)
142		AM_RANGE(0x3c00, 0x3fff) AM_READWRITE(trs80_videoram_r, trs80_videoram_w) AM_BASE(m_p_videoram)
	142	AM_RANGE(0x3c00, 0x3fff) AM_READWRITE(trs80_videoram_r, trs80_videoram_w) AM_SHARE("p_videoram")
143	143	AM_RANGE(0x4000, 0x7fff) AM_RAM
144	144	ADDRESS_MAP_END
145	145
r14946	r14947
161	161	AM_RANGE(0x37ee, 0x37ee) AM_DEVREADWRITE_LEGACY("wd179x", wd17xx_sector_r, wd17xx_sector_w)
162	162	AM_RANGE(0x37ef, 0x37ef) AM_DEVREADWRITE_LEGACY("wd179x", wd17xx_data_r, wd17xx_data_w)
163	163	AM_RANGE(0x3800, 0x38ff) AM_MIRROR(0x300) AM_READ(trs80_keyboard_r)
164		AM_RANGE(0x3c00, 0x3fff) AM_READWRITE(trs80_videoram_r, trs80_videoram_w) AM_BASE(m_p_videoram)
	164	AM_RANGE(0x3c00, 0x3fff) AM_READWRITE(trs80_videoram_r, trs80_videoram_w) AM_SHARE("p_videoram")
165	165	AM_RANGE(0x4000, 0xffff) AM_RAM
166	166	ADDRESS_MAP_END
167	167
r14946	r14947
263	263	static ADDRESS_MAP_START( meritum_map, AS_PROGRAM, 8, trs80_state )
264	264	AM_RANGE(0x0000, 0x37ff) AM_ROM
265	265	AM_RANGE(0x3800, 0x38ff) AM_MIRROR(0x300) AM_READ(trs80_keyboard_r)
266		AM_RANGE(0x3c00, 0x3fff) AM_READWRITE(trs80_videoram_r, trs80_videoram_w) AM_BASE(m_p_videoram)
	266	AM_RANGE(0x3c00, 0x3fff) AM_READWRITE(trs80_videoram_r, trs80_videoram_w) AM_SHARE("p_videoram")
267	267	AM_RANGE(0x4000, 0xffff) AM_RAM
268	268	ADDRESS_MAP_END
269	269
r14946	r14947
892	892	trs80_state *state = machine.driver_data<trs80_state>();
893	893	state->m_mode = 0;
894	894	state->m_model4 = 2;
895		state->m_p_videoram = machine.region("maincpu")->base()+0x4000;
	895	state->m_p_videoram.set_target(machine.region("maincpu")->base()+0x4000,state->m_p_videoram.bytes());
896	896	}
897	897
898	898	static DRIVER_INIT( trs80m4p )
r14946	r14947
900	900	trs80_state *state = machine.driver_data<trs80_state>();
901	901	state->m_mode = 0;
902	902	state->m_model4 = 4;
903		state->m_p_videoram = machine.region("maincpu")->base()+0x4000;
	903	state->m_p_videoram.set_target(machine.region("maincpu")->base()+0x4000,state->m_p_videoram.bytes());
904	904	}
905	905
906	906	static DRIVER_INIT( lnw80 )
r14946	r14947
909	909	state->m_mode = 0;
910	910	state->m_model4 = 0;
911	911	state->m_p_gfxram = machine.region("gfx2")->base();
912		state->m_p_videoram = machine.region("~~gfx2~~")->base()+0x4000;
	912	state->m_p_videoram.set_target(machine.region("maincpu")->base()+0x4000,state->m_p_videoram.bytes());
913	913	}
914	914
915	915	/* YEAR NAME PARENT COMPAT MACHINE INPUT INIT COMPANY FULLNAME */

src/mess/drivers/jtc.c
r14946	r14947
121	121	AM_RANGE(0x700b, 0x700b) AM_MIRROR(0x0ff0) AM_READ_PORT("Y11")
122	122	AM_RANGE(0x700c, 0x700c) AM_MIRROR(0x0ff0) AM_READ_PORT("Y12")
123	123	AM_RANGE(0xe000, 0xfdff) AM_RAM
124		AM_RANGE(0xfe00, 0xffff) AM_RAM AM_BASE(m_video_ram)
	124	AM_RANGE(0xfe00, 0xffff) AM_RAM AM_SHARE("video_ram")
125	125	ADDRESS_MAP_END
126	126
127	127	static ADDRESS_MAP_START( jtc_es1988_mem, AS_PROGRAM, 8, jtces88_state )
r14946	r14947
141	141	AM_RANGE(0x700b, 0x700b) AM_MIRROR(0x0ff0) AM_READ_PORT("Y11")
142	142	AM_RANGE(0x700c, 0x700c) AM_MIRROR(0x0ff0) AM_READ_PORT("Y12")
143	143	AM_RANGE(0xe000, 0xfdff) AM_RAM
144		AM_RANGE(0xfe00, 0xffff) AM_RAM AM_BASE(m_video_ram)
	144	AM_RANGE(0xfe00, 0xffff) AM_RAM AM_SHARE("video_ram")
145	145	ADDRESS_MAP_END
146	146
147	147	static ADDRESS_MAP_START( jtc_es23_mem, AS_PROGRAM, 8, jtces23_state )
r14946	r14947
164	164	AM_RANGE(0x700e, 0x700e) AM_MIRROR(0x0ff0) AM_READ_PORT("Y14")
165	165	AM_RANGE(0x700f, 0x700f) AM_MIRROR(0x0ff0) AM_READ_PORT("Y15")
166	166	AM_RANGE(0xe000, 0xfdff) AM_RAM
167		AM_RANGE(0xf800, 0xffff) AM_RAM AM_BASE(m_video_ram)
	167	AM_RANGE(0xf800, 0xffff) AM_RAM AM_SHARE("video_ram")
168	168	ADDRESS_MAP_END
169	169
170	170	static ADDRESS_MAP_START( jtc_es40_mem, AS_PROGRAM, 8, jtces40_state )
r14946	r14947
542	542	void jtces40_state::video_start()
543	543	{
544	544	/* allocate memory */
545		m_video_ram = auto_alloc_array(machine(), UINT8, JTC_ES40_VIDEORAM_SIZE);
	545	//m_video_ram = auto_alloc_array(machine(), UINT8, JTC_ES40_VIDEORAM_SIZE);
546	546	m_color_ram_r = auto_alloc_array(machine(), UINT8, JTC_ES40_VIDEORAM_SIZE);
547	547	m_color_ram_g = auto_alloc_array(machine(), UINT8, JTC_ES40_VIDEORAM_SIZE);
548	548	m_color_ram_b = auto_alloc_array(machine(), UINT8, JTC_ES40_VIDEORAM_SIZE);
549	549
550	550	/* register for state saving */
551	551	save_item(NAME(m_video_bank));
552		save_pointer(NAME(m_video_ram), JTC_ES40_VIDEORAM_SIZE);
	552	save_pointer(NAME(m_video_ram.target()), JTC_ES40_VIDEORAM_SIZE);
553	553	save_pointer(NAME(m_color_ram_r), JTC_ES40_VIDEORAM_SIZE);
554	554	save_pointer(NAME(m_color_ram_g), JTC_ES40_VIDEORAM_SIZE);
555	555	save_pointer(NAME(m_color_ram_b), JTC_ES40_VIDEORAM_SIZE);

src/mess/drivers/tdv2324.c
r14946	r14947
162	162	AM_RANGE(0x0000, 0x3fff) AM_ROM AM_REGION(P8085AH_1_TAG, 0)
163	163	AM_RANGE(0x4000, 0x47ff) AM_RAM
164	164	AM_RANGE(0x5000, 0x53ff) AM_RAM // EAROM
165		AM_RANGE(0x6000, 0x7fff) AM_RAM AM_BASE(m_video_ram)
	165	AM_RANGE(0x6000, 0x7fff) AM_RAM AM_SHARE("video_ram")
166	166	ADDRESS_MAP_END
167	167
168	168

src/mess/drivers/tandy2k.c
r14946	r14947
260	260	static ADDRESS_MAP_START( tandy2k_mem, AS_PROGRAM, 16, tandy2k_state )
261	261	ADDRESS_MAP_UNMAP_HIGH
262	262	// AM_RANGE(0x00000, 0xdffff) AM_RAM
263		AM_RANGE(0xe0000, 0xf7fff) AM_RAM AM_BASE(m_hires_ram)
264		AM_RANGE(0xf8000, 0xfbfff) AM_RAM AM_BASE(m_char_ram)
	263	AM_RANGE(0xe0000, 0xf7fff) AM_RAM AM_SHARE("hires_ram")
	264	AM_RANGE(0xf8000, 0xfbfff) AM_RAM AM_SHARE("char_ram")
265	265	AM_RANGE(0xfc000, 0xfdfff) AM_MIRROR(0x2000) AM_ROM AM_REGION(I80186_TAG, 0)
266	266	ADDRESS_MAP_END
267	267

src/mess/drivers/huebler.c
r14946	r14947
94	94	static ADDRESS_MAP_START( amu880_mem, AS_PROGRAM, 8, amu880_state )
95	95	ADDRESS_MAP_UNMAP_HIGH
96	96	AM_RANGE(0x0000, 0xe7ff) AM_RAM
97		AM_RANGE(0xe800, 0xefff) AM_RAM AM_BASE(m_video_ram)
	97	AM_RANGE(0xe800, 0xefff) AM_RAM AM_SHARE("video_ram")
98	98	AM_RANGE(0xf000, 0xfbff) AM_ROM
99	99	AM_RANGE(0xfc00, 0xffff) AM_RAM
100	100	ADDRESS_MAP_END

src/mess/drivers/fm7.c
r14946	r14947
1481	1481	AM_RANGE(0x0000,0xbfff) AM_READWRITE_LEGACY(fm7_vram_r,fm7_vram_w) // VRAM
1482	1482	AM_RANGE(0xc000,0xcfff) AM_RAM // Console RAM
1483	1483	AM_RANGE(0xd000,0xd37f) AM_RAM // Work RAM
1484		AM_RANGE(0xd380,0xd3ff) AM_RAM AM_BASE(m_shared_ram)
	1484	AM_RANGE(0xd380,0xd3ff) AM_RAM AM_SHARE("shared_ram")
1485	1485	// I/O space (D400-D4FF)
1486	1486	AM_RANGE(0xd400,0xd401) AM_READ_LEGACY(fm7_sub_keyboard_r)
1487	1487	AM_RANGE(0xd402,0xd402) AM_READ_LEGACY(fm7_cancel_ack)
r14946	r14947
1539	1539	AM_RANGE(0xfd40,0xfd7f) AM_READ_LEGACY(fm7_unknown_r)
1540	1540	AM_RANGE(0xfd80,0xfd93) AM_READWRITE_LEGACY(fm7_mmr_r,fm7_mmr_w)
1541	1541	AM_RANGE(0xfd94,0xfdff) AM_READ_LEGACY(fm7_unknown_r)
1542		AM_RANGE(0xfe00,0xffdf) AM_RAM_WRITE_LEGACY(fm77av_bootram_w) AM_BASE(m_boot_ram)
	1542	AM_RANGE(0xfe00,0xffdf) AM_RAM_WRITE_LEGACY(fm77av_bootram_w) AM_SHARE("boot_ram")
1543	1543	AM_RANGE(0xffe0,0xffef) AM_RAM
1544	1544	AM_RANGE(0xfff0,0xffff) AM_READWRITE_LEGACY(vector_r,vector_w)
1545	1545	ADDRESS_MAP_END
r14946	r14947
1549	1549	AM_RANGE(0x0000,0x7fff) AM_READWRITE_LEGACY(fm7_vram_r,fm7_vram_w) // VRAM
1550	1550	AM_RANGE(0x8000,0x8fff) AM_RAM // Console RAM(?)
1551	1551	AM_RANGE(0x9000,0x9f7f) AM_RAM // Work RAM(?)
1552		AM_RANGE(0x9f80,0x9fff) AM_RAM AM_BASE(m_shared_ram)
	1552	AM_RANGE(0x9f80,0x9fff) AM_RAM AM_SHARE("shared_ram")
1553	1553	AM_RANGE(0xafe4,0xafe4) AM_READWRITE_LEGACY(fm7_sub_busyflag_r,fm7_sub_busyflag_w)
1554	1554	AM_RANGE(0xafe6,0xafe6) AM_READWRITE_LEGACY(fm77av_video_flags_r,fm77av_video_flags_w)
1555	1555	AM_RANGE(0xc000,0xffff) AM_ROM // sybsystem ROM
r14946	r14947
1655	1655	AM_RANGE(0xfd80,0xfd93) AM_READWRITE_LEGACY(fm7_mmr_r,fm7_mmr_w)
1656	1656	AM_RANGE(0xfd94,0xfdff) AM_READ_LEGACY(fm7_unknown_r)
1657	1657	// Boot ROM (RAM on FM77AV and later)
1658		AM_RANGE(0xfe00,0xffdf) AM_RAM_WRITE_LEGACY(fm77av_bootram_w) AM_BASE(m_boot_ram)
	1658	AM_RANGE(0xfe00,0xffdf) AM_RAM_WRITE_LEGACY(fm77av_bootram_w) AM_SHARE("boot_ram")
1659	1659	AM_RANGE(0xffe0,0xffef) AM_RAM
1660	1660	AM_RANGE(0xfff0,0xffff) AM_READWRITE_LEGACY(vector_r,vector_w)
1661	1661	ADDRESS_MAP_END
r14946	r14947
1664	1664	AM_RANGE(0x0000,0xbfff) AM_READWRITE_LEGACY(fm7_vram_r,fm7_vram_w) // VRAM
1665	1665	AM_RANGE(0xc000,0xcfff) AM_RAM AM_REGION("maincpu",0x1c000) // Console RAM
1666	1666	AM_RANGE(0xd000,0xd37f) AM_RAM AM_REGION("maincpu",0x1d000) // Work RAM
1667		AM_RANGE(0xd380,0xd3ff) AM_RAM AM_BASE(m_shared_ram)
	1667	AM_RANGE(0xd380,0xd3ff) AM_RAM AM_SHARE("shared_ram")
1668	1668	// I/O space (D400-D4FF)
1669	1669	AM_RANGE(0xd400,0xd401) AM_READ_LEGACY(fm7_sub_keyboard_r)
1670	1670	AM_RANGE(0xd402,0xd402) AM_READ_LEGACY(fm7_cancel_ack)

src/mess/drivers/compis.c
r14946	r14947
358	358
359	359	static ADDRESS_MAP_START( upd7220_map, AS_0, 8, compis_state )
360	360	ADDRESS_MAP_GLOBAL_MASK(0x1ffff)
361		AM_RANGE(0x00000, 0x1ffff) AM_RAM AM_BASE(m_video_ram)
	361	AM_RANGE(0x00000, 0x1ffff) AM_RAM AM_SHARE("video_ram")
362	362	ADDRESS_MAP_END
363	363
364	364	static MACHINE_CONFIG_START( compis, compis_state )

src/mess/drivers/z80ne.c
r14946	r14947
129	129	AM_RANGE( 0x0400, 0x7fff ) AM_RAM
130	130	AM_RANGE( 0x8000, 0x83ff ) AM_ROMBANK("bank2")
131	131	AM_RANGE( 0x8400, 0xebff ) AM_RAM
132		AM_RANGE( 0xec00, 0xedff ) AM_RAM AM_BASE(m_videoram) /* (6847) */
	132	AM_RANGE( 0xec00, 0xedff ) AM_RAM AM_SHARE("videoram") /* (6847) */
133	133	AM_RANGE( 0xee00, 0xffff ) AM_RAM
134	134	ADDRESS_MAP_END
135	135
136	136	static ADDRESS_MAP_START( z80netb_mem, AS_PROGRAM, 8, z80ne_state )
137	137	AM_RANGE( 0x0000, 0x3fff ) AM_ROM
138	138	AM_RANGE( 0x4000, 0xebff ) AM_RAM
139		AM_RANGE( 0xec00, 0xedff ) AM_RAM AM_BASE(m_videoram) /* (6847) */
	139	AM_RANGE( 0xec00, 0xedff ) AM_RAM AM_SHARE("videoram") /* (6847) */
140	140	AM_RANGE( 0xee00, 0xffff ) AM_RAM
141	141	ADDRESS_MAP_END
142	142
r14946	r14947
163	163	AM_RANGE( 0x8000, 0x83ff ) AM_RAMBANK("bank3")
164	164	AM_RANGE( 0x8400, 0xdfff ) AM_RAM
165	165	AM_RANGE( 0xe000, 0xebff ) AM_READNOP AM_WRITENOP
166		AM_RANGE( 0xec00, 0xedff ) AM_RAM AM_BASE(m_videoram) /* (6847) */
	166	AM_RANGE( 0xec00, 0xedff ) AM_RAM AM_SHARE("videoram") /* (6847) */
167	167	AM_RANGE( 0xee00, 0xefff ) AM_READNOP AM_WRITENOP
168	168	AM_RANGE( 0xf000, 0xf3ff ) AM_RAMBANK("bank4")
169	169	AM_RANGE( 0xf400, 0xffff ) AM_READNOP AM_WRITENOP

src/mess/drivers/mac.c
r14946	r14947
570	570	AM_RANGE(0xf60000, 0xf6ffff) AM_READWRITE(mac_iwm_r, mac_iwm_w)
571	571	AM_RANGE(0xf70000, 0xf7ffff) AM_READWRITE(mac_via_r, mac_via_w)
572	572	AM_RANGE(0xf90000, 0xf9ffff) AM_READWRITE(macplus_scsi_r, macplus_scsi_w)
573		AM_RANGE(0xfa8000, 0xfaffff) AM_RAM AM_BASE(m_vram) // VRAM
	573	AM_RANGE(0xfa8000, 0xfaffff) AM_RAM AM_SHARE("vram") // VRAM
574	574	AM_RANGE(0xfb0000, 0xfbffff) AM_DEVREADWRITE8("asc", asc_device, read, write, 0xffff)
575	575	AM_RANGE(0xfc0000, 0xfcffff) AM_READ(mac_config_r)
576	576	AM_RANGE(0xfd0000, 0xfdffff) AM_READWRITE(mac_scc_r, mac_scc_2_w)
r14946	r14947
591	591	AM_RANGE(0xf16000, 0xf17fff) AM_READWRITE16(mac_iwm_r, mac_iwm_w, 0xffffffff)
592	592	AM_RANGE(0xf24000, 0xf24003) AM_READWRITE(rbv_ramdac_r, ariel_ramdac_w)
593	593	AM_RANGE(0xf26000, 0xf27fff) AM_READWRITE8(mac_rbv_r, mac_rbv_w, 0xffffffff) // VIA2 (V8)
594		AM_RANGE(0xf40000, 0xfbffff) AM_RAM AM_BASE(m_vram)
	594	AM_RANGE(0xf40000, 0xfbffff) AM_RAM AM_SHARE("vram")
595	595	ADDRESS_MAP_END
596	596
597	597	static ADDRESS_MAP_START(maclc3_map, AS_PROGRAM, 32, mac_state )
r14946	r14947
610	610
611	611	AM_RANGE(0x5ffffffc, 0x5fffffff) AM_READ(mac_read_id)
612	612
613		AM_RANGE(0x60000000, 0x600fffff) AM_RAM AM_MIRROR(0x0ff00000) AM_BASE(m_vram)
	613	AM_RANGE(0x60000000, 0x600fffff) AM_RAM AM_MIRROR(0x0ff00000) AM_SHARE("vram")
614	614	ADDRESS_MAP_END
615	615
616	616	static ADDRESS_MAP_START(macii_map, AS_PROGRAM, 32, mac_state )
r14946	r14947
657	657	AM_RANGE(0x50016000, 0x50017fff) AM_READWRITE16(mac_iwm_r, mac_iwm_w, 0xffffffff) AM_MIRROR(0x00f00000)
658	658	AM_RANGE(0x50040000, 0x50041fff) AM_READWRITE16(mac_via_r, mac_via_w, 0xffffffff) AM_MIRROR(0x00f00000) // mirror
659	659
660		AM_RANGE(0xfe000000, 0xfe00ffff) AM_RAM AM_BASE(m_vram)
	660	AM_RANGE(0xfe000000, 0xfe00ffff) AM_RAM AM_SHARE("vram")
661	661	AM_RANGE(0xfeffe000, 0xfeffffff) AM_ROM AM_REGION("se30vrom", 0x0)
662	662	ADDRESS_MAP_END
663	663
r14946	r14947
692	692	AM_RANGE(0x50016000, 0x50017fff) AM_READWRITE16(mac_iwm_r, mac_iwm_w, 0xffffffff) AM_MIRROR(0x01f00000)
693	693	AM_RANGE(0x50024000, 0x50027fff) AM_READ(buserror_r) AM_MIRROR(0x01f00000) // bus error here to make sure we aren't mistaken for another decoder
694	694
695		AM_RANGE(0xfee08000, 0xfeffffff) AM_RAM AM_BASE(m_vram)
	695	AM_RANGE(0xfee08000, 0xfeffffff) AM_RAM AM_SHARE("vram")
696	696	ADDRESS_MAP_END
697	697
698	698	static ADDRESS_MAP_START(macpb160_map, AS_PROGRAM, 32, mac_state )
r14946	r14947
709	709	AM_RANGE(0x50f20000, 0x50f21fff) AM_READWRITE8(mac_gsc_r, mac_gsc_w, 0xffffffff)
710	710	AM_RANGE(0x50f24000, 0x50f27fff) AM_READ(buserror_r) // bus error here to make sure we aren't mistaken for another decoder
711	711
712		AM_RANGE(0x60000000, 0x6001ffff) AM_RAM AM_BASE(m_vram) AM_MIRROR(0x0ffe0000)
	712	AM_RANGE(0x60000000, 0x6001ffff) AM_RAM AM_SHARE("vram") AM_MIRROR(0x0ffe0000)
713	713	ADDRESS_MAP_END
714	714
715	715	static ADDRESS_MAP_START(macpb165c_map, AS_PROGRAM, 32, mac_state )
r14946	r14947
727	727	AM_RANGE(0x50f24000, 0x50f27fff) AM_READ(buserror_r) // bus error here to make sure we aren't mistaken for another decoder
728	728
729	729	// on-board color video on 165c/180c
730		AM_RANGE(0xfc000000, 0xfc07ffff) AM_RAM AM_BASE(m_vram) AM_MIRROR(0x00380000) // 512k of VRAM
	730	AM_RANGE(0xfc000000, 0xfc07ffff) AM_RAM AM_SHARE("vram") AM_MIRROR(0x00380000) // 512k of VRAM
731	731	AM_RANGE(0xfc400000, 0xfcefffff) AM_READWRITE(macwd_r, macwd_w)
732	732	// fc4003c8 = DAC control, fc4003c9 = DAC data
733	733	// fc4003da bit 3 is VBL
r14946	r14947
750	750
751	751	AM_RANGE(0x5ffffffc, 0x5fffffff) AM_READ(mac_read_id)
752	752
753		AM_RANGE(0x60000000, 0x6001ffff) AM_RAM AM_BASE(m_vram) AM_MIRROR(0x0ffe0000)
	753	AM_RANGE(0x60000000, 0x6001ffff) AM_RAM AM_SHARE("vram") AM_MIRROR(0x0ffe0000)
754	754	ADDRESS_MAP_END
755	755	#endif
756	756	static ADDRESS_MAP_START(quadra700_map, AS_PROGRAM, 32, mac_state )
r14946	r14947
768	768
769	769	AM_RANGE(0x50040000, 0x50041fff) AM_READWRITE16(mac_via_r, mac_via_w, 0xffffffff) AM_MIRROR(0x00fc0000)
770	770	// f9800000 = VDAC / DAFB
771		AM_RANGE(0xf9000000, 0xf91fffff) AM_RAM AM_BASE(m_vram)
	771	AM_RANGE(0xf9000000, 0xf91fffff) AM_RAM AM_SHARE("vram")
772	772	AM_RANGE(0xf9800000, 0xf98001ff) AM_READWRITE(dafb_r, dafb_w)
773	773	AM_RANGE(0xf9800200, 0xf980023f) AM_READWRITE(dafb_dac_r, dafb_dac_w)
774	774	ADDRESS_MAP_END

src/mess/drivers/bw12.c
r14946	r14947
193	193	static ADDRESS_MAP_START( bw12_mem, AS_PROGRAM, 8, bw12_state )
194	194	AM_RANGE(0x0000, 0x7fff) AM_RAMBANK("bank1")
195	195	AM_RANGE(0x8000, 0xf7ff) AM_RAM
196		AM_RANGE(0xf800, 0xffff) AM_RAM AM_BASE(m_video_ram)
	196	AM_RANGE(0xf800, 0xffff) AM_RAM AM_SHARE("video_ram")
197	197	ADDRESS_MAP_END
198	198
199	199	static ADDRESS_MAP_START( bw12_io, AS_IO, 8, bw12_state )

src/mess/drivers/concept.c
r14946	r14947
44	44	AM_RANGE(0x020000, 0x021fff) AM_ROM /* macsbugs ROM (optional) */
45	45	AM_RANGE(0x030000, 0x03ffff) AM_READWRITE_LEGACY(concept_io_r,concept_io_w) /* I/O space */
46	46
47		AM_RANGE(0x080000, 0x0fffff) AM_RAM AM_BASE(m_videoram)/* AM_RAMBANK(2) / / DRAM */
	47	AM_RANGE(0x080000, 0x0fffff) AM_RAM AM_SHARE("videoram")/* AM_RAMBANK(2) / / DRAM */
48	48	ADDRESS_MAP_END
49	49
50	50	/* init with simple, fixed, B/W palette */

src/mess/drivers/lisa.c
r14946	r14947
50	50
51	51	static ADDRESS_MAP_START(lisa_fdc_map, AS_PROGRAM, 8, lisa_state )
52	52	ADDRESS_MAP_GLOBAL_MASK(0x1fff) // only 8k of address space
53		AM_RANGE(0x0000, 0x03ff) AM_RAM AM_BASE(m_fdc_ram) /* RAM (shared with 68000) */
	53	AM_RANGE(0x0000, 0x03ff) AM_RAM AM_SHARE("fdc_ram") /* RAM (shared with 68000) */
54	54	AM_RANGE(0x0400, 0x07ff) AM_READWRITE_LEGACY(lisa_fdc_io_r, lisa_fdc_io_w) /* disk controller (IWM and TTL logic) */
55	55	AM_RANGE(0x0800, 0x0fff) AM_NOP
56		AM_RANGE(0x1000, 0x1fff) AM_ROM AM_BASE(m_fdc_rom) /* ROM */
	56	AM_RANGE(0x1000, 0x1fff) AM_ROM AM_SHARE("fdc_rom") /* ROM */
57	57	AM_RANGE(0x2000, 0xffff) AM_READWRITE_LEGACY(lisa_fdc_r, lisa_fdc_w) /* handler for wrap-around */
58	58	ADDRESS_MAP_END
59	59
60	60	static ADDRESS_MAP_START(lisa210_fdc_map, AS_PROGRAM, 8, lisa_state )
61	61	ADDRESS_MAP_GLOBAL_MASK(0x1fff) // only 8k of address space
62		AM_RANGE(0x0000, 0x03ff) AM_RAM AM_BASE(m_fdc_ram) /* RAM (shared with 68000) */
	62	AM_RANGE(0x0000, 0x03ff) AM_RAM AM_SHARE("fdc_ram") /* RAM (shared with 68000) */
63	63	AM_RANGE(0x0400, 0x07ff) AM_NOP /* nothing, or RAM wrap-around ??? */
64	64	AM_RANGE(0x0800, 0x0bff) AM_READWRITE_LEGACY(lisa_fdc_io_r, lisa_fdc_io_w) /* disk controller (IWM and TTL logic) */
65	65	AM_RANGE(0x0c00, 0x0fff) AM_NOP /* nothing, or IO port wrap-around ??? */
66		AM_RANGE(0x1000, 0x1fff) AM_ROM AM_BASE(m_fdc_rom) /* ROM */
	66	AM_RANGE(0x1000, 0x1fff) AM_ROM AM_SHARE("fdc_rom") /* ROM */
67	67	AM_RANGE(0x2000, 0xffff) AM_READWRITE_LEGACY(lisa_fdc_r, lisa_fdc_w) /* handler for wrap-around */
68	68	ADDRESS_MAP_END
69	69

src/mess/drivers/sym1.c
r14946	r14947
34	34
35	35	static ADDRESS_MAP_START( sym1_map, AS_PROGRAM, 8, sym1_state )
36	36	AM_RANGE(0x0000, 0x03ff) AM_RAM /* U12/U13 RAM */
37		AM_RANGE(0x0400, 0x07ff) AM_RAMBANK("bank2") AM_BASE(m_ram_1k)
38		AM_RANGE(0x0800, 0x0bff) AM_RAMBANK("bank3") AM_BASE(m_ram_2k)
39		AM_RANGE(0x0c00, 0x0fff) AM_RAMBANK("bank4") AM_BASE(m_ram_3k)
40		AM_RANGE(0x8000, 0x8fff) AM_ROM AM_BASE(m_monitor) /* U20 Monitor ROM */
	37	AM_RANGE(0x0400, 0x07ff) AM_RAMBANK("bank2") AM_SHARE("ram_1k")
	38	AM_RANGE(0x0800, 0x0bff) AM_RAMBANK("bank3") AM_SHARE("ram_2k")
	39	AM_RANGE(0x0c00, 0x0fff) AM_RAMBANK("bank4") AM_SHARE("ram_3k")
	40	AM_RANGE(0x8000, 0x8fff) AM_ROM AM_SHARE("monitor") /* U20 Monitor ROM */
41	41	AM_RANGE(0xa000, 0xa00f) AM_DEVREADWRITE("via6522_0", via6522_device, read, write) /* U25 VIA #1 */
42	42	AM_RANGE(0xa400, 0xa40f) AM_DEVREADWRITE_LEGACY("riot", riot6532_r, riot6532_w) /* U27 RIOT */
43		AM_RANGE(0xa600, 0xa67f) AM_RAMBANK("bank5") AM_BASE(m_riot_ram) /* U27 RIOT RAM */
	43	AM_RANGE(0xa600, 0xa67f) AM_RAMBANK("bank5") AM_SHARE("riot_ram") /* U27 RIOT RAM */
44	44	AM_RANGE(0xa800, 0xa80f) AM_DEVREADWRITE("via6522_1", via6522_device, read, write) /* U28 VIA #2 */
45	45	AM_RANGE(0xac00, 0xac0f) AM_DEVREADWRITE("via6522_2", via6522_device, read, write) /* U29 VIA #3 */
46	46	AM_RANGE(0xb000, 0xefff) AM_ROM

src/mess/drivers/lynx.c
r14946	r14947
16	16	static QUICKLOAD_LOAD( lynx );
17	17
18	18	static ADDRESS_MAP_START( lynx_mem , AS_PROGRAM, 8, lynx_state )
19		AM_RANGE(0x0000, 0xfbff) AM_RAM AM_BASE(m_mem_0000)
20		AM_RANGE(0xfc00, 0xfcff) AM_RAM AM_BASE(m_mem_fc00)
21		AM_RANGE(0xfd00, 0xfdff) AM_RAM AM_BASE(m_mem_fd00)
22		AM_RANGE(0xfe00, 0xfff7) AM_READ_BANK("bank3") AM_WRITEONLY AM_BASE_SIZE(m_mem_fe00, m_mem_fe00_size)
	19	AM_RANGE(0x0000, 0xfbff) AM_RAM AM_SHARE("mem_0000")
	20	AM_RANGE(0xfc00, 0xfcff) AM_RAM AM_SHARE("mem_fc00")
	21	AM_RANGE(0xfd00, 0xfdff) AM_RAM AM_SHARE("mem_fd00")
	22	AM_RANGE(0xfe00, 0xfff7) AM_READ_BANK("bank3") AM_WRITEONLY AM_SHARE("mem_fe00")
23	23	AM_RANGE(0xfff8, 0xfff8) AM_RAM
24	24	AM_RANGE(0xfff9, 0xfff9) AM_READWRITE_LEGACY(lynx_memory_config_r, lynx_memory_config_w)
25		AM_RANGE(0xfffa, 0xffff) AM_READ_BANK("bank4") AM_WRITEONLY AM_BASE(m_mem_fffa)
	25	AM_RANGE(0xfffa, 0xffff) AM_READ_BANK("bank4") AM_WRITEONLY AM_SHARE("mem_fffa")
26	26	ADDRESS_MAP_END
27	27
28	28	static INPUT_PORTS_START( lynx )

src/mess/drivers/aquarius.c
r14946	r14947
232	232
233	233	static ADDRESS_MAP_START( aquarius_mem, AS_PROGRAM, 8, aquarius_state )
234	234	AM_RANGE(0x0000, 0x1fff) AM_ROM
235		AM_RANGE(0x3000, 0x33ff) AM_RAM_WRITE_LEGACY(aquarius_videoram_w) AM_BASE(m_videoram)
236		AM_RANGE(0x3400, 0x37ff) AM_RAM_WRITE_LEGACY(aquarius_colorram_w) AM_BASE(m_colorram)
	235	AM_RANGE(0x3000, 0x33ff) AM_RAM_WRITE_LEGACY(aquarius_videoram_w) AM_SHARE("videoram")
	236	AM_RANGE(0x3400, 0x37ff) AM_RAM_WRITE_LEGACY(aquarius_colorram_w) AM_SHARE("colorram")
237	237	AM_RANGE(0x3800, 0x3fff) AM_RAM
238	238	AM_RANGE(0x4000, 0xbfff) AM_NOP /* expansion ram */
239	239	AM_RANGE(0xc000, 0xffff) AM_READ_LEGACY(cartridge_r)

src/mess/drivers/x68k.c
r14946	r14947
1963	1963	static ADDRESS_MAP_START(x68k_map, AS_PROGRAM, 16, x68k_state )
1964	1964	// AM_RANGE(0x000000, 0xbfffff) AM_RAMBANK(1)
1965	1965	AM_RANGE(0xbffffc, 0xbfffff) AM_READWRITE_LEGACY(x68k_rom0_r, x68k_rom0_w)
1966		// AM_RANGE(0xc00000, 0xdfffff) AM_READWRITE_LEGACY(x68k_gvram_r, x68k_gvram_w) AM_BASE(m_gvram)
1967		// AM_RANGE(0xe00000, 0xe7ffff) AM_READWRITE_LEGACY(x68k_tvram_r, x68k_tvram_w) AM_BASE(m_tvram)
	1966	// AM_RANGE(0xc00000, 0xdfffff) AM_READWRITE_LEGACY(x68k_gvram_r, x68k_gvram_w) AM_SHARE("gvram")
	1967	// AM_RANGE(0xe00000, 0xe7ffff) AM_READWRITE_LEGACY(x68k_tvram_r, x68k_tvram_w) AM_SHARE("tvram")
1968	1968	AM_RANGE(0xc00000, 0xdfffff) AM_RAMBANK("bank2")
1969	1969	AM_RANGE(0xe00000, 0xe7ffff) AM_RAMBANK("bank3")
1970	1970	AM_RANGE(0xe80000, 0xe81fff) AM_READWRITE_LEGACY(x68k_crtc_r, x68k_crtc_w)
r14946	r14947
2000	2000	static ADDRESS_MAP_START(x68kxvi_map, AS_PROGRAM, 16, x68k_state )
2001	2001	// AM_RANGE(0x000000, 0xbfffff) AM_RAMBANK(1)
2002	2002	AM_RANGE(0xbffffc, 0xbfffff) AM_READWRITE_LEGACY(x68k_rom0_r, x68k_rom0_w)
2003		// AM_RANGE(0xc00000, 0xdfffff) AM_READWRITE_LEGACY(x68k_gvram_r, x68k_gvram_w) AM_BASE(m_gvram)
2004		// AM_RANGE(0xe00000, 0xe7ffff) AM_READWRITE_LEGACY(x68k_tvram_r, x68k_tvram_w) AM_BASE(m_tvram)
	2003	// AM_RANGE(0xc00000, 0xdfffff) AM_READWRITE_LEGACY(x68k_gvram_r, x68k_gvram_w) AM_SHARE("gvram")
	2004	// AM_RANGE(0xe00000, 0xe7ffff) AM_READWRITE_LEGACY(x68k_tvram_r, x68k_tvram_w) AM_SHARE("tvram")
2005	2005	AM_RANGE(0xc00000, 0xdfffff) AM_RAMBANK("bank2")
2006	2006	AM_RANGE(0xe00000, 0xe7ffff) AM_RAMBANK("bank3")
2007	2007	AM_RANGE(0xe80000, 0xe81fff) AM_READWRITE_LEGACY(x68k_crtc_r, x68k_crtc_w)
r14946	r14947
2039	2039	ADDRESS_MAP_GLOBAL_MASK(0x00ffffff) // Still only has 24-bit address space
2040	2040	// AM_RANGE(0x000000, 0xbfffff) AM_RAMBANK(1)
2041	2041	AM_RANGE(0xbffffc, 0xbfffff) AM_READWRITE16_LEGACY(x68k_rom0_r, x68k_rom0_w,0xffffffff)
2042		// AM_RANGE(0xc00000, 0xdfffff) AM_READWRITE_LEGACY(x68k_gvram_r, x68k_gvram_w) AM_BASE(m_gvram)
2043		// AM_RANGE(0xe00000, 0xe7ffff) AM_READWRITE_LEGACY(x68k_tvram_r, x68k_tvram_w) AM_BASE(m_tvram)
	2042	// AM_RANGE(0xc00000, 0xdfffff) AM_READWRITE_LEGACY(x68k_gvram_r, x68k_gvram_w) AM_SHARE("gvram")
	2043	// AM_RANGE(0xe00000, 0xe7ffff) AM_READWRITE_LEGACY(x68k_tvram_r, x68k_tvram_w) AM_SHARE("tvram")
2044	2044	AM_RANGE(0xc00000, 0xdfffff) AM_RAMBANK("bank2")
2045	2045	AM_RANGE(0xe00000, 0xe7ffff) AM_RAMBANK("bank3")
2046	2046	AM_RANGE(0xe80000, 0xe81fff) AM_READWRITE16_LEGACY(x68k_crtc_r, x68k_crtc_w,0xffffffff)
r14946	r14947
2702	2702	x68k_state *state = machine.driver_data<x68k_state>();
2703	2703	unsigned char* rom = machine.region("maincpu")->base();
2704	2704	unsigned char* user2 = machine.region("user2")->base();
2705		state->m_gvram = auto_alloc_array(machine, UINT16, 0x080000/sizeof(UINT16));
2706		state->m_tvram = auto_alloc_array(machine, UINT16, 0x080000/sizeof(UINT16));
	2705	//FIXME
	2706	//state->m_gvram = auto_alloc_array(machine, UINT16, 0x080000/sizeof(UINT16));
	2707	//state->m_tvram = auto_alloc_array(machine, UINT16, 0x080000/sizeof(UINT16));
2707	2708	state->m_sram = auto_alloc_array(machine, UINT16, 0x4000/sizeof(UINT16));
2708	2709
2709	2710	state->m_spritereg = auto_alloc_array_clear(machine, UINT16, 0x8000/sizeof(UINT16));

src/mess/drivers/kaypro.c
r14946	r14947
47	47
48	48	static ADDRESS_MAP_START( kaypro_map, AS_PROGRAM, 8, kaypro_state )
49	49	AM_RANGE(0x0000, 0x0fff) AM_ROM AM_REGION("maincpu", 0x0000)
50		AM_RANGE(0x3000, 0x3fff) AM_RAM AM_REGION("maincpu", 0x3000) AM_BASE(m_p_videoram)
	50	AM_RANGE(0x3000, 0x3fff) AM_RAM AM_REGION("maincpu", 0x3000) AM_SHARE("p_videoram")
51	51	AM_RANGE(0x4000, 0xffff) AM_RAM AM_REGION("rambank", 0x4000)
52	52	ADDRESS_MAP_END
53	53

src/mess/drivers/victor9k.c
r14946	r14947
48	48	AM_RANGE(0xe80a0, 0xe80af) AM_DEVREADWRITE(M6522_4_TAG, via6522_device, read, write)
49	49	AM_RANGE(0xe80c0, 0xe80cf) AM_DEVREADWRITE(M6522_6_TAG, via6522_device, read, write)
50	50	AM_RANGE(0xe80e0, 0xe80ef) AM_DEVREADWRITE(M6522_5_TAG, via6522_device, read, write)
51		AM_RANGE(0xf0000, 0xf0fff) AM_MIRROR(0x1000) AM_RAM AM_BASE(m_video_ram)
	51	AM_RANGE(0xf0000, 0xf0fff) AM_MIRROR(0x1000) AM_RAM AM_SHARE("video_ram")
52	52	AM_RANGE(0xfe000, 0xfffff) AM_ROM AM_REGION(I8088_TAG, 0)
53	53	ADDRESS_MAP_END
54	54

src/mess/drivers/portfoli.c
r14946	r14947
509	509	AM_RANGE(0x8040, 0x8041) AM_READWRITE(counter_r, counter_w)
510	510	AM_RANGE(0x8050, 0x8050) AM_READWRITE(irq_status_r, irq_mask_w)
511	511	AM_RANGE(0x8051, 0x8051) AM_READWRITE(battery_r, unknown_w)
512		AM_RANGE(0x8060, 0x8060) AM_RAM AM_BASE(m_contrast)
	512	AM_RANGE(0x8060, 0x8060) AM_RAM AM_SHARE("contrast")
513	513	// AM_RANGE(0x8070, 0x8077) AM_DEVREADWRITE_LEGACY(M82C50A_TAG, ins8250_r, ins8250_w) // Serial Interface
514	514	// AM_RANGE(0x8078, 0x807b) AM_DEVREADWRITE(M82C55A_TAG, i8255_device, read, write) // Parallel Interface
515	515	AM_RANGE(0x807c, 0x807c) AM_WRITE(ncc1_w)

src/mess/drivers/atom.c
r14946	r14947
181	181	AM_RANGE(0x0a00, 0x0a03) AM_MIRROR(0x1f8) AM_DEVREADWRITE_LEGACY(I8271_TAG, i8271_r, i8271_w)
182	182	AM_RANGE(0x0a04, 0x0a04) AM_MIRROR(0x1f8) AM_DEVREADWRITE_LEGACY(I8271_TAG, i8271_data_r, i8271_data_w)
183	183	AM_RANGE(0x0a05, 0x7fff) AM_RAM
184		AM_RANGE(0x8000, 0x97ff) AM_RAM AM_BASE(m_video_ram)
	184	AM_RANGE(0x8000, 0x97ff) AM_RAM AM_SHARE("video_ram")
185	185	AM_RANGE(0x9800, 0x9fff) AM_RAM
186	186	AM_RANGE(0xa000, 0xafff) AM_ROM AM_REGION(EXTROM_TAG, 0)
187	187	AM_RANGE(0xb000, 0xb003) AM_MIRROR(0x3fc) AM_DEVREADWRITE(INS8255_TAG, i8255_device, read, write)

src/mess/drivers/gp32.c
r14946	r14947
102	102	int i;
103	103	for (i = 0; i < 2; i++)
104	104	{
105		vram = (UINT8 *)state->m_s3c240x_ram + state->m_s3c240x_lcd.vramaddr_cur - 0x0C000000;
	105	vram = (UINT8 *)state->m_s3c240x_ram.target() + state->m_s3c240x_lcd.vramaddr_cur - 0x0C000000;
106	106	data[i*2+0] = vram[0];
107	107	data[i*2+1] = vram[1];
108	108	state->m_s3c240x_lcd.vramaddr_cur += 2;
r14946	r14947
1763	1763
1764	1764	static ADDRESS_MAP_START( gp32_map, AS_PROGRAM, 32, gp32_state )
1765	1765	AM_RANGE(0x00000000, 0x0007ffff) AM_ROM
1766		AM_RANGE(0x0c000000, 0x0c7fffff) AM_RAM AM_BASE(m_s3c240x_ram)
	1766	AM_RANGE(0x0c000000, 0x0c7fffff) AM_RAM AM_SHARE("s3c240x_ram")
1767	1767	AM_RANGE(0x14000000, 0x1400003b) AM_READWRITE_LEGACY(s3c240x_memcon_r, s3c240x_memcon_w)
1768	1768	AM_RANGE(0x14200000, 0x1420005b) AM_READWRITE_LEGACY(s3c240x_usb_host_r, s3c240x_usb_host_w)
1769	1769	AM_RANGE(0x14400000, 0x14400017) AM_READWRITE_LEGACY(s3c240x_irq_r, s3c240x_irq_w)

src/mess/drivers/tmc2000e.c
r14946	r14947
79	79	static ADDRESS_MAP_START( tmc2000e_map, AS_PROGRAM, 8, tmc2000e_state )
80	80	AM_RANGE(0x0000, 0x1fff) AM_RAM
81	81	AM_RANGE(0xc000, 0xdfff) AM_ROM
82		AM_RANGE(0xfc00, 0xffff) AM_WRITEONLY AM_BASE(m_colorram)
	82	AM_RANGE(0xfc00, 0xffff) AM_WRITEONLY AM_SHARE("colorram")
83	83	ADDRESS_MAP_END
84	84
85	85	static ADDRESS_MAP_START( tmc2000e_io_map, AS_IO, 8, tmc2000e_state )
r14946	r14947
211	211	void tmc2000e_state::machine_start()
212	212	{
213	213	/* allocate color RAM */
214		m_colorram = auto_alloc_array(machine(), UINT8, TMC2000E_COLORRAM_SIZE);
	214	//FIXME
	215	//m_colorram = auto_alloc_array(machine(), UINT8, TMC2000E_COLORRAM_SIZE);
215	216
216	217	/* register for state saving */
217		save_pointer(NAME(m_colorram), TMC2000E_COLORRAM_SIZE);
	218	save_pointer(NAME(m_colorram.target()), TMC2000E_COLORRAM_SIZE);
218	219	save_item(NAME(m_cdp1864_efx));
219	220	save_item(NAME(m_keylatch));
220	221	}

src/mess/drivers/hec2hrp.c
r14946	r14947
132	132	AM_RANGE(0x0000,0x3fff) AM_ROM
133	133
134	134	/* Video br mapping*/
135		AM_RANGE(0x4000,0x49ff) AM_RAM AM_BASE(m_videoram)
	135	AM_RANGE(0x4000,0x49ff) AM_RAM AM_SHARE("videoram")
136	136	/* continous RAM*/
137	137	AM_RANGE(0x4A00,0xbfff) AM_RAM
138	138	/* from 0xC000 to 0xFFFF => Bank Ram for video and data !*/
139		AM_RANGE(0xc000,0xffff) AM_RAM AM_BASE(m_hector_videoram)
	139	AM_RANGE(0xc000,0xffff) AM_RAM AM_SHARE("hector_videoram")
140	140	ADDRESS_MAP_END
141	141
142	142	/*****************************************************************************/
r14946	r14947
156	156	AM_RANGE(0x0000,0x3fff) AM_ROMBANK("bank2")
157	157
158	158	/* Video br mapping*/
159		AM_RANGE(0x4000,0x49ff) AM_RAM AM_BASE(m_videoram)
	159	AM_RANGE(0x4000,0x49ff) AM_RAM AM_SHARE("videoram")
160	160	/* continous RAM*/
161	161	AM_RANGE(0x4A00,0xbfff) AM_RAM
162	162	/* from 0xC000 to 0xFFFF => Bank Ram for video and data !*/
163		AM_RANGE(0xc000,0xffff) AM_RAMBANK("bank1") AM_BASE(m_hector_videoram)
	163	AM_RANGE(0xc000,0xffff) AM_RAMBANK("bank1") AM_SHARE("hector_videoram")
164	164	ADDRESS_MAP_END
165	165
166	166	static ADDRESS_MAP_START( hec2hrp_io , AS_IO, 8, hec2hrp_state )
r14946	r14947
333	333	/***********************************************SPECIFIQUE DISK II *************************/
334	334
335	335	// As video HR ram is in bank, use extern memory
336		state->m_hector_videoram = state->m_hector_videoram_hrx;
	336	state->m_hector_videoram.set_target(state->m_hector_videoram_hrx,state->m_hector_videoram.bytes());
337	337
338	338	hector_init(machine);
339	339	hector_disc2_init(machine); // Init of the Disc II !
r14946	r14947
360	360	/****************************************************SPECIFIQUE Mini disque *************************/
361	361
362	362	// As video HR ram is in bank, use extern memory
363		state->m_hector_videoram = state->m_hector_videoram_hrx;
	363	state->m_hector_videoram.set_target(state->m_hector_videoram_hrx,state->m_hector_videoram.bytes());
364	364
365	365	hector_init(machine);
366	366	hector_minidisc_init(machine);

src/mess/drivers/apricotf.c
r14946	r14947
165	165	static ADDRESS_MAP_START( act_f1_mem, AS_PROGRAM, 16, f1_state )
166	166	ADDRESS_MAP_UNMAP_HIGH
167	167	AM_RANGE(0x00000, 0x01dff) AM_RAM
168		AM_RANGE(0x01e00, 0x01fff) AM_RAM AM_BASE(m_p_scrollram)
	168	AM_RANGE(0x01e00, 0x01fff) AM_RAM AM_SHARE("p_scrollram")
169	169	AM_RANGE(0x02000, 0x3ffff) AM_RAM
170		AM_RANGE(0xe0000, 0xe001f) AM_READWRITE(palette_r, palette_w) AM_BASE(m_p_paletteram)
	170	AM_RANGE(0xe0000, 0xe001f) AM_READWRITE(palette_r, palette_w) AM_SHARE("p_paletteram")
171	171	AM_RANGE(0xf8000, 0xfffff) AM_ROM AM_REGION(I8086_TAG, 0)
172	172	ADDRESS_MAP_END
173	173

src/mess/drivers/intv.c
r14946	r14947
766	766	AM_RANGE(0x3a00, 0x3bff) AM_READWRITE( intv_gram_r, intv_gram_w ) /* GRAM Alias, 8-bits wide */
767	767	AM_RANGE(0x4800, 0x6fff) AM_ROM /* Cartridges? */
768	768	AM_RANGE(0x7000, 0x7fff) AM_ROM AM_REGION("maincpu", 0x7000<<1) /* Keyboard ROM */
769		AM_RANGE(0x8000, 0xbfff) AM_RAM_WRITE( intvkbd_dualport16_w ) AM_BASE(m_intvkbd_dualport_ram) /* Dual-port RAM */
	769	AM_RANGE(0x8000, 0xbfff) AM_RAM_WRITE( intvkbd_dualport16_w ) AM_SHARE("intvkbd_dualport_ram") /* Dual-port RAM */
770	770	ADDRESS_MAP_END
771	771
772	772	static ADDRESS_MAP_START( intvkbd2_mem , AS_PROGRAM, 8, intv_state)
r14946	r14947
774	774	AM_RANGE( 0x0000, 0x3fff) AM_READWRITE( intvkbd_dualport8_lsb_r, intvkbd_dualport8_lsb_w ) /* Dual-port RAM */
775	775	AM_RANGE( 0x4000, 0x7fff) AM_READWRITE( intvkbd_dualport8_msb_r, intvkbd_dualport8_msb_w ) /* Dual-port RAM */
776	776	AM_RANGE( 0xb7f8, 0xb7ff) AM_RAM /* ??? */
777		AM_RANGE( 0xb800, 0xbfff) AM_RAM AM_BASE(m_videoram) /* Text Display */
	777	AM_RANGE( 0xb800, 0xbfff) AM_RAM AM_SHARE("videoram") /* Text Display */
778	778	AM_RANGE( 0xc000, 0xffff) AM_ROM
779	779	ADDRESS_MAP_END
780	780

src/mess/drivers/special.c
r14946	r14947
15	15	static ADDRESS_MAP_START(specialist_mem, AS_PROGRAM, 8, special_state )
16	16	AM_RANGE( 0x0000, 0x2fff ) AM_RAMBANK("bank1") // First bank
17	17	AM_RANGE( 0x3000, 0x8fff ) AM_RAM // RAM
18		AM_RANGE( 0x9000, 0xbfff ) AM_RAM AM_BASE(m_p_videoram) // Video RAM
	18	AM_RANGE( 0x9000, 0xbfff ) AM_RAM AM_SHARE("p_videoram") // Video RAM
19	19	AM_RANGE( 0xc000, 0xf000 ) AM_ROM // System ROM
20	20	AM_RANGE( 0xf000, 0xf700 ) AM_NOP
21	21	AM_RANGE( 0xf800, 0xf803 ) AM_MIRROR(0x7fc) AM_DEVREADWRITE("ppi8255", i8255_device, read, write)
r14946	r14947
24	24	static ADDRESS_MAP_START(specialp_mem, AS_PROGRAM, 8, special_state )
25	25	AM_RANGE( 0x0000, 0x2fff ) AM_RAMBANK("bank1") // First bank
26	26	AM_RANGE( 0x3000, 0x7fff ) AM_RAM // RAM
27		AM_RANGE( 0x8000, 0xbfff ) AM_RAM AM_BASE(m_p_videoram) // Video RAM
	27	AM_RANGE( 0x8000, 0xbfff ) AM_RAM AM_SHARE("p_videoram") // Video RAM
28	28	AM_RANGE( 0xc000, 0xf000 ) AM_ROM // System ROM
29	29	AM_RANGE( 0xf000, 0xf700 ) AM_NOP
30	30	AM_RANGE( 0xf800, 0xf803 ) AM_MIRROR(0x7fc) AM_DEVREADWRITE("ppi8255", i8255_device, read, write)

src/mess/drivers/jupiter.c
r14946	r14947
74	74	//-------------------------------------------------
75	75
76	76	static ADDRESS_MAP_START( jupiter3_mem, AS_PROGRAM, 8, jupiter3_state )
77		AM_RANGE(0x0000, 0xbfff) AM_RAM AM_BASE(m_p_ram)
78		AM_RANGE(0xc000, 0xdfff) AM_RAM AM_BASE(m_p_videoram)
	77	AM_RANGE(0x0000, 0xbfff) AM_RAM AM_SHARE("p_ram")
	78	AM_RANGE(0xc000, 0xdfff) AM_RAM AM_SHARE("p_videoram")
79	79	AM_RANGE(0xe000, 0xefff) AM_ROM AM_REGION(Z80_TAG, 0)
80	80	AM_RANGE(0xf000, 0xffff) AM_RAM
81	81	ADDRESS_MAP_END

src/mess/drivers/mikro80.c
r14946	r14947
21	21	static ADDRESS_MAP_START(mikro80_mem, AS_PROGRAM, 8, mikro80_state )
22	22	AM_RANGE( 0x0000, 0x07ff ) AM_RAMBANK("bank1") // First bank
23	23	AM_RANGE( 0x0800, 0xdfff ) AM_RAM // RAM
24		AM_RANGE( 0xe000, 0xe7ff ) AM_RAM AM_BASE(m_cursor_ram)// Video RAM
25		AM_RANGE( 0xe800, 0xefff ) AM_RAM AM_BASE(m_video_ram) // Video RAM
	24	AM_RANGE( 0xe000, 0xe7ff ) AM_RAM AM_SHARE("cursor_ram")// Video RAM
	25	AM_RANGE( 0xe800, 0xefff ) AM_RAM AM_SHARE("video_ram") // Video RAM
26	26	AM_RANGE( 0xd000, 0xf7ff ) AM_RAM // RAM
27	27	AM_RANGE( 0xf800, 0xffff ) AM_ROM // System ROM
28	28	ADDRESS_MAP_END

src/mess/drivers/mz80.c
r14946	r14947
239	239	static ADDRESS_MAP_START( mz80k_mem, AS_PROGRAM, 8, mz80_state )
240	240	ADDRESS_MAP_UNMAP_HIGH
241	241	AM_RANGE(0x0000, 0x0fff) AM_ROM
242		AM_RANGE(0x1000, 0xcfff) AM_RAM AM_BASE(m_p_ram) // 48 KB of RAM
243		AM_RANGE(0xd000, 0xd7ff) AM_RAM AM_BASE(m_p_videoram) // Video RAM
	242	AM_RANGE(0x1000, 0xcfff) AM_RAM AM_SHARE("p_ram") // 48 KB of RAM
	243	AM_RANGE(0xd000, 0xd7ff) AM_RAM AM_SHARE("p_videoram") // Video RAM
244	244	AM_RANGE(0xe000, 0xe003) AM_DEVREADWRITE("ppi8255", i8255_device, read, write) /* PPIA 8255 */
245	245	AM_RANGE(0xe004, 0xe007) AM_DEVREADWRITE_LEGACY("pit8253", pit8253_r,pit8253_w) /* PIT 8253 */
246	246	AM_RANGE(0xe008, 0xe00b) AM_READWRITE( mz80k_strobe_r, mz80k_strobe_w)

src/mess/drivers/ut88.c
r14946	r14947
40	40	AM_RANGE( 0x0000, 0x07ff ) AM_RAMBANK("bank1") // First bank
41	41	AM_RANGE( 0x0800, 0xdfff ) AM_RAM // RAM
42	42	AM_RANGE( 0xe000, 0xe7ff ) AM_RAM // Video RAM (not used)
43		AM_RANGE( 0xe800, 0xefff ) AM_RAM AM_BASE(m_p_videoram) // Video RAM
	43	AM_RANGE( 0xe800, 0xefff ) AM_RAM AM_SHARE("p_videoram") // Video RAM
44	44	AM_RANGE( 0xf400, 0xf7ff ) AM_RAM // System RAM
45	45	AM_RANGE( 0xf800, 0xffff ) AM_ROM // System ROM
46	46	ADDRESS_MAP_END

src/mess/drivers/mpz80.c
r14946	r14947
539	539	AM_RANGE(0x0401, 0x0401) AM_READWRITE(keyboard_r, disp_col_w)
540	540	AM_RANGE(0x0402, 0x0402) AM_READWRITE(switch_r, task_w)
541	541	AM_RANGE(0x0403, 0x0403) AM_READWRITE(status_r, mask_w)
542		AM_RANGE(0x0600, 0x07ff) AM_RAM AM_BASE(m_map_ram)
	542	AM_RANGE(0x0600, 0x07ff) AM_RAM AM_SHARE("map_ram")
543	543	AM_RANGE(0x0800, 0x0bff) AM_ROM AM_REGION(Z80_TAG, 0)
544	544	AM_RANGE(0x0c00, 0x0c00) AM_DEVREADWRITE(AM9512_TAG, am9512_device, read, write)
545	545	*/
r14946	r14947
723	723
724	724	void mpz80_state::machine_start()
725	725	{
726		m_map_ram = auto_alloc_array_clear(machine(), UINT8, 0x200);
	726	//FIXME
	727	//m_map_ram = auto_alloc_array_clear(machine(), UINT8, 0x200);
727	728	}
728	729
729	730

src/mess/drivers/svision.c
r14946	r14947
235	235
236	236	static ADDRESS_MAP_START( svision_mem , AS_PROGRAM, 8, svision_state )
237	237	AM_RANGE( 0x0000, 0x1fff) AM_RAM
238		AM_RANGE( 0x2000, 0x3fff) AM_READWRITE_LEGACY(svision_r, svision_w) AM_BASE(m_reg)
239		AM_RANGE( 0x4000, 0x5fff) AM_RAM AM_BASE(m_videoram)
	238	AM_RANGE( 0x2000, 0x3fff) AM_READWRITE_LEGACY(svision_r, svision_w) AM_SHARE("reg")
	239	AM_RANGE( 0x4000, 0x5fff) AM_RAM AM_SHARE("videoram")
240	240	AM_RANGE( 0x6000, 0x7fff) AM_NOP
241	241	AM_RANGE( 0x8000, 0xbfff) AM_ROMBANK("bank1")
242	242	AM_RANGE( 0xc000, 0xffff) AM_ROMBANK("bank2")
r14946	r14947
244	244
245	245	static ADDRESS_MAP_START( tvlink_mem , AS_PROGRAM, 8, svision_state )
246	246	AM_RANGE( 0x0000, 0x1fff) AM_RAM
247		AM_RANGE( 0x2000, 0x3fff) AM_READWRITE_LEGACY(tvlink_r, tvlink_w) AM_BASE(m_reg)
248		AM_RANGE( 0x4000, 0x5fff) AM_RAM AM_BASE(m_videoram)
	247	AM_RANGE( 0x2000, 0x3fff) AM_READWRITE_LEGACY(tvlink_r, tvlink_w) AM_SHARE("reg")
	248	AM_RANGE( 0x4000, 0x5fff) AM_RAM AM_SHARE("videoram")
249	249	AM_RANGE( 0x6000, 0x7fff) AM_NOP
250	250	AM_RANGE( 0x8000, 0xbfff) AM_ROMBANK("bank1")
251	251	AM_RANGE( 0xc000, 0xffff) AM_ROMBANK("bank2")

src/mess/drivers/xerox820.c
r14946	r14947
238	238
239	239	static ADDRESS_MAP_START( xerox820_mem, AS_PROGRAM, 8, xerox820_state )
240	240	ADDRESS_MAP_UNMAP_HIGH
241		AM_RANGE(0x3000, 0x3fff) AM_RAM AM_BASE(m_video_ram)
	241	AM_RANGE(0x3000, 0x3fff) AM_RAM AM_SHARE("video_ram")
242	242	AM_RANGE(0x4000, 0xffff) AM_RAM
243	243	ADDRESS_MAP_END
244	244
r14946	r14947
256	256
257	257	static ADDRESS_MAP_START( xerox820ii_mem, AS_PROGRAM, 8, xerox820ii_state )
258	258	ADDRESS_MAP_UNMAP_HIGH
259		AM_RANGE(0x3000, 0x3fff) AM_RAM AM_BASE(m_video_ram)
	259	AM_RANGE(0x3000, 0x3fff) AM_RAM AM_SHARE("video_ram")
260	260	AM_RANGE(0xc000, 0xffff) AM_RAM
261	261	ADDRESS_MAP_END
262	262

src/mess/drivers/micronic.c
r14946	r14947
209	209
210	210	static ADDRESS_MAP_START(micronic_mem, AS_PROGRAM, 8, micronic_state)
211	211	AM_RANGE(0x0000, 0x7fff) AM_RAMBANK("bank1")
212		AM_RANGE(0x8000, 0xffff) AM_RAM AM_BASE(m_ram_base)
	212	AM_RANGE(0x8000, 0xffff) AM_RAM AM_SHARE("ram_base")
213	213	ADDRESS_MAP_END
214	214
215	215	static ADDRESS_MAP_START(micronic_io, AS_IO, 8, micronic_state)

src/mess/drivers/psion.c
r14946	r14947
237	237	static ADDRESS_MAP_START(psioncm_mem, AS_PROGRAM, 8, psion_state)
238	238	ADDRESS_MAP_UNMAP_LOW
239	239	AM_RANGE(0x0000, 0x001f) AM_READWRITE(hd63701_int_reg_r, hd63701_int_reg_w)
240		AM_RANGE(0x0040, 0x00ff) AM_RAM AM_BASE(m_sys_register)
	240	AM_RANGE(0x0040, 0x00ff) AM_RAM AM_SHARE("sys_register")
241	241	AM_RANGE(0x0100, 0x03ff) AM_READWRITE(io_r, io_w)
242		AM_RANGE(0x2000, 0x3fff) AM_RAM AM_BASE~~_SIZE~~(m_ram~~,m_ram_size~~)
	242	AM_RANGE(0x2000, 0x3fff) AM_RAM AM_SHARE("ram")
243	243	AM_RANGE(0x8000, 0xffff) AM_ROM
244	244	ADDRESS_MAP_END
245	245
246	246	static ADDRESS_MAP_START(psionla_mem, AS_PROGRAM, 8, psion_state)
247	247	ADDRESS_MAP_UNMAP_LOW
248	248	AM_RANGE(0x0000, 0x001f) AM_READWRITE(hd63701_int_reg_r, hd63701_int_reg_w)
249		AM_RANGE(0x0040, 0x00ff) AM_RAM AM_BASE(m_sys_register)
	249	AM_RANGE(0x0040, 0x00ff) AM_RAM AM_SHARE("sys_register")
250	250	AM_RANGE(0x0100, 0x03ff) AM_READWRITE(io_r, io_w)
251		AM_RANGE(0x0400, 0x5fff) AM_RAM AM_BASE~~_SIZE~~(m_ram~~,m_ram_size~~)
	251	AM_RANGE(0x0400, 0x5fff) AM_RAM AM_SHARE("ram")
252	252	AM_RANGE(0x8000, 0xffff) AM_ROM
253	253	ADDRESS_MAP_END
254	254
255	255	static ADDRESS_MAP_START(psionp350_mem, AS_PROGRAM, 8, psion_state)
256	256	ADDRESS_MAP_UNMAP_LOW
257	257	AM_RANGE(0x0000, 0x001f) AM_READWRITE(hd63701_int_reg_r, hd63701_int_reg_w)
258		AM_RANGE(0x0040, 0x00ff) AM_RAM AM_BASE(m_sys_register)
	258	AM_RANGE(0x0040, 0x00ff) AM_RAM AM_SHARE("sys_register")
259	259	AM_RANGE(0x0100, 0x03ff) AM_READWRITE(io_r, io_w)
260		AM_RANGE(0x0400, 0x3fff) AM_RAM AM_BASE~~_SIZE~~(m_ram~~,m_ram_size~~)
	260	AM_RANGE(0x0400, 0x3fff) AM_RAM AM_SHARE("ram")
261	261	AM_RANGE(0x4000, 0x7fff) AM_RAMBANK("rambank")
262	262	AM_RANGE(0x8000, 0xffff) AM_ROM
263	263	ADDRESS_MAP_END
r14946	r14947
265	265	static ADDRESS_MAP_START(psionlam_mem, AS_PROGRAM, 8, psion_state)
266	266	ADDRESS_MAP_UNMAP_LOW
267	267	AM_RANGE(0x0000, 0x001f) AM_READWRITE(hd63701_int_reg_r, hd63701_int_reg_w)
268		AM_RANGE(0x0040, 0x00ff) AM_RAM AM_BASE(m_sys_register)
	268	AM_RANGE(0x0040, 0x00ff) AM_RAM AM_SHARE("sys_register")
269	269	AM_RANGE(0x0100, 0x03ff) AM_READWRITE(io_r, io_w)
270		AM_RANGE(0x0400, 0x7fff) AM_RAM AM_BASE~~_SIZE~~(m_ram~~,m_ram_size~~)
	270	AM_RANGE(0x0400, 0x7fff) AM_RAM AM_SHARE("ram")
271	271	AM_RANGE(0x8000, 0xbfff) AM_ROMBANK("rombank")
272	272	AM_RANGE(0xc000, 0xffff) AM_ROM
273	273	ADDRESS_MAP_END
r14946	r14947
275	275	static ADDRESS_MAP_START(psionlz_mem, AS_PROGRAM, 8, psion_state)
276	276	ADDRESS_MAP_UNMAP_LOW
277	277	AM_RANGE(0x0000, 0x001f) AM_READWRITE(hd63701_int_reg_r, hd63701_int_reg_w)
278		AM_RANGE(0x0040, 0x00ff) AM_RAM AM_BASE(m_sys_register)
	278	AM_RANGE(0x0040, 0x00ff) AM_RAM AM_SHARE("sys_register")
279	279	AM_RANGE(0x0100, 0x03ff) AM_READWRITE(io_r, io_w)
280		AM_RANGE(0x0400, 0x3fff) AM_RAM AM_BASE~~_SIZE~~(m_ram~~,m_ram_size~~)
	280	AM_RANGE(0x0400, 0x3fff) AM_RAM AM_SHARE("ram")
281	281	AM_RANGE(0x4000, 0x7fff) AM_RAMBANK("rambank")
282	282	AM_RANGE(0x8000, 0xbfff) AM_ROMBANK("rombank")
283	283	AM_RANGE(0xc000, 0xffff) AM_ROM
r14946	r14947
350	350	if (read_or_write)
351	351	{
352	352	file->write(state->m_sys_register, 0xc0);
353		file->write(state->m_ram, state->m_ram~~_siz~~e);
	353	file->write(state->m_ram, state->m_ram.bytes());
354	354	if (state->m_ram_bank_count)
355	355	file->write(state->m_paged_ram, state->m_ram_bank_count * 0x4000);
356	356	}
r14946	r14947
359	359	if (file)
360	360	{
361	361	file->read(state->m_sys_register, 0xc0);
362		file->read(state->m_ram, state->m_ram~~_siz~~e);
	362	file->read(state->m_ram, state->m_ram.bytes());
363	363	if (state->m_ram_bank_count)
364	364	file->read(state->m_paged_ram, state->m_ram_bank_count * 0x4000);
365	365

src/mess/drivers/gba.c
r14946	r14947
1995	1995	AM_RANGE(0x02000000, 0x0203ffff) AM_RAM AM_MIRROR(0xfc0000)
1996	1996	AM_RANGE(0x03000000, 0x03007fff) AM_RAM AM_MIRROR(0xff8000)
1997	1997	AM_RANGE(0x04000000, 0x040003ff) AM_READWRITE_LEGACY(gba_io_r, gba_io_w )
1998		AM_RANGE(0x05000000, 0x050003ff) AM_RAM_WRITE_LEGACY(gba_pram_w) AM_BASE(m_gba_pram) // Palette RAM
1999		AM_RANGE(0x06000000, 0x06017fff) AM_RAM_WRITE_LEGACY(gba_vram_w) AM_BASE(m_gba_vram) // VRAM
2000		AM_RANGE(0x07000000, 0x070003ff) AM_RAM_WRITE_LEGACY(gba_oam_w) AM_BASE(m_gba_oam) // OAM
	1998	AM_RANGE(0x05000000, 0x050003ff) AM_RAM_WRITE_LEGACY(gba_pram_w) AM_SHARE("gba_pram") // Palette RAM
	1999	AM_RANGE(0x06000000, 0x06017fff) AM_RAM_WRITE_LEGACY(gba_vram_w) AM_SHARE("gba_vram") // VRAM
	2000	AM_RANGE(0x07000000, 0x070003ff) AM_RAM_WRITE_LEGACY(gba_oam_w) AM_SHARE("gba_oam") // OAM
2001	2001	AM_RANGE(0x08000000, 0x09ffffff) AM_ROM AM_REGION("cartridge", 0) // cartridge ROM (mirror 0)
2002	2002	AM_RANGE(0x0a000000, 0x0bffffff) AM_ROM AM_REGION("cartridge", 0) // cartridge ROM (mirror 1)
2003	2003	AM_RANGE(0x0c000000, 0x0cffffff) AM_ROM AM_REGION("cartridge", 0) // final mirror

src/mess/drivers/vixen.c
r14946	r14947
266	266	static ADDRESS_MAP_START( vixen_mem, AS_PROGRAM, 8, vixen_state )
267	267	ADDRESS_MAP_UNMAP_HIGH
268	268	AM_RANGE(0x0000, 0xefff) AM_READ_BANK("bank1") AM_WRITE_BANK("bank2")
269		AM_RANGE(0xf000, 0xffff) AM_READ_BANK("bank3") AM_WRITE_BANK("bank4") AM_BASE(m_video_ram)
	269	AM_RANGE(0xf000, 0xffff) AM_READ_BANK("bank3") AM_WRITE_BANK("bank4") AM_SHARE("video_ram")
270	270	ADDRESS_MAP_END
271	271
272	272
r14946	r14947
419	419	save_item(NAME(m_alt));
420	420	save_item(NAME(m_256));
421	421	save_item(NAME(m_vsync));
422		save_pointer(NAME(m_video_ram), 0x1000);
	422	save_pointer(NAME(m_video_ram.target()), 0x1000);
423	423	}
424	424
425	425

15994 Revisions