Previous

15994 Revisions

Next

r9296 Saturday 2nd October, 2010 at 00:38:16 UTC by Sandro Ronco
[PSION] Converted driver to use data class instead of the global variables

[src/mess/drivers]

psion.c

src/mess/drivers/psion.c

r9295	r9296
40	40	bool write_flag;
41	41	};
42	42
43		static struct _psion
	43	class psion_state : public driver_device
44	44	{
	45	public:
	46	psion_state(running_machine &machine, const driver_device_config_base &config)
	47	: driver_device(machine, config) { }
	48
45	49	UINT16 kb_counter;
46	50	UINT8 enable_nmi;
47	51	UINT8 *sys_register;
r9295	r9296
63	67	UINT8 port6_ddr;
64	68	UINT8 port6;
65	69
66		struct datapack pack1;
67		struct datapack pack2;
68		} psion;
	70	datapack pack1;
	71	datapack pack2;
69	72
	73	// devices
	74	hd44780_device *hd44780;
	75	device_t *beep;
	76	};
	77
	78
70	79	/***********************************************
71	80
72	81	Datapack
73	82
74	83	***********************************************/
75	84
76		UINT8 datapack_update(datapack *pack, UINT8 data)
	85	static UINT8 datapack_update(datapack *pack, UINT8 data)
77	86	{
78	87	assert(pack != NULL);
79	88
r9295	r9296
126	135	return data;
127	136	}
128	137
129		void datapack_control_lines_w(datapack *pack, UINT8 data)
	138	static void datapack_control_lines_w(datapack *pack, UINT8 data)
130	139	{
131	140	assert(pack != NULL);
132	141
r9295	r9296
155	164	pack->control_lines = data;
156	165	}
157	166
158		UINT8 datapack_control_lines_r(datapack *pack)
	167	static UINT8 datapack_control_lines_r(datapack *pack)
159	168	{
160	169	assert(pack != NULL);
161	170
162	171	return pack->control_lines;
163	172	}
164	173
165		int datapack_load(device_image_interface &image, datapack &pack)
	174	static int datapack_load(device_image_interface &image, datapack &pack)
166	175	{
167	176	running_machine *machine = image.device().machine;
168	177	char opk_head[6];
r9295	r9296
193	202	return IMAGE_INIT_PASS;
194	203	}
195	204
196		void datapack_unload(device_image_interface &image, datapack &pack)
	205	static void datapack_unload(device_image_interface &image, datapack &pack)
197	206	{
198	207	running_machine *machine = image.device().machine;
199	208
r9295	r9296
223	232
224	233	static TIMER_CALLBACK( nmi_timer )
225	234	{
226		if (psion.enable_nmi)
	235	psion_state *state = machine->driver_data<psion_state>();
	236
	237	if (state->enable_nmi)
227	238	cputag_set_input_line(machine, "maincpu", INPUT_LINE_NMI, PULSE_LINE);
228	239	}
229	240
230		UINT8 kb_read(running_machine *machine)
	241	static UINT8 kb_read(running_machine *machine)
231	242	{
	243	psion_state *state = machine->driver_data<psion_state>();
232	244	static const char *const bitnames[] = {"K1", "K2", "K3", "K4", "K5", "K6", "K7"};
233	245	UINT8 line, data = 0x7c;
234	246
235		if (psion.kb_counter)
	247	if (state->kb_counter)
236	248	{
237	249	for (line = 0; line < 7; line++)
238		if (psion.kb_counter == (0x7f & ~(1 << line)))
	250	if (state->kb_counter == (0x7f & ~(1 << line)))
239	251	data = input_port_read(machine, bitnames[line]);
240	252	}
241	253	else
r9295	r9296
247	259	return data & 0x7c;
248	260	}
249	261
250		void update_bank(running_machine *machine)
	262	static void update_bank(running_machine *machine)
251	263	{
252		if (psion.ram_bank < psion.ram_bank_count && psion.ram_bank_count)
253		memory_set_bankptr(machine,"rambank", psion.paged_ram + psion.ram_bank*0x4000);
	264	psion_state *state = machine->driver_data<psion_state>();
254	265
255		if (psion.rom_bank_count)
	266	if (state->ram_bank < state->ram_bank_count && state->ram_bank_count)
	267	memory_set_bankptr(machine,"rambank", state->paged_ram + state->ram_bank*0x4000);
	268
	269	if (state->rom_bank_count)
256	270	{
257		if (psion.rom_bank==0)
	271	if (state->rom_bank==0)
258	272	memory_set_bankptr(machine,"rombank", memory_region(machine, "maincpu") + 0x8000);
259		else if (psion.rom_bank < psion.rom_bank_count)
260		memory_set_bankptr(machine,"rombank", memory_region(machine, "maincpu") + psion.rom_bank*0x4000 + 0xc000);
	273	else if (state->rom_bank < state->rom_bank_count)
	274	memory_set_bankptr(machine,"rombank", memory_region(machine, "maincpu") + state->rom_bank*0x4000 + 0xc000);
261	275	}
262	276	}
263	277
264		struct datapack *get_active_slot(running_machine *machine, UINT8 data)
	278	static struct datapack *get_active_slot(running_machine *machine, UINT8 data)
265	279	{
	280	psion_state *state = machine->driver_data<psion_state>();
	281
266	282	switch(data & 0x70)
267	283	{
268	284	case 0x60:
269		return &psion.pack1;
	285	return &state->pack1;
270	286	case 0x50:
271		return &psion.pack2;
	287	return &state->pack2;
272	288	}
273	289
274	290	return NULL;
275	291	}
276	292
277		WRITE8_HANDLER( hd63701_int_reg_w )
	293	static WRITE8_HANDLER( hd63701_int_reg_w )
278	294	{
	295	psion_state *state = space->machine->driver_data<psion_state>();
	296
279	297	switch (offset)
280	298	{
281	299	case 0x01:
282		psion.port2_ddr = data;
	300	state->port2_ddr = data;
283	301	break;
284	302	case 0x03:
285	303	/* datapack i/o data bus */
286		if (psion.port2_ddr == 0xff)
	304	if (state->port2_ddr == 0xff)
287	305	{
288		datapack *pack = get_active_slot(space->machine, psion.port6);
	306	datapack *pack = get_active_slot(space->machine, state->port6);
289	307
290	308	if (pack)
291		psion.port2 = datapack_update(pack, data);
	309	state->port2 = datapack_update(pack, data);
292	310	else
293		psion.port2 = data;
	311	state->port2 = data;
294	312	}
295	313	break;
296	314	case 0x08:
297		psion.tcsr_value = data;
	315	state->tcsr_value = data;
298	316	break;
299	317	case 0x15:
300	318	/* read-only */
301	319	break;
302	320	case 0x16:
303		psion.port6_ddr = data;
	321	state->port6_ddr = data;
304	322	break;
305	323	case 0x17:
306	324	/*
r9295	r9296
315	333	---- ---x clock line
316	334	*/
317	335	{
318		psion.port6 = (data & psion.port6_ddr) | (psion.port6 & ~psion.port6_ddr);
319		datapack *pack = get_active_slot(space->machine, psion.port6);
	336	state->port6 = (data & state->port6_ddr) | (state->port6 & ~state->port6_ddr);
	337	datapack *pack = get_active_slot(space->machine, state->port6);
320	338
321	339	if (pack != NULL)
322	340	{
323		datapack_control_lines_w(pack, psion.port6);
324		datapack_update(pack, psion.port2);
	341	datapack_control_lines_w(pack, state->port6);
	342	datapack_update(pack, state->port2);
325	343	}
326	344	}
327	345	break;
r9295	r9296
330	348	hd63701_internal_registers_w(space, offset, data);
331	349	}
332	350
333		READ8_HANDLER( hd63701_int_reg_r )
	351	static READ8_HANDLER( hd63701_int_reg_r )
334	352	{
	353	psion_state *state = space->machine->driver_data<psion_state>();
	354
335	355	switch (offset)
336	356	{
337	357	case 0x03:
338	358	/* datapack i/o data bus */
339		if (psion.port2_ddr == 0)
	359	if (state->port2_ddr == 0)
340	360	{
341		datapack *pack = get_active_slot(space->machine, psion.port6);
	361	datapack *pack = get_active_slot(space->machine, state->port6);
342	362
343	363	if (pack)
344		psion.port2 = datapack_update(pack, psion.port2);
	364	state->port2 = datapack_update(pack, state->port2);
345	365	else
346		psion.port2 = 0;
	366	state->port2 = 0;
347	367
348		return psion.port2;
	368	return state->port2;
349	369	}
350	370	else
351	371	return 0;
352	372	case 0x14:
353		return (hd63701_internal_registers_r(space, offset)&0x7f) | (psion.stby_pwr<<7);
	373	return (hd63701_internal_registers_r(space, offset)&0x7f) | (state->stby_pwr<<7);
354	374	case 0x15:
355	375	/*
356	376	x--- ---- ON key active high
r9295	r9296
358	378	---- --x- pulse
359	379	---- ---x battery status
360	380	*/
361		return kb_read(space->machine) | input_port_read(space->machine, "BATTERY") | input_port_read(space->machine, "ON") | (psion.kb_counter == 0x7ff)<<1 | psion.pulse<<1;
	381	return kb_read(space->machine) | input_port_read(space->machine, "BATTERY") | input_port_read(space->machine, "ON") | (state->kb_counter == 0x7ff)<<1 | state->pulse<<1;
362	382	case 0x17:
363	383	/* datapack control lines */
364	384	{
365		datapack *pack = get_active_slot(space->machine, psion.port6);
	385	datapack *pack = get_active_slot(space->machine, state->port6);
366	386
367	387	if (pack)
368	388	return datapack_control_lines_r(pack);
369	389	else
370		return psion.port6;
	390	return state->port6;
371	391	}
372	392	case 0x08:
373		hd63701_internal_registers_w(space, offset, psion.tcsr_value);
	393	hd63701_internal_registers_w(space, offset, state->tcsr_value);
374	394	default:
375	395	return hd63701_internal_registers_r(space, offset);
376	396	}
377	397	}
378	398
379	399	/* Read/Write common */
380		void io_rw(address_space* space, UINT16 offset)
	400	static void io_rw(address_space* space, UINT16 offset)
381	401	{
	402	psion_state *state = space->machine->driver_data<psion_state>();
	403
382	404	if (space->debugger_access())
383	405	return;
384	406
r9295	r9296
386	408	{
387	409	case 0xc0:
388	410	/* switch off, CPU goes into standby mode */
389		psion.enable_nmi = 0;
390		psion.stby_pwr = 1;
	411	state->enable_nmi = 0;
	412	state->stby_pwr = 1;
391	413	space->machine->device<cpu_device>("maincpu")->suspend(SUSPEND_REASON_HALT, 1);
392	414	break;
393	415	case 0x100:
394		psion.pulse = 1;
	416	state->pulse = 1;
395	417	break;
396	418	case 0x140:
397		psion.pulse = 0;
	419	state->pulse = 0;
398	420	break;
399	421	case 0x200:
400		psion.kb_counter = 0;
	422	state->kb_counter = 0;
401	423	break;
402	424	case 0x180:
403		beep_set_state(space->machine->device("beep"), 1);
	425	beep_set_state(state->beep, 1);
404	426	break;
405	427	case 0x1c0:
406		beep_set_state(space->machine->device("beep"), 0);
	428	beep_set_state(state->beep, 0);
407	429	break;
408	430	case 0x240:
409		if (offset == 0x260 && (psion.rom_bank_count || psion.ram_bank_count))
	431	if (offset == 0x260 && (state->rom_bank_count || state->ram_bank_count))
410	432	{
411		psion.ram_bank=0;
412		psion.rom_bank=0;
	433	state->ram_bank=0;
	434	state->rom_bank=0;
413	435	update_bank(space->machine);
414	436	}
415	437	else
416		psion.kb_counter++;
	438	state->kb_counter++;
417	439	break;
418	440	case 0x280:
419		if (offset == 0x2a0 && psion.ram_bank_count)
	441	if (offset == 0x2a0 && state->ram_bank_count)
420	442	{
421		psion.ram_bank++;
	443	state->ram_bank++;
422	444	update_bank(space->machine);
423	445	}
424	446	else
425		psion.enable_nmi = 1;
	447	state->enable_nmi = 1;
426	448	break;
427	449	case 0x2c0:
428		if (offset == 0x2e0 && psion.rom_bank_count)
	450	if (offset == 0x2e0 && state->rom_bank_count)
429	451	{
430		psion.rom_bank++;
	452	state->rom_bank++;
431	453	update_bank(space->machine);
432	454	}
433	455	else
434		psion.enable_nmi = 0;
	456	state->enable_nmi = 0;
435	457	break;
436	458	}
437	459	}
438	460
439		WRITE8_HANDLER( io_w )
	461	static WRITE8_HANDLER( io_w )
440	462	{
441		hd44780_device * hd44780 = space->machine->device<hd44780_device>("hd44780");
	463	psion_state *state = space->machine->driver_data<psion_state>();
442	464
443	465	switch (offset & 0x0ffc0)
444	466	{
445	467	case 0x80:
446	468	if (offset & 1)
447		hd44780->data_write(offset, data);
	469	state->hd44780->data_write(offset, data);
448	470	else
449		hd44780->control_write(offset, data);
	471	state->hd44780->control_write(offset, data);
450	472	break;
451	473	default:
452	474	io_rw(space, offset);
453	475	}
454	476	}
455	477
456		READ8_HANDLER( io_r )
	478	static READ8_HANDLER( io_r )
457	479	{
458		hd44780_device * hd44780 = space->machine->device<hd44780_device>("hd44780");
	480	psion_state *state = space->machine->driver_data<psion_state>();
459	481
460	482	switch (offset & 0xffc0)
461	483	{
462	484	case 0x80:
463	485	if (offset& 1)
464		return hd44780->data_read(offset);
	486	return state->hd44780->data_read(offset);
465	487	else
466		return hd44780->control_read(offset);
	488	return state->hd44780->control_read(offset);
467	489	default:
468	490	io_rw(space, offset);
469	491	}
r9295	r9296
483	505	static ADDRESS_MAP_START(psioncm_mem, ADDRESS_SPACE_PROGRAM, 8)
484	506	ADDRESS_MAP_UNMAP_LOW
485	507	AM_RANGE(0x0000, 0x001f) AM_READWRITE(hd63701_int_reg_r, hd63701_int_reg_w)
486		AM_RANGE(0x0040, 0x00ff) AM_RAM AM_BASE(&psion.sys_register)
	508	AM_RANGE(0x0040, 0x00ff) AM_RAM AM_BASE_MEMBER(psion_state, sys_register)
487	509	AM_RANGE(0x0100, 0x03ff) AM_READWRITE(io_r, io_w)
488		AM_RANGE(0x2000, 0x3fff) AM_RAM AM_BASE(&psion.ram) AM_SIZE(&psion.ram_size)
	510	AM_RANGE(0x2000, 0x3fff) AM_RAM AM_BASE_SIZE_MEMBER(psion_state, ram, ram_size)
489	511	AM_RANGE(0x8000, 0xffff) AM_ROM
490	512	ADDRESS_MAP_END
491	513
492	514	static ADDRESS_MAP_START(psionla_mem, ADDRESS_SPACE_PROGRAM, 8)
493	515	ADDRESS_MAP_UNMAP_LOW
494	516	AM_RANGE(0x0000, 0x001f) AM_READWRITE(hd63701_int_reg_r, hd63701_int_reg_w)
495		AM_RANGE(0x0040, 0x00ff) AM_RAM AM_BASE(&psion.sys_register)
	517	AM_RANGE(0x0040, 0x00ff) AM_RAM AM_BASE_MEMBER(psion_state, sys_register)
496	518	AM_RANGE(0x0100, 0x03ff) AM_READWRITE(io_r, io_w)
497		AM_RANGE(0x0400, 0x5fff) AM_RAM AM_BASE(&psion.ram) AM_SIZE(&psion.ram_size)
	519	AM_RANGE(0x0400, 0x5fff) AM_RAM AM_BASE_SIZE_MEMBER(psion_state, ram, ram_size)
498	520	AM_RANGE(0x8000, 0xffff) AM_ROM
499	521	ADDRESS_MAP_END
500	522
501	523	static ADDRESS_MAP_START(psionp350_mem, ADDRESS_SPACE_PROGRAM, 8)
502	524	ADDRESS_MAP_UNMAP_LOW
503	525	AM_RANGE(0x0000, 0x001f) AM_READWRITE(hd63701_int_reg_r, hd63701_int_reg_w)
504		AM_RANGE(0x0040, 0x00ff) AM_RAM AM_BASE(&psion.sys_register)
	526	AM_RANGE(0x0040, 0x00ff) AM_RAM AM_BASE_MEMBER(psion_state, sys_register)
505	527	AM_RANGE(0x0100, 0x03ff) AM_READWRITE(io_r, io_w)
506		AM_RANGE(0x0400, 0x3fff) AM_RAM AM_BASE(&psion.ram) AM_SIZE(&psion.ram_size)
	528	AM_RANGE(0x0400, 0x3fff) AM_RAM AM_BASE_SIZE_MEMBER(psion_state, ram, ram_size)
507	529	AM_RANGE(0x4000, 0x7fff) AM_RAMBANK("rambank")
508	530	AM_RANGE(0x8000, 0xffff) AM_ROM
509	531	ADDRESS_MAP_END
r9295	r9296
511	533	static ADDRESS_MAP_START(psionlam_mem, ADDRESS_SPACE_PROGRAM, 8)
512	534	ADDRESS_MAP_UNMAP_LOW
513	535	AM_RANGE(0x0000, 0x001f) AM_READWRITE(hd63701_int_reg_r, hd63701_int_reg_w)
514		AM_RANGE(0x0040, 0x00ff) AM_RAM AM_BASE(&psion.sys_register)
	536	AM_RANGE(0x0040, 0x00ff) AM_RAM AM_BASE_MEMBER(psion_state, sys_register)
515	537	AM_RANGE(0x0100, 0x03ff) AM_READWRITE(io_r, io_w)
516		AM_RANGE(0x0400, 0x7fff) AM_RAM AM_BASE(&psion.ram) AM_SIZE(&psion.ram_size)
	538	AM_RANGE(0x0400, 0x7fff) AM_RAM AM_BASE_SIZE_MEMBER(psion_state, ram, ram_size)
517	539	AM_RANGE(0x8000, 0xbfff) AM_ROMBANK("rombank")
518	540	AM_RANGE(0xc000, 0xffff) AM_ROM
519	541	ADDRESS_MAP_END
r9295	r9296
521	543	static ADDRESS_MAP_START(psionlz_mem, ADDRESS_SPACE_PROGRAM, 8)
522	544	ADDRESS_MAP_UNMAP_LOW
523	545	AM_RANGE(0x0000, 0x001f) AM_READWRITE(hd63701_int_reg_r, hd63701_int_reg_w)
524		AM_RANGE(0x0040, 0x00ff) AM_RAM AM_BASE(&psion.sys_register)
	546	AM_RANGE(0x0040, 0x00ff) AM_RAM AM_BASE_MEMBER(psion_state, sys_register)
525	547	AM_RANGE(0x0100, 0x03ff) AM_READWRITE(io_r, io_w)
526		AM_RANGE(0x0400, 0x3fff) AM_RAM AM_BASE(&psion.ram) AM_SIZE(&psion.ram_size)
	548	AM_RANGE(0x0400, 0x3fff) AM_RAM AM_BASE_SIZE_MEMBER(psion_state, ram, ram_size)
527	549	AM_RANGE(0x4000, 0x7fff) AM_RAMBANK("rambank")
528	550	AM_RANGE(0x8000, 0xbfff) AM_ROMBANK("rombank")
529	551	AM_RANGE(0xc000, 0xffff) AM_ROM
r9295	r9296
591	613
592	614	static DEVICE_IMAGE_LOAD( psion_pack1 )
593	615	{
594		return datapack_load(image, psion.pack1);
	616	psion_state *state = image.device().machine->driver_data<psion_state>();
	617
	618	return datapack_load(image, state->pack1);
595	619	}
596	620
597	621	static DEVICE_IMAGE_UNLOAD( psion_pack1 )
598	622	{
599		datapack_unload(image, psion.pack1);
	623	psion_state *state = image.device().machine->driver_data<psion_state>();
	624
	625	datapack_unload(image, state->pack1);
600	626	}
601	627
602	628	static DEVICE_IMAGE_LOAD( psion_pack2 )
603	629	{
604		return datapack_load(image, psion.pack2);
	630	psion_state *state = image.device().machine->driver_data<psion_state>();
	631
	632	return datapack_load(image, state->pack2);
605	633	}
606	634
607	635	static DEVICE_IMAGE_UNLOAD( psion_pack2 )
608	636	{
609		datapack_unload(image, psion.pack2);
	637	psion_state *state = image.device().machine->driver_data<psion_state>();
	638
	639	datapack_unload(image, state->pack2);
610	640	}
611	641
612	642	static NVRAM_HANDLER( psion )
613	643	{
	644	psion_state *state = machine->driver_data<psion_state>();
	645
614	646	if (read_or_write)
615	647	{
616		mame_fwrite(file, psion.sys_register, 0xc0);
617		mame_fwrite(file, psion.ram, psion.ram_size);
618		if (psion.ram_bank_count)
619		mame_fwrite(file, psion.paged_ram, psion.ram_bank_count * 0x4000);
	648	mame_fwrite(file, state->sys_register, 0xc0);
	649	mame_fwrite(file, state->ram, state->ram_size);
	650	if (state->ram_bank_count)
	651	mame_fwrite(file, state->paged_ram, state->ram_bank_count * 0x4000);
620	652	}
621	653	else
622	654	{
623	655	if (file)
624	656	{
625		mame_fread(file, psion.sys_register, 0xc0);
626		mame_fread(file, psion.ram, psion.ram_size);
627		if (psion.ram_bank_count)
628		mame_fread(file, psion.paged_ram, psion.ram_bank_count * 0x4000);
	657	mame_fread(file, state->sys_register, 0xc0);
	658	mame_fread(file, state->ram, state->ram_size);
	659	if (state->ram_bank_count)
	660	mame_fread(file, state->paged_ram, state->ram_bank_count * 0x4000);
629	661
630		psion.stby_pwr = 1;
	662	state->stby_pwr = 1;
631	663	}
632	664	else
633		psion.stby_pwr = 0;
	665	state->stby_pwr = 0;
634	666	}
635	667	}
636	668
637	669	static MACHINE_START(psion)
638	670	{
	671	psion_state *state = machine->driver_data<psion_state>();
	672
639	673	if (!strcmp(machine->gamedrv->name, "psionlam"))
640	674	{
641		psion.rom_bank_count = 3;
642		psion.ram_bank_count = 0;
	675	state->rom_bank_count = 3;
	676	state->ram_bank_count = 0;
643	677	}
644	678	else if (!strcmp(machine->gamedrv->name, "psionp350"))
645	679	{
646		psion.rom_bank_count = 0;
647		psion.ram_bank_count = 5;
	680	state->rom_bank_count = 0;
	681	state->ram_bank_count = 5;
648	682	}
649	683	else if (!strncmp(machine->gamedrv->name, "psionlz", 7))
650	684	{
651		psion.rom_bank_count = 3;
652		psion.ram_bank_count = 3;
	685	state->rom_bank_count = 3;
	686	state->ram_bank_count = 3;
653	687	}
654	688	else if (!strcmp(machine->gamedrv->name, "psionp464"))
655	689	{
656		psion.rom_bank_count = 3;
657		psion.ram_bank_count = 9;
	690	state->rom_bank_count = 3;
	691	state->ram_bank_count = 9;
658	692	}
659	693	else
660	694	{
661		psion.rom_bank_count = 0;
662		psion.ram_bank_count = 0;
	695	state->rom_bank_count = 0;
	696	state->ram_bank_count = 0;
663	697	}
664	698
665		if (psion.ram_bank_count)
666		psion.paged_ram = auto_alloc_array(machine, UINT8, psion.ram_bank_count * 0x4000);
	699	if (state->ram_bank_count)
	700	state->paged_ram = auto_alloc_array(machine, UINT8, state->ram_bank_count * 0x4000);
667	701
668	702	timer_pulse(machine, ATTOTIME_IN_SEC(1), NULL, 0, nmi_timer);
	703
	704	state->hd44780 = machine->device<hd44780_device>("hd44780");
	705	state->beep = machine->device<device_t>("beep");
669	706	}
670	707
671	708	static MACHINE_RESET(psion)
672	709	{
673		psion.enable_nmi=0;
674		psion.kb_counter=0;
675		psion.ram_bank=0;
676		psion.rom_bank=0;
677		psion.pulse=0;
	710	psion_state *state = machine->driver_data<psion_state>();
678	711
679		if (psion.rom_bank_count || psion.ram_bank_count)
	712	state->enable_nmi=0;
	713	state->kb_counter=0;
	714	state->ram_bank=0;
	715	state->rom_bank=0;
	716	state->pulse=0;
	717
	718	if (state->rom_bank_count || state->ram_bank_count)
680	719	update_bank(machine);
681	720	}
682	721
r9295	r9296
686	725
687	726	static VIDEO_UPDATE( psion_2lines )
688	727	{
689		hd44780_device * hd44780 = screen->machine->device<hd44780_device>("hd44780");
	728	psion_state *state = screen->machine->driver_data<psion_state>();
690	729
691		return hd44780->video_update( bitmap, cliprect );
	730	return state->hd44780->video_update( bitmap, cliprect );
692	731	}
693	732
694	733	static VIDEO_UPDATE( psion_4lines )
695	734	{
696		hd44780_device * hd44780 = screen->machine->device<hd44780_device>("hd44780");
	735	psion_state *state = screen->machine->driver_data<psion_state>();
697	736
698		return hd44780->video_update( bitmap, cliprect );
	737	return state->hd44780->video_update( bitmap, cliprect );
699	738	}
700	739
701	740	static PALETTE_INIT( psion )
r9295	r9296
744	783	};
745	784
746	785	/* basic configuration for 2 lines display */
747		static MACHINE_CONFIG_START( psion_2lines, driver_device )
	786	static MACHINE_CONFIG_START( psion_2lines, psion_state )
748	787	/* basic machine hardware */
749	788	MDRV_CPU_ADD("maincpu",HD63701, 980000) // should be HD6303 at 0.98MHz
750	789
r9295	r9296
794	833	};
795	834
796	835	/* basic configuration for 4 lines display */
797		static MACHINE_CONFIG_START( psion_4lines, driver_device )
	836	static MACHINE_CONFIG_START( psion_4lines, psion_state )
798	837	/* basic machine hardware */
799	838	MDRV_CPU_ADD("maincpu",HD63701, 980000) // should be HD6303 at 0.98MHz
800	839

Previous

15994 Revisions

Next

---

© 1998-2018 The MESS Team