Previous

199869 Revisions

Next

r22819 Tuesday 14th May, 2013 at 10:21:05 UTC by smf
modernised TMS5220 [smf]

[src/emu/machine]	spchrom.c* spchrom.h*
[src/emu/sound]	sound.mak tms5220.c tms5220.h
[src/mame/audio]	atarijsa.c cinemat.c exidy.c jedi.c midway.c starwars.c
[src/mame/drivers]	atarisy1.c atarisy2.c esripsys.c firefox.c gauntlet.c icecold.c looping.c maygay1b.c polepos.c portrait.c tomcat.c zaccaria.c
[src/mame/includes]	esripsys.h polepos.h portrait.h
[src/mame/machine]	mhavoc.c
[src/mess]	mess.mak
[src/mess/audio]	spchroms.c spchroms.h
[src/mess/drivers]	exelv.c mpf1.c pes.c
[src/mess/includes]	mpf1.h
[src/mess/machine]	a2echoii.c a2mockingboard.c rmnimbus.c
[src/mess/machine/ti99]	spchsyn.c spchsyn.h speech8.c speech8.h

trunk/src/emu/machine/spchrom.c

r0	r22819
	1	/*
	2	spchroms.c - This is an emulator for "typical" speech ROMs from TI, as used by TI99/4(a).
	3
	4	In order to support its speech processor, TI designed some ROMs with a 1-bit data bus
	5	and 4-bit address bus (multiplexed 5 times to provide a 18-bit address).
	6	A fairly complete description of such a ROM (tms6100) is found in the tms5220 datasheet.
	7
	8	One notable thing is that the address is a byte address (*NOT* a bit address).
	9
	10	This file is designed to be interfaced with the tms5220 core.
	11	Interfacing it with the tms5110 would make sense, too.
	12	*/
	13
	14	#include "emu.h"
	15	#include "spchrom.h"
	16
	17	#define TMS5220_ADDRESS_MASK 0x3FFFFUL  /* 18-bit mask for tms5220 address */
	18
	19	// device type definition
	20	const device_type SPEECHROM = &device_creator<speechrom_device>;
	21
	22	speechrom_device::speechrom_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
	23	: device_t(mconfig, SPEECHROM, "SPEECHROM", tag, owner, clock),
	24	m_speechROMaddr(0),
	25	m_load_pointer(0),
	26	m_ROM_bits_count(0)
	27	{
	28	}
	29
	30	/*
	31	Read 'count' bits serially from speech ROM
	32	*/
	33	int speechrom_device::read(int count)
	34	{
	35	int val;
	36
	37	if (m_load_pointer)
	38	{   /* first read after load address is ignored */
	39	m_load_pointer = 0;
	40	count--;
	41	}
	42
	43	if (m_speechROMaddr < m_speechROMlen)
	44	if (count < m_ROM_bits_count)
	45	{
	46	m_ROM_bits_count -= count;
	47	val = (m_speechrom_data[m_speechROMaddr] >> m_ROM_bits_count) & (0xFF >> (8 - count));
	48	}
	49	else
	50	{
	51	val = ((int) m_speechrom_data[m_speechROMaddr]) << 8;
	52
	53	m_speechROMaddr = (m_speechROMaddr + 1) & TMS5220_ADDRESS_MASK;
	54
	55	if (m_speechROMaddr < m_speechROMlen)
	56	val |= m_speechrom_data[m_speechROMaddr];
	57
	58	m_ROM_bits_count += 8 - count;
	59
	60	val = (val >> m_ROM_bits_count) & (0xFF >> (8 - count));
	61	}
	62	else
	63	val = 0;
	64
	65	return val;
	66	}
	67
	68	/*
	69	Write an address nibble to speech ROM
	70	*/
	71	void speechrom_device::load_address(int data)
	72	{
	73	/* tms5220 data sheet says that if we load only one 4-bit nibble, it won't work.
	74	This code does not care about this. */
	75	m_speechROMaddr = ( (m_speechROMaddr & ~(0xf << m_load_pointer))
	76	| (((unsigned long) (data & 0xf)) << m_load_pointer) ) & TMS5220_ADDRESS_MASK;
	77	m_load_pointer += 4;
	78	m_ROM_bits_count = 8;
	79	}
	80
	81	/*
	82	Perform a read and branch command
	83	*/
	84	void speechrom_device::read_and_branch()
	85	{
	86	/* tms5220 data sheet says that if more than one speech ROM (tms6100) is present,
	87	there is a bus contention.  This code does not care about this. */
	88	if (m_speechROMaddr < m_speechROMlen-1)
	89	m_speechROMaddr = (m_speechROMaddr & 0x3c000UL)
	90	| (((((unsigned long) m_speechrom_data[m_speechROMaddr]) << 8)
	91	| m_speechrom_data[m_speechROMaddr+1]) & 0x3fffUL);
	92	else if (m_speechROMaddr == m_speechROMlen-1)
	93	m_speechROMaddr = (m_speechROMaddr & 0x3c000UL)
	94	| ((((unsigned long) m_speechrom_data[m_speechROMaddr]) << 8) & 0x3fffUL);
	95	else
	96	m_speechROMaddr = (m_speechROMaddr & 0x3c000UL);
	97
	98	m_ROM_bits_count = 8;
	99	}
	100
	101	void speechrom_device::device_start()
	102	{
	103	memory_region *region = memregion(tag());
	104	if (region == NULL)
	105	{
	106	throw emu_fatalerror("No region for device '%s'\n", tag());
	107	}
	108
	109	m_speechrom_data = region->base();
	110	m_speechROMlen = region->bytes();
	111
	112	save_item(NAME(m_speechROMaddr));
	113	save_item(NAME(m_load_pointer));
	114	save_item(NAME(m_ROM_bits_count));
	115	}

Property changes on: trunk/src/emu/machine/spchrom.c

Added: svn:eol-style    + native Added: svn:mime-type    + text/plain

trunk/src/emu/machine/spchrom.h

r0	r22819
	1	/*
	2	* Voice Synthesis Memory
	3	*
	4	*/
	5
	6	#ifndef __SPCHROMS_H
	7	#define __SPCHROMS_H
	8
	9	#include "emu.h"
	10
	11	class speechrom_device : public device_t
	12	{
	13	public:
	14	// construction/destruction
	15	speechrom_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
	16
	17	/// TODO: implement bus behaviour
	18	int read(int count);
	19	void load_address(int data);
	20	void read_and_branch();
	21
	22	// device-level overrides
	23	virtual void device_start();
	24
	25	private:
	26	UINT8 *m_speechrom_data;           /* pointer to speech ROM data */
	27	unsigned long m_speechROMlen;      /* length of data pointed by speechrom_data, from 0 to 2^18 */
	28	unsigned long m_speechROMaddr;     /* 18 bit pointer in ROM */
	29	int m_load_pointer;                /* which 4-bit nibble will be affected by load address */
	30	int m_ROM_bits_count;              /* current bit position in ROM */
	31	};
	32
	33
	34	// device type definition
	35	extern const device_type SPEECHROM;
	36
	37	#endif

Property changes on: trunk/src/emu/machine/spchrom.h

Added: svn:mime-type    + text/plain Added: svn:eol-style    + native

trunk/src/emu/sound/sound.mak

r22818	r22819
644	644	# Texas Instruments TMS5200-series speech synthesizers
645	645	#-------------------------------------------------
646	646	ifneq ($(filter TMS5220,$(SOUNDS)),)
647		SOUNDOBJS += $(SOUNDOBJ)/tms5220.o
	647	SOUNDOBJS += $(SOUNDOBJ)/tms5220.o $(EMUMACHINE)/spchrom.o
648	648	endif
649	649
650	650	$(SOUNDOBJ)/tms5220.o:  $(SOUNDSRC)/tms5110r.c

trunk/src/emu/sound/tms5220.c

r22818	r22819
251	251	#include "emu.h"
252	252	#include "tms5220.h"
253	253
	254	static INT16 clip_analog(INT16 cliptemp);
	255
254	256	/* *****optional defines***** */
255	257
256	258	/* Hacky improvements which don't match patent: */
r22818	r22819
258	260	* One of the following two lines should be used, and the other commented
259	261	* The second line is more accurate mathematically but not accurate to the patent
260	262	*/
261		#define INTERP_SHIFT >> tms->coeff->interp_coeff[tms->IP]
262		//define INTERP_SHIFT / (1<<tms->coeff->interp_coeff[tms->IP])
	263	#define INTERP_SHIFT >> m_coeff->interp_coeff[m_IP]
	264	//define INTERP_SHIFT / (1<<m_coeff->interp_coeff[m_IP])
263	265
264	266	/* Other hacks */
265	267	/* HACK?: if defined, outputs the low 4 bits of the lattice filter to the i/o
r22818	r22819
267	269	* ...actually the tms5220c might legitamately do this! */
268	270	#undef ALLOW_4_LSB
269	271
270		/* HACK: if defined, uses impossibly perfect 'straight line' interpolation */
271		#undef PERFECT_INTERPOLATION_HACK
272	272
273
274	273	/* *****configuration of chip connection stuff***** */
275	274	/* must be defined; if 0, output the waveform as if it was tapped on the speaker pin as usual, if 1, output the waveform as if it was tapped on the i/o pin (volume is much lower in the latter case) */
276	275	#define FORCE_DIGITAL 0
r22818	r22819
323	322
324	323	static const UINT8 reload_table[4] = { 0, 2, 4, 6 }; //sample count reload for 5220c only; 5200 and 5220 always reload with 0; keep in mind this is loaded on IP=0 PC=12 subcycle=1 so it immediately will increment after one sample, effectively being 1,3,5,7 as in the comments above.
325	324
326		struct tms5220_state
327		{
328		/* coefficient tables */
329		int variant;                /* Variant of the 5xxx - see tms5110r.h */
330
331		/* coefficient tables */
332		const struct tms5100_coeffs *coeff;
333
334		/* callbacks */
335		devcb_resolved_write_line   irq_func;
336		devcb_resolved_write_line   readyq_func;
337
338		/* these contain data that describes the 128-bit data FIFO */
339		UINT8 fifo[FIFO_SIZE];
340		UINT8 fifo_head;
341		UINT8 fifo_tail;
342		UINT8 fifo_count;
343		UINT8 fifo_bits_taken;
344
345
346		/* these contain global status bits */
347		UINT8 speaking_now;     /* True only if actual speech is being generated right now. Is set when a speak vsm command happens OR when speak external happens and buffer low becomes nontrue; Is cleared when speech halts after the last stop frame or the last frame after talk status is otherwise cleared.*/
348		UINT8 speak_external;   /* If 1, DDIS is 1, i.e. Speak External command in progress, writes go to FIFO. */
349		UINT8 talk_status;      /* If 1, TS status bit is 1, i.e. speak or speak external is in progress and we have not encountered a stop frame yet; talk_status differs from speaking_now in that speaking_now is set as soon as a speak or speak external command is started; talk_status does NOT go active until after 8 bytes are written to the fifo on a speak external command, otherwise the two are the same. TS is cleared by 3 things: 1. when a STOP command has just been processed as a new frame in the speech stream; 2. if the fifo runs out in speak external mode; 3. on power-up/during a reset command; When it gets cleared, speak_external is also cleared, an interrupt is generated, and speaking_now will be cleared when the next frame starts. */
350		UINT8 buffer_low;       /* If 1, FIFO has less than 8 bytes in it */
351		UINT8 buffer_empty;     /* If 1, FIFO is empty */
352		UINT8 irq_pin;          /* state of the IRQ pin (output) */
353		UINT8 ready_pin;        /* state of the READY pin (output) */
354
355		/* these contain data describing the current and previous voice frames */
356		#define OLD_FRAME_SILENCE_FLAG tms->OLDE // 1 if E=0, 0 otherwise.
357		#define OLD_FRAME_UNVOICED_FLAG tms->OLDP // 1 if P=0 (unvoiced), 0 if voiced
358		UINT8 OLDE;
359		UINT8 OLDP;
360
361		#define NEW_FRAME_STOP_FLAG (tms->new_frame_energy_idx == 0xF) // 1 if this is a stop (Energy = 0xF) frame
362		#define NEW_FRAME_SILENCE_FLAG (tms->new_frame_energy_idx == 0) // ditto as above
363		#define NEW_FRAME_UNVOICED_FLAG (tms->new_frame_pitch_idx == 0) // ditto as above
364		UINT8 new_frame_energy_idx;
365		UINT8 new_frame_pitch_idx;
366		UINT8 new_frame_k_idx[10];
367
368
369		/* these are all used to contain the current state of the sound generation */
370		#ifndef PERFECT_INTERPOLATION_HACK
371		INT16 current_energy;
372		INT16 current_pitch;
373		INT16 current_k[10];
374
375		INT16 target_energy;
376		INT16 target_pitch;
377		INT16 target_k[10];
378		#else
379		UINT8 old_frame_energy_idx;
380		UINT8 old_frame_pitch_idx;
381		UINT8 old_frame_k_idx[10];
382
383		INT32 current_energy;
384		INT32 current_pitch;
385		INT32 current_k[10];
386
387		INT32 target_energy;
388		INT32 target_pitch;
389		INT32 target_k[10];
390		#endif
391
392		UINT16 previous_energy; /* needed for lattice filter to match patent */
393
394		UINT8 subcycle;         /* contains the current subcycle for a given PC: 0 is A' (only used on SPKSLOW mode on 51xx), 1 is A, 2 is B */
395		UINT8 subc_reload;      /* contains 1 for normal speech, 0 when SPKSLOW is active */
396		UINT8 PC;               /* current parameter counter (what param is being interpolated), ranges from 0 to 12 */
397		/* TODO/NOTE: the current interpolation period, counts 1,2,3,4,5,6,7,0 for divide by 8,8,8,4,4,2,2,1 */
398		UINT8 IP;               /* the current interpolation period */
399		UINT8 inhibit;          /* If 1, interpolation is inhibited until the DIV1 period */
400		UINT8 tms5220c_rate;    /* only relevant for tms5220C's multi frame rate feature; is the actual 4 bit value written on a 0x2* or 0x0* command */
401		UINT16 pitch_count;     /* pitch counter; provides chirp rom address */
402
403		INT32 u[11];
404		INT32 x[10];
405
406		UINT16 RNG;             /* the random noise generator configuration is: 1 + x + x^3 + x^4 + x^13 */
407		INT16 excitation_data;
408
409		/* R Nabet : These have been added to emulate speech Roms */
410		UINT8 schedule_dummy_read;          /* set after each load address, so that next read operation is preceded by a dummy read */
411		UINT8 data_register;                /* data register, used by read command */
412		UINT8 RDB_flag;                 /* whether we should read data register or status register */
413
414		/* io_ready: page 3 of the datasheet specifies that READY will be asserted until
415		* data is available or processed by the system.
416		*/
417		UINT8 io_ready;
418
419		/* flag for "true" timing involving rs/ws */
420		UINT8 true_timing;
421
422		/* rsws - state, rs bit 1, ws bit 0 */
423		UINT8 rs_ws;
424		UINT8 read_latch;
425		UINT8 write_latch;
426
427		/* The TMS52xx has two different ways of providing output data: the
428		analog speaker pin (which was usually used) and the Digital I/O pin.
429		The internal DAC used to feed the analog pin is only 8 bits, and has the
430		funny clipping/clamping logic, while the digital pin gives full 10 bit
431		resolution of the output data.
432		TODO: add a way to set/reset this other than the FORCE_DIGITAL define
433		*/
434		UINT8 digital_select;
435		device_t *device;
436
437		const tms5220_interface *intf;
438		sound_stream *stream;
439		int clock;
440		};
441
442
443	325	// Pull in the ROM tables
444	326	#include "tms5110r.c"
445	327
446	328
447		INLINE tms5220_state *get_safe_token(device_t *device)
	329	void tms5220_device::set_variant(int variant)
448	330	{
449		assert(device != NULL);
450		assert(device->type() == TMS5220 ||
451		device->type() == TMS5220C ||
452		device->type() == TMC0285 ||
453		device->type() == TMS5200);
454		return (tms5220_state *)downcast<tms5220_device *>(device)->token();
455		}
456
457		/* Static function prototypes */
458		static void process_command(tms5220_state *tms, unsigned char data);
459		static void parse_frame(tms5220_state *tms);
460		static void update_status_and_ints(tms5220_state *tms);
461		static void set_interrupt_state(tms5220_state *tms, int state);
462		static INT32 lattice_filter(tms5220_state *tms);
463		static INT16 clip_analog(INT16 clip);
464		static void update_ready_state(tms5220_state *tms);
465		static STREAM_UPDATE( tms5220_update );
466
467		static void tms5220_set_variant(tms5220_state *tms, int variant)
468		{
469	331	switch (variant)
470	332	{
471	333	case TMS5220_IS_5200:
472		tms->coeff = &tms5200_coeff;
	334	m_coeff = &tms5200_coeff;
473	335	break;
474	336	case TMS5220_IS_5220C:
475	337	case TMS5220_IS_5220:
476		tms->coeff = &tms5220_coeff;
	338	m_coeff = &tms5220_coeff;
477	339	break;
478	340	default:
479	341	fatalerror("Unknown variant in tms5220_set_variant\n");
480	342	}
481		tms->variant = variant;
	343	m_variant = variant;
482	344	}
483	345
484	346
485		static void register_for_save_states(tms5220_state *tms)
	347	void tms5220_device::register_for_save_states()
486	348	{
487		tms->device->save_item(NAME(tms->fifo));
488		tms->device->save_item(NAME(tms->fifo_head));
489		tms->device->save_item(NAME(tms->fifo_tail));
490		tms->device->save_item(NAME(tms->fifo_count));
491		tms->device->save_item(NAME(tms->fifo_bits_taken));
	349	save_item(NAME(m_fifo));
	350	save_item(NAME(m_fifo_head));
	351	save_item(NAME(m_fifo_tail));
	352	save_item(NAME(m_fifo_count));
	353	save_item(NAME(m_fifo_bits_taken));
492	354
493		tms->device->save_item(NAME(tms->speaking_now));
494		tms->device->save_item(NAME(tms->speak_external));
495		tms->device->save_item(NAME(tms->talk_status));
496		tms->device->save_item(NAME(tms->buffer_low));
497		tms->device->save_item(NAME(tms->buffer_empty));
498		tms->device->save_item(NAME(tms->irq_pin));
499		tms->device->save_item(NAME(tms->ready_pin));
	355	save_item(NAME(m_speaking_now));
	356	save_item(NAME(m_speak_external));
	357	save_item(NAME(m_talk_status));
	358	save_item(NAME(m_buffer_low));
	359	save_item(NAME(m_buffer_empty));
	360	save_item(NAME(m_irq_pin));
	361	save_item(NAME(m_ready_pin));
500	362
501		tms->device->save_item(NAME(tms->OLDE));
502		tms->device->save_item(NAME(tms->OLDP));
	363	save_item(NAME(m_OLDE));
	364	save_item(NAME(m_OLDP));
503	365
504		tms->device->save_item(NAME(tms->new_frame_energy_idx));
505		tms->device->save_item(NAME(tms->new_frame_pitch_idx));
506		tms->device->save_item(NAME(tms->new_frame_k_idx));
	366	save_item(NAME(m_new_frame_energy_idx));
	367	save_item(NAME(m_new_frame_pitch_idx));
	368	save_item(NAME(m_new_frame_k_idx));
507	369	#ifdef PERFECT_INTERPOLATION_HACK
508		tms->device->save_item(NAME(tms->old_frame_energy_idx));
509		tms->device->save_item(NAME(tms->old_frame_pitch_idx));
510		tms->device->save_item(NAME(tms->old_frame_k_idx));
	370	save_item(NAME(m_old_frame_energy_idx));
	371	save_item(NAME(m_old_frame_pitch_idx));
	372	save_item(NAME(m_old_frame_k_idx));
511	373	#endif
512		tms->device->save_item(NAME(tms->current_energy));
513		tms->device->save_item(NAME(tms->current_pitch));
514		tms->device->save_item(NAME(tms->current_k));
	374	save_item(NAME(m_current_energy));
	375	save_item(NAME(m_current_pitch));
	376	save_item(NAME(m_current_k));
515	377
516		tms->device->save_item(NAME(tms->target_energy));
517		tms->device->save_item(NAME(tms->target_pitch));
518		tms->device->save_item(NAME(tms->target_k));
	378	save_item(NAME(m_target_energy));
	379	save_item(NAME(m_target_pitch));
	380	save_item(NAME(m_target_k));
519	381
520		tms->device->save_item(NAME(tms->previous_energy));
	382	save_item(NAME(m_previous_energy));
521	383
522		tms->device->save_item(NAME(tms->subcycle));
523		tms->device->save_item(NAME(tms->subc_reload));
524		tms->device->save_item(NAME(tms->PC));
525		tms->device->save_item(NAME(tms->IP));
526		tms->device->save_item(NAME(tms->inhibit));
527		tms->device->save_item(NAME(tms->tms5220c_rate));
528		tms->device->save_item(NAME(tms->pitch_count));
	384	save_item(NAME(m_subcycle));
	385	save_item(NAME(m_subc_reload));
	386	save_item(NAME(m_PC));
	387	save_item(NAME(m_IP));
	388	save_item(NAME(m_inhibit));
	389	save_item(NAME(m_tms5220c_rate));
	390	save_item(NAME(m_pitch_count));
529	391
530		tms->device->save_item(NAME(tms->u));
531		tms->device->save_item(NAME(tms->x));
	392	save_item(NAME(m_u));
	393	save_item(NAME(m_x));
532	394
533		tms->device->save_item(NAME(tms->RNG));
534		tms->device->save_item(NAME(tms->excitation_data));
	395	save_item(NAME(m_RNG));
	396	save_item(NAME(m_excitation_data));
535	397
536		tms->device->save_item(NAME(tms->schedule_dummy_read));
537		tms->device->save_item(NAME(tms->data_register));
538		tms->device->save_item(NAME(tms->RDB_flag));
539		tms->device->save_item(NAME(tms->digital_select));
	398	save_item(NAME(m_schedule_dummy_read));
	399	save_item(NAME(m_data_register));
	400	save_item(NAME(m_RDB_flag));
	401	save_item(NAME(m_digital_select));
540	402
541		tms->device->save_item(NAME(tms->io_ready));
	403	save_item(NAME(m_io_ready));
542	404	}
543	405
544	406
r22818	r22819
586	448
587	449	***********************************************************************************************/
588	450
589		static void tms5220_data_write(tms5220_state *tms, int data)
	451	void tms5220_device::data_write(int data)
590	452	{
591	453	#ifdef DEBUG_DUMP_INPUT_DATA
592	454	fprintf(stdout, "%c",data);
593	455	#endif
594		if (tms->speak_external) // If we're in speak external mode
	456	if (m_speak_external) // If we're in speak external mode
595	457	{
596	458	// add this byte to the FIFO
597		if (tms->fifo_count < FIFO_SIZE)
	459	if (m_fifo_count < FIFO_SIZE)
598	460	{
599		tms->fifo[tms->fifo_tail] = data;
600		tms->fifo_tail = (tms->fifo_tail + 1) % FIFO_SIZE;
601		tms->fifo_count++;
	461	m_fifo[m_fifo_tail] = data;
	462	m_fifo_tail = (m_fifo_tail + 1) % FIFO_SIZE;
	463	m_fifo_count++;
602	464	#ifdef DEBUG_FIFO
603		logerror("data_write: Added byte to FIFO (current count=%2d)\n", tms->fifo_count);
	465	logerror("data_write: Added byte to FIFO (current count=%2d)\n", m_fifo_count);
604	466	#endif
605		update_status_and_ints(tms);
606		if ((tms->talk_status == 0) && (tms->buffer_low == 0)) // we just unset buffer low with that last write, and talk status *was* zero...
	467	update_status_and_ints();
	468	if ((m_talk_status == 0) && (m_buffer_low == 0)) // we just unset buffer low with that last write, and talk status *was* zero...
607	469	{
608	470	int i;
609	471	#ifdef DEBUG_FIFO
r22818	r22819
611	473	#endif
612	474	// ...then we now have enough bytes to start talking; clear out the new frame parameters (it will become old frame just before the first call to parse_frame() )
613	475	// TODO: the 3 lines below (and others) are needed for victory to not fail its selftest due to a sample ending too late, may require additional investigation
614		tms->subcycle = tms->subc_reload;
615		tms->PC = 0;
616		tms->IP = reload_table[tms->tms5220c_rate&0x3]; // is this correct? should this be always 7 instead, so that the new frame is loaded quickly?
617		tms->new_frame_energy_idx = 0;
618		tms->new_frame_pitch_idx = 0;
	476	m_subcycle = m_subc_reload;
	477	m_PC = 0;
	478	m_IP = reload_table[m_tms5220c_rate&0x3]; // is this correct? should this be always 7 instead, so that the new frame is loaded quickly?
	479	m_new_frame_energy_idx = 0;
	480	m_new_frame_pitch_idx = 0;
619	481	for (i = 0; i < 4; i++)
620		tms->new_frame_k_idx[i] = 0;
	482	m_new_frame_k_idx[i] = 0;
621	483	for (i = 4; i < 7; i++)
622		tms->new_frame_k_idx[i] = 0xF;
623		for (i = 7; i < tms->coeff->num_k; i++)
624		tms->new_frame_k_idx[i] = 0x7;
625		tms->talk_status = tms->speaking_now = 1;
	484	m_new_frame_k_idx[i] = 0xF;
	485	for (i = 7; i < m_coeff->num_k; i++)
	486	m_new_frame_k_idx[i] = 0x7;
	487	m_talk_status = m_speaking_now = 1;
626	488	}
627	489	}
628	490	else
r22818	r22819
635	497
636	498
637	499	}
638		else //(! tms->speak_external)
	500	else //(! m_speak_external)
639	501	// R Nabet : we parse commands at once.  It is necessary for such commands as read.
640		process_command(tms,data);
	502	process_command(data);
641	503	}
642	504
643	505	/**********************************************************************************************
r22818	r22819
663	525
664	526	***********************************************************************************************/
665	527
666		static void update_status_and_ints(tms5220_state *tms)
	528	void tms5220_device::update_status_and_ints()
667	529	{
668	530	/* update flags and set ints if needed */
669	531
670		update_ready_state(tms);
	532	update_ready_state();
671	533
672	534	/* BL is set if neither byte 9 nor 8 of the fifo are in use; this
673	535	translates to having fifo_count (which ranges from 0 bytes in use to 16
674	536	bytes used) being less than or equal to 8. Victory/Victorba depends on this. */
675		if (tms->fifo_count <= 8)
	537	if (m_fifo_count <= 8)
676	538	{
677	539	// generate an interrupt if necessary; if /BL was inactive and is now active, set int.
678		if (!tms->buffer_low)
679		set_interrupt_state(tms, 1);
680		tms->buffer_low = 1;
	540	if (!m_buffer_low)
	541	set_interrupt_state(1);
	542	m_buffer_low = 1;
681	543	}
682	544	else
683		tms->buffer_low = 0;
	545	m_buffer_low = 0;
684	546
685	547	/* BE is set if neither byte 15 nor 14 of the fifo are in use; this
686	548	translates to having fifo_count equal to exactly 0 */
687		if (tms->fifo_count == 0)
	549	if (m_fifo_count == 0)
688	550	{
689	551	// generate an interrupt if necessary; if /BE was inactive and is now active, set int.
690		if (!tms->buffer_empty)
691		set_interrupt_state(tms, 1);
692		tms->buffer_empty = 1;
	552	if (!m_buffer_empty)
	553	set_interrupt_state(1);
	554	m_buffer_empty = 1;
693	555	}
694	556	else
695		tms->buffer_empty = 0;
	557	m_buffer_empty = 0;
696	558
697	559	/* TS is talk status and is set elsewhere in the fifo parser and in
698	560	the SPEAK command handler; however, if /BE is true during speak external
699	561	mode, it is immediately unset here. */
700		if ((tms->speak_external == 1) && (tms->buffer_empty == 1))
	562	if ((m_speak_external == 1) && (m_buffer_empty == 1))
701	563	{
702	564	// generate an interrupt: /TS was active, and is now inactive.
703		if (tms->talk_status == 1)
	565	if (m_talk_status == 1)
704	566	{
705		tms->talk_status = tms->speak_external = 0;
706		set_interrupt_state(tms, 1);
	567	m_talk_status = m_speak_external = 0;
	568	set_interrupt_state(1);
707	569	}
708	570	}
709	571	/* Note that TS being unset will also generate an interrupt when a STOP
r22818	r22819
716	578
717	579	***********************************************************************************************/
718	580
719		static int extract_bits(tms5220_state *tms, int count)
	581	int tms5220_device::extract_bits(int count)
720	582	{
721	583	int val = 0;
722	584
723		if (tms->speak_external)
	585	if (m_speak_external)
724	586	{
725	587	// extract from FIFO
726	588	while (count--)
727	589	{
728		val = (val << 1) | ((tms->fifo[tms->fifo_head] >> tms->fifo_bits_taken) & 1);
729		tms->fifo_bits_taken++;
730		if (tms->fifo_bits_taken >= 8)
	590	val = (val << 1) | ((m_fifo[m_fifo_head] >> m_fifo_bits_taken) & 1);
	591	m_fifo_bits_taken++;
	592	if (m_fifo_bits_taken >= 8)
731	593	{
732		tms->fifo_count--;
733		tms->fifo[tms->fifo_head] = 0; // zero the newly depleted fifo head byte
734		tms->fifo_head = (tms->fifo_head + 1) % FIFO_SIZE;
735		tms->fifo_bits_taken = 0;
736		update_status_and_ints(tms);
	594	m_fifo_count--;
	595	m_fifo[m_fifo_head] = 0; // zero the newly depleted fifo head byte
	596	m_fifo_head = (m_fifo_head + 1) % FIFO_SIZE;
	597	m_fifo_bits_taken = 0;
	598	update_status_and_ints();
737	599	}
738	600	}
739	601	}
740	602	else
741	603	{
742	604	// extract from VSM (speech ROM)
743		if (tms->intf->read)
744		val = (* tms->intf->read)(tms->device, count);
	605	if (m_speechrom)
	606	val = m_speechrom->read(count);
745	607	}
746	608
747	609	return val;
r22818	r22819
753	615
754	616	***********************************************************************************************/
755	617
756		static int tms5220_status_read(tms5220_state *tms)
	618	int tms5220_device::status_read()
757	619	{
758		if (tms->RDB_flag)
	620	if (m_RDB_flag)
759	621	{   /* if last command was read, return data register */
760		tms->RDB_flag = FALSE;
761		return(tms->data_register);
	622	m_RDB_flag = FALSE;
	623	return(m_data_register);
762	624	}
763	625	else
764	626	{   /* read status */
765	627
766	628	/* clear the interrupt pin on status read */
767		set_interrupt_state(tms, 0);
	629	set_interrupt_state(0);
768	630	#ifdef DEBUG_PIN_READS
769		logerror("Status read: TS=%d BL=%d BE=%d\n", tms->talk_status, tms->buffer_low, tms->buffer_empty);
	631	logerror("Status read: TS=%d BL=%d BE=%d\n", m_talk_status, m_buffer_low, m_buffer_empty);
770	632	#endif
771	633
772		return (tms->talk_status << 7) | (tms->buffer_low << 6) | (tms->buffer_empty << 5);
	634	return (m_talk_status << 7) | (m_buffer_low << 6) | (m_buffer_empty << 5);
773	635	}
774	636	}
775	637
r22818	r22819
780	642
781	643	***********************************************************************************************/
782	644
783		static int tms5220_ready_read(tms5220_state *tms)
	645	int tms5220_device::ready_read()
784	646	{
785	647	#ifdef DEBUG_PIN_READS
786		logerror("ready_read: ready pin read, io_ready is %d, fifo count is %d\n", tms->io_ready, tms->fifo_count);
	648	logerror("ready_read: ready pin read, io_ready is %d, fifo count is %d\n", m_io_ready, m_fifo_count);
787	649	#endif
788		return ((tms->fifo_count < FIFO_SIZE)||(!tms->speak_external)) && tms->io_ready;
	650	return ((m_fifo_count < FIFO_SIZE)||(!m_speak_external)) && m_io_ready;
789	651	}
790	652
791	653
r22818	r22819
797	659
798	660	***********************************************************************************************/
799	661
800		static int tms5220_cycles_to_ready(tms5220_state *tms)
	662	int tms5220_device::cycles_to_ready()
801	663	{
802	664	int answer;
803	665
804	666
805		if (tms5220_ready_read(tms))
	667	if (ready_read())
806	668	answer = 0;
807	669	else
808	670	{
809	671	int val;
810		int samples_per_frame = tms->subc_reload?200:304; // either (13 A cycles + 12 B cycles) * 8 interps for normal SPEAK/SPKEXT, or (13*2 A cycles + 12 B cycles) * 8 interps for SPKSLOW
811		int current_sample = ((tms->PC*(3-tms->subc_reload))+((tms->subc_reload?38:25)*tms->IP));
	672	int samples_per_frame = m_subc_reload?200:304; // either (13 A cycles + 12 B cycles) * 8 interps for normal SPEAK/SPKEXT, or (13*2 A cycles + 12 B cycles) * 8 interps for SPKSLOW
	673	int current_sample = ((m_PC*(3-m_subc_reload))+((m_subc_reload?38:25)*m_IP));
812	674	answer = samples_per_frame-current_sample+8;
813	675
814		// total number of bits available in current byte is (8 - tms->fifo_bits_taken)
	676	// total number of bits available in current byte is (8 - m_fifo_bits_taken)
815	677	// if more than 4 are available, we need to check the energy
816		if (tms->fifo_bits_taken < 4)
	678	if (m_fifo_bits_taken < 4)
817	679	{
818	680	// read energy
819		val = (tms->fifo[tms->fifo_head] >> tms->fifo_bits_taken) & 0xf;
	681	val = (m_fifo[m_fifo_head] >> m_fifo_bits_taken) & 0xf;
820	682	if (val == 0)
821	683	/* 0 -> silence frame: we will only read 4 bits, and we will
822	684	* therefore need to read another frame before the FIFO is not
823	685	* full any more */
824		answer += tms->subc_reload?200:304;
	686	answer += m_subc_reload?200:304;
825	687	/* 15 -> stop frame, we will only read 4 bits, but the FIFO will
826	688	* we cleared; otherwise, we need to parse the repeat flag (1 bit)
827	689	* and the pitch (6 bits), so everything will be OK. */
r22818	r22819
838	700
839	701	***********************************************************************************************/
840	702
841		static int tms5220_int_read(tms5220_state *tms)
	703	int tms5220_device::int_read()
842	704	{
843	705	#ifdef DEBUG_PIN_READS
844		logerror("int_read: irq pin read, state is %d\n", tms->irq_pin);
	706	logerror("int_read: irq pin read, state is %d\n", m_irq_pin);
845	707	#endif
846		return tms->irq_pin;
	708	return m_irq_pin;
847	709	}
848	710
849	711
r22818	r22819
853	715
854	716	***********************************************************************************************/
855	717
856		static void tms5220_process(tms5220_state *tms, INT16 *buffer, unsigned int size)
	718	void tms5220_device::process(INT16 *buffer, unsigned int size)
857	719	{
858	720	int buf_count=0;
859	721	int i, bitout, zpar;
r22818	r22819
861	723
862	724	/* the following gotos are probably safe to remove */
863	725	/* if we're empty and still not speaking, fill with nothingness */
864		if (!tms->speaking_now)
	726	if (!m_speaking_now)
865	727	goto empty;
866	728
867	729	/* if speak external is set, but talk status is not (yet) set,
868	730	wait for buffer low to clear */
869		if (!tms->talk_status && tms->speak_external && tms->buffer_low)
	731	if (!m_talk_status && m_speak_external && m_buffer_low)
870	732	goto empty;
871	733
872	734	/* loop until the buffer is full or we've stopped speaking */
873		while ((size > 0) && tms->speaking_now)
	735	while ((size > 0) && m_speaking_now)
874	736	{
875	737	/* if it is the appropriate time to update the old energy/pitch idxes,
876	738	* i.e. when IP=7, PC=12, T=17, subcycle=2, do so. Since IP=7 PC=12 T=17
877	739	* is JUST BEFORE the transition to IP=0 PC=0 T=0 sybcycle=(0 or 1),
878	740	* which happens 4 T-cycles later), we change on the latter.*/
879		if ((tms->IP == 0) && (tms->PC == 0) && (tms->subcycle < 2))
	741	if ((m_IP == 0) && (m_PC == 0) && (m_subcycle < 2))
880	742	{
881		tms->OLDE = (tms->new_frame_energy_idx == 0);
882		tms->OLDP = (tms->new_frame_pitch_idx == 0);
	743	m_OLDE = (m_new_frame_energy_idx == 0);
	744	m_OLDP = (m_new_frame_pitch_idx == 0);
883	745	}
884	746
885	747	/* if we're ready for a new frame to be applied, i.e. when IP=0, PC=12, Sub=1
886	748	* (In reality, the frame was really loaded incrementally during the entire IP=0
887	749	* PC=x time period, but it doesn't affect anything until IP=0 PC=12 happens)
888	750	*/
889		if ((tms->IP == 0) && (tms->PC == 12) && (tms->subcycle == 1))
	751	if ((m_IP == 0) && (m_PC == 12) && (m_subcycle == 1))
890	752	{
891	753	// HACK for regression testing, be sure to comment out before release!
892		//tms->RNG = 0x1234;
	754	//m_RNG = 0x1234;
893	755	// end HACK
894	756
895	757	/* appropriately override the interp count if needed; this will be incremented after the frame parse! */
896		tms->IP = reload_table[tms->tms5220c_rate&0x3];
	758	m_IP = reload_table[m_tms5220c_rate&0x3];
897	759
898	760	#ifdef PERFECT_INTERPOLATION_HACK
899	761	/* remember previous frame energy, pitch, and coefficients */
900		tms->old_frame_energy_idx = tms->new_frame_energy_idx;
901		tms->old_frame_pitch_idx = tms->new_frame_pitch_idx;
902		for (i = 0; i < tms->coeff->num_k; i++)
903		tms->old_frame_k_idx[i] = tms->new_frame_k_idx[i];
	762	m_old_frame_energy_idx = m_new_frame_energy_idx;
	763	m_old_frame_pitch_idx = m_new_frame_pitch_idx;
	764	for (i = 0; i < m_coeff->num_k; i++)
	765	m_old_frame_k_idx[i] = m_new_frame_k_idx[i];
904	766	#endif
905	767
906	768	/* if the talk status was clear last frame, halt speech now. */
907		if (tms->talk_status == 0)
	769	if (m_talk_status == 0)
908	770	{
909	771	#ifdef DEBUG_GENERATION
910	772	fprintf(stderr,"tms5220_process: processing frame: talk status = 0 caused by stop frame or buffer empty, halting speech.\n");
911	773	#endif
912		tms->speaking_now = 0; // finally halt speech
	774	m_speaking_now = 0; // finally halt speech
913	775	goto empty;
914	776	}
915	777
916	778
917	779	/* Parse a new frame into the new_target_energy, new_target_pitch and new_target_k[] */
918		parse_frame(tms);
	780	parse_frame();
919	781	#ifdef DEBUG_PARSE_FRAME_DUMP
920	782	fprintf(stderr,"\n");
921	783	#endif
r22818	r22819
923	785	/* if the new frame is a stop frame, set an interrupt and set talk status to 0 */
924	786	if (NEW_FRAME_STOP_FLAG == 1)
925	787	{
926		tms->talk_status = tms->speak_external = 0;
927		set_interrupt_state(tms, 1);
928		update_status_and_ints(tms);
	788	m_talk_status = m_speak_external = 0;
	789	set_interrupt_state(1);
	790	update_status_and_ints();
929	791	}
930	792
931	793	/* in all cases where interpolation would be inhibited, set the inhibit flag; otherwise clear it.
r22818	r22819
937	799	if ( ((OLD_FRAME_UNVOICED_FLAG == 0) && (NEW_FRAME_UNVOICED_FLAG == 1))
938	800	|| ((OLD_FRAME_UNVOICED_FLAG == 1) && (NEW_FRAME_UNVOICED_FLAG == 0)) /* this line needs further investigation, starwars tie fighters may sound better without it */
939	801	|| ((OLD_FRAME_SILENCE_FLAG == 1) && (NEW_FRAME_SILENCE_FLAG == 0)) )
940		tms->inhibit = 1;
	802	m_inhibit = 1;
941	803	else // normal frame, normal interpolation
942		tms->inhibit = 0;
	804	m_inhibit = 0;
943	805
944	806	/* load new frame targets from tables, using parsed indices */
945		tms->target_energy = tms->coeff->energytable[tms->new_frame_energy_idx];
946		tms->target_pitch = tms->coeff->pitchtable[tms->new_frame_pitch_idx];
	807	m_target_energy = m_coeff->energytable[m_new_frame_energy_idx];
	808	m_target_pitch = m_coeff->pitchtable[m_new_frame_pitch_idx];
947	809	zpar = NEW_FRAME_UNVOICED_FLAG; // find out if parameters k5-k10 should be zeroed
948	810	for (i = 0; i < 4; i++)
949		tms->target_k[i] = tms->coeff->ktable[i][tms->new_frame_k_idx[i]];
950		for (i = 4; i < tms->coeff->num_k; i++)
951		tms->target_k[i] = (tms->coeff->ktable[i][tms->new_frame_k_idx[i]] * (1-zpar));
	811	m_target_k[i] = m_coeff->ktable[i][m_new_frame_k_idx[i]];
	812	for (i = 4; i < m_coeff->num_k; i++)
	813	m_target_k[i] = (m_coeff->ktable[i][m_new_frame_k_idx[i]] * (1-zpar));
952	814
953	815	#ifdef DEBUG_GENERATION
954	816	/* Debug info for current parsed frame */
955		fprintf(stderr, "OLDE: %d; OLDP: %d; ", tms->OLDE, tms->OLDP);
	817	fprintf(stderr, "OLDE: %d; OLDP: %d; ", m_OLDE, m_OLDP);
956	818	fprintf(stderr,"Processing frame: ");
957		if (tms->inhibit == 0)
	819	if (m_inhibit == 0)
958	820	fprintf(stderr, "Normal Frame\n");
959	821	else
960	822	fprintf(stderr,"Interpolation Inhibited\n");
961		fprintf(stderr,"*** current Energy, Pitch and Ks =      %04d,   %04d, %04d, %04d, %04d, %04d, %04d, %04d, %04d, %04d, %04d, %04d\n",tms->current_energy, tms->current_pitch, tms->current_k[0], tms->current_k[1], tms->current_k[2], tms->current_k[3], tms->current_k[4], tms->current_k[5], tms->current_k[6], tms->current_k[7], tms->current_k[8], tms->current_k[9]);
962		fprintf(stderr,"*** target Energy(idx), Pitch, and Ks = %04d(%x),%04d, %04d, %04d, %04d, %04d, %04d, %04d, %04d, %04d, %04d, %04d\n",tms->target_energy, tms->new_frame_energy_idx, tms->target_pitch, tms->target_k[0], tms->target_k[1], tms->target_k[2], tms->target_k[3], tms->target_k[4], tms->target_k[5], tms->target_k[6], tms->target_k[7], tms->target_k[8], tms->target_k[9]);
	823	fprintf(stderr,"*** current Energy, Pitch and Ks =      %04d,   %04d, %04d, %04d, %04d, %04d, %04d, %04d, %04d, %04d, %04d, %04d\n",m_current_energy, m_current_pitch, m_current_k[0], m_current_k[1], m_current_k[2], m_current_k[3], m_current_k[4], m_current_k[5], m_current_k[6], m_current_k[7], m_current_k[8], m_current_k[9]);
	824	fprintf(stderr,"*** target Energy(idx), Pitch, and Ks = %04d(%x),%04d, %04d, %04d, %04d, %04d, %04d, %04d, %04d, %04d, %04d, %04d\n",m_target_energy, m_new_frame_energy_idx, m_target_pitch, m_target_k[0], m_target_k[1], m_target_k[2], m_target_k[3], m_target_k[4], m_target_k[5], m_target_k[6], m_target_k[7], m_target_k[8], m_target_k[9]);
963	825	#endif
964	826
965	827	/* if TS is now 0, ramp the energy down to 0. Is this really correct to hardware? */
966		if (tms->talk_status == 0)
	828	if (m_talk_status == 0)
967	829	{
968	830	#ifdef DEBUG_GENERATION
969	831	fprintf(stderr,"Talk status is 0, forcing target energy to 0\n");
970	832	#endif
971		tms->target_energy = 0;
	833	m_target_energy = 0;
972	834	}
973	835	}
974	836	else // Not a new frame, just interpolate the existing frame.
975	837	{
976		int inhibit_state = ((tms->inhibit==1)&&(tms->IP != 0)); // disable inhibit when reaching the last interp period, but don't overwrite the tms->inhibit value
	838	int inhibit_state = ((m_inhibit==1)&&(m_IP != 0)); // disable inhibit when reaching the last interp period, but don't overwrite the m_inhibit value
977	839	#ifdef PERFECT_INTERPOLATION_HACK
978		int samples_per_frame = tms->subc_reload?175:266; // either (13 A cycles + 12 B cycles) * 7 interps for normal SPEAK/SPKEXT, or (13*2 A cycles + 12 B cycles) * 7 interps for SPKSLOW
979		//int samples_per_frame = tms->subc_reload?200:304; // either (13 A cycles + 12 B cycles) * 8 interps for normal SPEAK/SPKEXT, or (13*2 A cycles + 12 B cycles) * 8 interps for SPKSLOW
980		int current_sample = (tms->subcycle - tms->subc_reload)+(tms->PC*(3-tms->subc_reload))+((tms->subc_reload?25:38)*((tms->IP-1)&7));
	840	int samples_per_frame = m_subc_reload?175:266; // either (13 A cycles + 12 B cycles) * 7 interps for normal SPEAK/SPKEXT, or (13*2 A cycles + 12 B cycles) * 7 interps for SPKSLOW
	841	//int samples_per_frame = m_subc_reload?200:304; // either (13 A cycles + 12 B cycles) * 8 interps for normal SPEAK/SPKEXT, or (13*2 A cycles + 12 B cycles) * 8 interps for SPKSLOW
	842	int current_sample = (m_subcycle - m_subc_reload)+(m_PC*(3-m_subc_reload))+((m_subc_reload?25:38)*((m_IP-1)&7));
981	843
982	844	zpar = OLD_FRAME_UNVOICED_FLAG;
983	845	//fprintf(stderr, "CS: %03d", current_sample);
984	846	// reset the current energy, pitch, etc to what it was at frame start
985		tms->current_energy = tms->coeff->energytable[tms->old_frame_energy_idx];
986		tms->current_pitch = tms->coeff->pitchtable[tms->old_frame_pitch_idx];
	847	m_current_energy = m_coeff->energytable[m_old_frame_energy_idx];
	848	m_current_pitch = m_coeff->pitchtable[m_old_frame_pitch_idx];
987	849	for (i = 0; i < 4; i++)
988		tms->current_k[i] = tms->coeff->ktable[i][tms->old_frame_k_idx[i]];
989		for (i = 4; i < tms->coeff->num_k; i++)
990		tms->current_k[i] = (tms->coeff->ktable[i][tms->old_frame_k_idx[i]] * (1-zpar));
	850	m_current_k[i] = m_coeff->ktable[i][m_old_frame_k_idx[i]];
	851	for (i = 4; i < m_coeff->num_k; i++)
	852	m_current_k[i] = (m_coeff->ktable[i][m_old_frame_k_idx[i]] * (1-zpar));
991	853	// now adjust each value to be exactly correct for each of the samples per frame
992		if (tms->IP != 0) // if we're still interpolating...
	854	if (m_IP != 0) // if we're still interpolating...
993	855	{
994		tms->current_energy += (((tms->target_energy - tms->current_energy)*(1-inhibit_state))*current_sample)/samples_per_frame;
995		tms->current_pitch += (((tms->target_pitch - tms->current_pitch)*(1-inhibit_state))*current_sample)/samples_per_frame;
996		for (i = 0; i < tms->coeff->num_k; i++)
997		tms->current_k[i] += (((tms->target_k[i] - tms->current_k[i])*(1-inhibit_state))*current_sample)/samples_per_frame;
	856	m_current_energy += (((m_target_energy - m_current_energy)*(1-inhibit_state))*current_sample)/samples_per_frame;
	857	m_current_pitch += (((m_target_pitch - m_current_pitch)*(1-inhibit_state))*current_sample)/samples_per_frame;
	858	for (i = 0; i < m_coeff->num_k; i++)
	859	m_current_k[i] += (((m_target_k[i] - m_current_k[i])*(1-inhibit_state))*current_sample)/samples_per_frame;
998	860	}
999	861	else // we're done, play this frame for 1/8 frame.
1000	862	{
1001		tms->current_energy = tms->target_energy;
1002		tms->current_pitch = tms->target_pitch;
1003		for (i = 0; i < tms->coeff->num_k; i++)
1004		tms->current_k[i] = tms->target_k[i];
	863	m_current_energy = m_target_energy;
	864	m_current_pitch = m_target_pitch;
	865	for (i = 0; i < m_coeff->num_k; i++)
	866	m_current_k[i] = m_target_k[i];
1005	867	}
1006	868	#else
1007	869	//Updates to parameters only happen on subcycle '2' (B cycle) of PCs.
1008		if (tms->subcycle == 2)
	870	if (m_subcycle == 2)
1009	871	{
1010		switch(tms->PC)
	872	switch(m_PC)
1011	873	{
1012	874	case 0: /* PC = 0, B cycle, write updated energy */
1013		tms->current_energy += (((tms->target_energy - tms->current_energy)*(1-inhibit_state)) INTERP_SHIFT);
	875	m_current_energy += (((m_target_energy - m_current_energy)*(1-inhibit_state)) INTERP_SHIFT);
1014	876	break;
1015	877	case 1: /* PC = 1, B cycle, write updated pitch */
1016		tms->current_pitch += (((tms->target_pitch - tms->current_pitch)*(1-inhibit_state)) INTERP_SHIFT);
	878	m_current_pitch += (((m_target_pitch - m_current_pitch)*(1-inhibit_state)) INTERP_SHIFT);
1017	879	break;
1018	880	case 2: case 3: case 4: case 5: case 6: case 7: case 8: case 9: case 10: case 11:
1019	881	/* PC = 2 through 11, B cycle, write updated K1 through K10 */
1020		tms->current_k[tms->PC-2] += (((tms->target_k[tms->PC-2] - tms->current_k[tms->PC-2])*(1-inhibit_state)) INTERP_SHIFT);
	882	m_current_k[m_PC-2] += (((m_target_k[m_PC-2] - m_current_k[m_PC-2])*(1-inhibit_state)) INTERP_SHIFT);
1021	883	break;
1022	884	case 12: /* PC = 12, do nothing */
1023	885	break;
r22818	r22819
1030	892	if (OLD_FRAME_UNVOICED_FLAG == 1)
1031	893	{
1032	894	// generate unvoiced samples here
1033		if (tms->RNG & 1)
1034		tms->excitation_data = ~0x3F; /* according to the patent it is (either + or -) half of the maximum value in the chirp table, so either 01000000(0x40) or 11000000(0xC0)*/
	895	if (m_RNG & 1)
	896	m_excitation_data = ~0x3F; /* according to the patent it is (either + or -) half of the maximum value in the chirp table, so either 01000000(0x40) or 11000000(0xC0)*/
1035	897	else
1036		tms->excitation_data = 0x40;
	898	m_excitation_data = 0x40;
1037	899	}
1038	900	else /* (OLD_FRAME_UNVOICED_FLAG == 0) */
1039	901	{
r22818	r22819
1044	906	* and if the address reaches that point the ADDRESS incrementer is
1045	907	* disabled, forcing all samples beyond 51d to be == 51d
1046	908	*/
1047		if (tms->pitch_count >= 51)
1048		tms->excitation_data = tms->coeff->chirptable[51];
1049		else /*tms->pitch_count < 51*/
1050		tms->excitation_data = tms->coeff->chirptable[tms->pitch_count];
	909	if (m_pitch_count >= 51)
	910	m_excitation_data = m_coeff->chirptable[51];
	911	else /*m_pitch_count < 51*/
	912	m_excitation_data = m_coeff->chirptable[m_pitch_count];
1051	913	}
1052	914
1053	915	// Update LFSR *20* times every sample (once per T cycle), like patent shows
1054	916	for (i=0; i<20; i++)
1055	917	{
1056		bitout = ((tms->RNG >> 12) & 1) ^
1057		((tms->RNG >>  3) & 1) ^
1058		((tms->RNG >>  2) & 1) ^
1059		((tms->RNG >>  0) & 1);
1060		tms->RNG <<= 1;
1061		tms->RNG |= bitout;
	918	bitout = ((m_RNG >> 12) & 1) ^
	919	((m_RNG >>  3) & 1) ^
	920	((m_RNG >>  2) & 1) ^
	921	((m_RNG >>  0) & 1);
	922	m_RNG <<= 1;
	923	m_RNG |= bitout;
1062	924	}
1063		this_sample = lattice_filter(tms); /* execute lattice filter */
	925	this_sample = lattice_filter(); /* execute lattice filter */
1064	926	#ifdef DEBUG_GENERATION_VERBOSE
1065		//fprintf(stderr,"C:%01d; ",tms->subcycle);
1066		fprintf(stderr,"IP:%01d PC:%02d X:%04d E:%03d P:%03d Pc:%03d ",tms->IP, tms->PC, tms->excitation_data, tms->current_energy, tms->current_pitch, tms->pitch_count);
1067		//fprintf(stderr,"X:%04d E:%03d P:%03d Pc:%03d ", tms->excitation_data, tms->current_energy, tms->current_pitch, tms->pitch_count);
	927	//fprintf(stderr,"C:%01d; ",m_subcycle);
	928	fprintf(stderr,"IP:%01d PC:%02d X:%04d E:%03d P:%03d Pc:%03d ",m_IP, m_PC, m_excitation_data, m_current_energy, m_current_pitch, m_pitch_count);
	929	//fprintf(stderr,"X:%04d E:%03d P:%03d Pc:%03d ", m_excitation_data, m_current_energy, m_current_pitch, m_pitch_count);
1068	930	for (i=0; i<10; i++)
1069		fprintf(stderr,"K%d:%04d ", i+1, tms->current_k[i]);
	931	fprintf(stderr,"K%d:%04d ", i+1, m_current_k[i]);
1070	932	fprintf(stderr,"Out:%06d", this_sample);
1071	933	fprintf(stderr,"\n");
1072	934	#endif
1073	935	/* next, force result to 14 bits (since its possible that the addition at the final (k1) stage of the lattice overflowed) */
1074	936	while (this_sample > 16383) this_sample -= 32768;
1075	937	while (this_sample < -16384) this_sample += 32768;
1076		if (tms->digital_select == 0) // analog SPK pin output is only 8 bits, with clipping
	938	if (m_digital_select == 0) // analog SPK pin output is only 8 bits, with clipping
1077	939	buffer[buf_count] = clip_analog(this_sample);
1078	940	else // digital I/O pin output is 12 bits
1079	941	{
r22818	r22819
1092	954	}
1093	955	// Update all counts
1094	956
1095		tms->subcycle++;
1096		if ((tms->subcycle == 2) && (tms->PC == 12))
	957	m_subcycle++;
	958	if ((m_subcycle == 2) && (m_PC == 12))
1097	959	{
1098	960	/* Circuit 412 in the patent acts a reset, resetting the pitch counter to 0
1099	961	* if INHIBIT was true during the most recent frame transition.
1100	962	* The exact time this occurs is betwen IP=7, PC=12 sub=0, T=t12
1101		* and tms->IP = 0, PC=0 sub=0, T=t12, a period of exactly 20 cycles,
	963	* and m_IP = 0, PC=0 sub=0, T=t12, a period of exactly 20 cycles,
1102	964	* which overlaps the time OLDE and OLDP are updated at IP=7 PC=12 T17
1103	965	* (and hence INHIBIT itself 2 t-cycles later). We do it here because it is
1104	966	* convenient and should make no difference in output.
1105	967	*/
1106		if ((tms->IP == 7)&&(tms->inhibit==1)) tms->pitch_count = 0;
1107		tms->subcycle = tms->subc_reload;
1108		tms->PC = 0;
1109		tms->IP++;
1110		tms->IP&=0x7;
	968	if ((m_IP == 7)&&(m_inhibit==1)) m_pitch_count = 0;
	969	m_subcycle = m_subc_reload;
	970	m_PC = 0;
	971	m_IP++;
	972	m_IP&=0x7;
1111	973	}
1112		else if (tms->subcycle == 3)
	974	else if (m_subcycle == 3)
1113	975	{
1114		tms->subcycle = tms->subc_reload;
1115		tms->PC++;
	976	m_subcycle = m_subc_reload;
	977	m_PC++;
1116	978	}
1117		tms->pitch_count++;
1118		if (tms->pitch_count >= tms->current_pitch) tms->pitch_count = 0;
1119		tms->pitch_count &= 0x1FF;
	979	m_pitch_count++;
	980	if (m_pitch_count >= m_current_pitch) m_pitch_count = 0;
	981	m_pitch_count &= 0x1FF;
1120	982	buf_count++;
1121	983	size--;
1122	984	}
r22818	r22819
1125	987
1126	988	while (size > 0)
1127	989	{
1128		tms->subcycle++;
1129		if ((tms->subcycle == 2) && (tms->PC == 12))
	990	m_subcycle++;
	991	if ((m_subcycle == 2) && (m_PC == 12))
1130	992	{
1131		tms->subcycle = tms->subc_reload;
1132		tms->PC = 0;
1133		tms->IP++;
1134		tms->IP&=0x7;
	993	m_subcycle = m_subc_reload;
	994	m_PC = 0;
	995	m_IP++;
	996	m_IP&=0x7;
1135	997	}
1136		else if (tms->subcycle == 3)
	998	else if (m_subcycle == 3)
1137	999	{
1138		tms->subcycle = tms->subc_reload;
1139		tms->PC++;
	1000	m_subcycle = m_subc_reload;
	1001	m_PC++;
1140	1002	}
1141	1003	buffer[buf_count] = -1; /* should be just -1; actual chip outputs -1 every idle sample; (cf note in data sheet, p 10, table 4) */
1142	1004	buf_count++;
r22818	r22819
1215	1077
1216	1078	***********************************************************************************************/
1217	1079
1218		static INT32 lattice_filter(tms5220_state *tms)
	1080	INT32 tms5220_device::lattice_filter()
1219	1081	{
1220	1082	// Lattice filter here
1221	1083	// Aug/05/07: redone as unrolled loop, for clarity - LN
1222	1084	/* Originally Copied verbatim from table I in US patent 4,209,804, now updated to be in same order as the actual chip does it, not that it matters.
1223	1085	notation equivalencies from table:
1224		Yn(i) == tms->u[n-1]
1225		Kn = tms->current_k[n-1]
1226		bn = tms->x[n-1]
	1086	Yn(i) == m_u[n-1]
	1087	Kn = m_current_k[n-1]
	1088	bn = m_x[n-1]
1227	1089	*/
1228		tms->u[10] = matrix_multiply(tms->previous_energy, (tms->excitation_data<<6));  //Y(11)
1229		tms->u[9] = tms->u[10] - matrix_multiply(tms->current_k[9], tms->x[9]);
1230		tms->u[8] = tms->u[9] - matrix_multiply(tms->current_k[8], tms->x[8]);
1231		tms->u[7] = tms->u[8] - matrix_multiply(tms->current_k[7], tms->x[7]);
1232		tms->u[6] = tms->u[7] - matrix_multiply(tms->current_k[6], tms->x[6]);
1233		tms->u[5] = tms->u[6] - matrix_multiply(tms->current_k[5], tms->x[5]);
1234		tms->u[4] = tms->u[5] - matrix_multiply(tms->current_k[4], tms->x[4]);
1235		tms->u[3] = tms->u[4] - matrix_multiply(tms->current_k[3], tms->x[3]);
1236		tms->u[2] = tms->u[3] - matrix_multiply(tms->current_k[2], tms->x[2]);
1237		tms->u[1] = tms->u[2] - matrix_multiply(tms->current_k[1], tms->x[1]);
1238		tms->u[0] = tms->u[1] - matrix_multiply(tms->current_k[0], tms->x[0]);
1239		tms->x[9] = tms->x[8] + matrix_multiply(tms->current_k[8], tms->u[8]);
1240		tms->x[8] = tms->x[7] + matrix_multiply(tms->current_k[7], tms->u[7]);
1241		tms->x[7] = tms->x[6] + matrix_multiply(tms->current_k[6], tms->u[6]);
1242		tms->x[6] = tms->x[5] + matrix_multiply(tms->current_k[5], tms->u[5]);
1243		tms->x[5] = tms->x[4] + matrix_multiply(tms->current_k[4], tms->u[4]);
1244		tms->x[4] = tms->x[3] + matrix_multiply(tms->current_k[3], tms->u[3]);
1245		tms->x[3] = tms->x[2] + matrix_multiply(tms->current_k[2], tms->u[2]);
1246		tms->x[2] = tms->x[1] + matrix_multiply(tms->current_k[1], tms->u[1]);
1247		tms->x[1] = tms->x[0] + matrix_multiply(tms->current_k[0], tms->u[0]);
1248		tms->x[0] = tms->u[0];
1249		tms->previous_energy = tms->current_energy;
	1090	m_u[10] = matrix_multiply(m_previous_energy, (m_excitation_data<<6));  //Y(11)
	1091	m_u[9] = m_u[10] - matrix_multiply(m_current_k[9], m_x[9]);
	1092	m_u[8] = m_u[9] - matrix_multiply(m_current_k[8], m_x[8]);
	1093	m_u[7] = m_u[8] - matrix_multiply(m_current_k[7], m_x[7]);
	1094	m_u[6] = m_u[7] - matrix_multiply(m_current_k[6], m_x[6]);
	1095	m_u[5] = m_u[6] - matrix_multiply(m_current_k[5], m_x[5]);
	1096	m_u[4] = m_u[5] - matrix_multiply(m_current_k[4], m_x[4]);
	1097	m_u[3] = m_u[4] - matrix_multiply(m_current_k[3], m_x[3]);
	1098	m_u[2] = m_u[3] - matrix_multiply(m_current_k[2], m_x[2]);
	1099	m_u[1] = m_u[2] - matrix_multiply(m_current_k[1], m_x[1]);
	1100	m_u[0] = m_u[1] - matrix_multiply(m_current_k[0], m_x[0]);
	1101	m_x[9] = m_x[8] + matrix_multiply(m_current_k[8], m_u[8]);
	1102	m_x[8] = m_x[7] + matrix_multiply(m_current_k[7], m_u[7]);
	1103	m_x[7] = m_x[6] + matrix_multiply(m_current_k[6], m_u[6]);
	1104	m_x[6] = m_x[5] + matrix_multiply(m_current_k[5], m_u[5]);
	1105	m_x[5] = m_x[4] + matrix_multiply(m_current_k[4], m_u[4]);
	1106	m_x[4] = m_x[3] + matrix_multiply(m_current_k[3], m_u[3]);
	1107	m_x[3] = m_x[2] + matrix_multiply(m_current_k[2], m_u[2]);
	1108	m_x[2] = m_x[1] + matrix_multiply(m_current_k[1], m_u[1]);
	1109	m_x[1] = m_x[0] + matrix_multiply(m_current_k[0], m_u[0]);
	1110	m_x[0] = m_u[0];
	1111	m_previous_energy = m_current_energy;
1250	1112	#ifdef DEBUG_LATTICE
1251	1113	int i;
1252		fprintf(stderr,"V:%04d ", tms->u[10]);
	1114	fprintf(stderr,"V:%04d ", m_u[10]);
1253	1115	for (i = 9; i >= 0; i--)
1254	1116	{
1255		fprintf(stderr,"Y%d:%04d ", i+1, tms->u[i]);
1256		fprintf(stderr,"b%d:%04d ", i+1, tms->x[i]);
	1117	fprintf(stderr,"Y%d:%04d ", i+1, m_u[i]);
	1118	fprintf(stderr,"b%d:%04d ", i+1, m_x[i]);
1257	1119	if ((i % 5) == 0) fprintf(stderr,"\n");
1258	1120	}
1259	1121	#endif
1260		return tms->u[0];
	1122	return m_u[0];
1261	1123	}
1262	1124
1263	1125
r22818	r22819
1267	1129
1268	1130	***********************************************************************************************/
1269	1131
1270		static void process_command(tms5220_state *tms, unsigned char cmd)
	1132	void tms5220_device::process_command(unsigned char cmd)
1271	1133	{
1272	1134	#ifdef DEBUG_COMMAND_DUMP
1273	1135	fprintf(stderr,"process_command called with parameter %02X\n",cmd);
r22818	r22819
1276	1138	switch (cmd & 0x70)
1277	1139	{
1278	1140	case 0x10 : /* read byte */
1279		if (tms->talk_status == 0) /* TALKST must be clear for RDBY */
	1141	if (m_talk_status == 0) /* TALKST must be clear for RDBY */
1280	1142	{
1281		if (tms->schedule_dummy_read)
	1143	if (m_schedule_dummy_read)
1282	1144	{
1283		tms->schedule_dummy_read = FALSE;
1284		if (tms->intf->read)
1285		(*tms->intf->read)(tms->device, 1);
	1145	m_schedule_dummy_read = FALSE;
	1146	if (m_speechrom)
	1147	m_speechrom->read(1);
1286	1148	}
1287		if (tms->intf->read)
1288		tms->data_register = (*tms->intf->read)(tms->device, 8);    /* read one byte from speech ROM... */
1289		tms->RDB_flag = TRUE;
	1149	if (m_speechrom)
	1150	m_data_register = m_speechrom->read(8);    /* read one byte from speech ROM... */
	1151	m_RDB_flag = TRUE;
1290	1152	}
1291	1153	break;
1292	1154
1293	1155	case 0x00: case 0x20: /* set rate (tms5220c only), otherwise NOP */
1294		if (tms->variant == TMS5220_IS_5220C)
	1156	if (m_variant == TMS5220_IS_5220C)
1295	1157	{
1296		tms->tms5220c_rate = cmd&0x0F;
	1158	m_tms5220c_rate = cmd&0x0F;
1297	1159	}
1298	1160	break;
1299	1161
1300	1162	case 0x30 : /* read and branch */
1301		if (tms->talk_status == 0) /* TALKST must be clear for RB */
	1163	if (m_talk_status == 0) /* TALKST must be clear for RB */
1302	1164	{
1303	1165	#ifdef VERBOSE
1304	1166	logerror("read and branch command received\n");
1305	1167	#endif
1306		tms->RDB_flag = FALSE;
1307		if (tms->intf->read_and_branch)
1308		(*tms->intf->read_and_branch)(tms->device);
	1168	m_RDB_flag = FALSE;
	1169	if (m_speechrom)
	1170	m_speechrom->read_and_branch();
1309	1171	}
1310	1172	break;
1311	1173
1312	1174	case 0x40 : /* load address */
1313		if (tms->talk_status == 0) /* TALKST must be clear for LA */
	1175	if (m_talk_status == 0) /* TALKST must be clear for LA */
1314	1176	{
1315	1177	/* tms5220 data sheet says that if we load only one 4-bit nibble, it won't work.
1316	1178	This code does not care about this. */
1317		if (tms->intf->load_address)
1318		(*tms->intf->load_address)(tms->device, cmd & 0x0f);
1319		tms->schedule_dummy_read = TRUE;
	1179	if (m_speechrom)
	1180	m_speechrom->load_address(cmd & 0x0f);
	1181	m_schedule_dummy_read = TRUE;
1320	1182	}
1321	1183	break;
1322	1184
1323	1185	case 0x50 : /* speak */
1324		if (tms->schedule_dummy_read)
	1186	if (m_schedule_dummy_read)
1325	1187	{
1326		tms->schedule_dummy_read = FALSE;
1327		if (tms->intf->read)
1328		(*tms->intf->read)(tms->device, 1);
	1188	m_schedule_dummy_read = FALSE;
	1189	if (m_speechrom)
	1190	m_speechrom->read(1);
1329	1191	}
1330		tms->speaking_now = 1;
1331		tms->speak_external = 0;
1332		tms->talk_status = 1;  /* start immediately */
	1192	m_speaking_now = 1;
	1193	m_speak_external = 0;
	1194	m_talk_status = 1;  /* start immediately */
1333	1195	/* clear out variables before speaking */
1334	1196	// TODO: similar to the victory case described above, but for VSM speech
1335		tms->subcycle = tms->subc_reload;
1336		tms->PC = 0;
1337		tms->IP = reload_table[tms->tms5220c_rate&0x3];
1338		tms->new_frame_energy_idx = 0;
1339		tms->new_frame_pitch_idx = 0;
	1197	m_subcycle = m_subc_reload;
	1198	m_PC = 0;
	1199	m_IP = reload_table[m_tms5220c_rate&0x3];
	1200	m_new_frame_energy_idx = 0;
	1201	m_new_frame_pitch_idx = 0;
1340	1202	int i;
1341	1203	for (i = 0; i < 4; i++)
1342		tms->new_frame_k_idx[i] = 0;
	1204	m_new_frame_k_idx[i] = 0;
1343	1205	for (i = 4; i < 7; i++)
1344		tms->new_frame_k_idx[i] = 0xF;
1345		for (i = 7; i < tms->coeff->num_k; i++)
1346		tms->new_frame_k_idx[i] = 0x7;
	1206	m_new_frame_k_idx[i] = 0xF;
	1207	for (i = 7; i < m_coeff->num_k; i++)
	1208	m_new_frame_k_idx[i] = 0x7;
1347	1209	break;
1348	1210
1349	1211	case 0x60 : /* speak external */
1350	1212	//SPKEXT going active activates SPKEE which clears the fifo
1351		tms->fifo_head = tms->fifo_tail = tms->fifo_count = tms->fifo_bits_taken = 0;
1352		tms->speak_external = 1;
1353		tms->RDB_flag = FALSE;
	1213	m_fifo_head = m_fifo_tail = m_fifo_count = m_fifo_bits_taken = 0;
	1214	m_speak_external = 1;
	1215	m_RDB_flag = FALSE;
1354	1216	break;
1355	1217
1356	1218	case 0x70 : /* reset */
1357		if (tms->schedule_dummy_read)
	1219	if (m_schedule_dummy_read)
1358	1220	{
1359		tms->schedule_dummy_read = FALSE;
1360		if (tms->intf->read)
1361		(*tms->intf->read)(tms->device, 1);
	1221	m_schedule_dummy_read = FALSE;
	1222	if (m_speechrom)
	1223	m_speechrom->read(1);
1362	1224	}
1363		tms->device->reset();
	1225	reset();
1364	1226	break;
1365	1227	}
1366	1228
1367	1229	/* update the buffer low state */
1368		update_status_and_ints(tms);
	1230	update_status_and_ints();
1369	1231	}
1370	1232
1371	1233	/******************************************************************************************
r22818	r22819
1374	1236
1375	1237	******************************************************************************************/
1376	1238
1377		static void parse_frame(tms5220_state *tms)
	1239	void tms5220_device::parse_frame()
1378	1240	{
1379	1241	int indx, i, rep_flag;
1380	1242
r22818	r22819
1382	1244
1383	1245	/* if the chip is a tms5220C, and the rate mode is set to that each frame (0x04 bit set)
1384	1246	has a 2 bit rate preceding it, grab two bits here and store them as the rate; */
1385		if ((tms->variant == TMS5220_IS_5220C) && (tms->tms5220c_rate & 0x04))
	1247	if ((m_variant == TMS5220_IS_5220C) && (m_tms5220c_rate & 0x04))
1386	1248	{
1387		indx = extract_bits(tms, 2);
	1249	indx = extract_bits(2);
1388	1250	#ifdef DEBUG_PARSE_FRAME_DUMP
1389	1251	printbits(indx,2);
1390	1252	fprintf(stderr," ");
1391	1253	#endif
1392		tms->IP = reload_table[indx];
	1254	m_IP = reload_table[indx];
1393	1255	}
1394	1256	else // non-5220C and 5220C in fixed rate mode
1395		tms->IP = reload_table[tms->tms5220c_rate&0x3];
	1257	m_IP = reload_table[m_tms5220c_rate&0x3];
1396	1258
1397		update_status_and_ints(tms);
1398		if (!tms->talk_status) goto ranout;
	1259	update_status_and_ints();
	1260	if (!m_talk_status) goto ranout;
1399	1261
1400	1262	// attempt to extract the energy index
1401		tms->new_frame_energy_idx = extract_bits(tms,tms->coeff->energy_bits);
	1263	m_new_frame_energy_idx = extract_bits(m_coeff->energy_bits);
1402	1264	#ifdef DEBUG_PARSE_FRAME_DUMP
1403		printbits(tms->new_frame_energy_idx,tms->coeff->energy_bits);
	1265	printbits(m_new_frame_energy_idx,m_coeff->energy_bits);
1404	1266	fprintf(stderr," ");
1405	1267	#endif
1406		update_status_and_ints(tms);
1407		if (!tms->talk_status) goto ranout;
	1268	update_status_and_ints();
	1269	if (!m_talk_status) goto ranout;
1408	1270	// if the energy index is 0 or 15, we're done
1409		if ((tms->new_frame_energy_idx == 0) || (tms->new_frame_energy_idx == 15))
	1271	if ((m_new_frame_energy_idx == 0) || (m_new_frame_energy_idx == 15))
1410	1272	return;
1411	1273
1412	1274
1413	1275	// attempt to extract the repeat flag
1414		rep_flag = extract_bits(tms,1);
	1276	rep_flag = extract_bits(1);
1415	1277	#ifdef DEBUG_PARSE_FRAME_DUMP
1416	1278	printbits(rep_flag, 1);
1417	1279	fprintf(stderr," ");
1418	1280	#endif
1419	1281
1420	1282	// attempt to extract the pitch
1421		tms->new_frame_pitch_idx = extract_bits(tms,tms->coeff->pitch_bits);
	1283	m_new_frame_pitch_idx = extract_bits(m_coeff->pitch_bits);
1422	1284	#ifdef DEBUG_PARSE_FRAME_DUMP
1423		printbits(tms->new_frame_pitch_idx,tms->coeff->pitch_bits);
	1285	printbits(m_new_frame_pitch_idx,m_coeff->pitch_bits);
1424	1286	fprintf(stderr," ");
1425	1287	#endif
1426		update_status_and_ints(tms);
1427		if (!tms->talk_status) goto ranout;
	1288	update_status_and_ints();
	1289	if (!m_talk_status) goto ranout;
1428	1290	// if this is a repeat frame, just do nothing, it will reuse the old coefficients
1429	1291	if (rep_flag)
1430	1292	return;
r22818	r22819
1432	1294	// extract first 4 K coefficients
1433	1295	for (i = 0; i < 4; i++)
1434	1296	{
1435		tms->new_frame_k_idx[i] = extract_bits(tms,tms->coeff->kbits[i]);
	1297	m_new_frame_k_idx[i] = extract_bits(m_coeff->kbits[i]);
1436	1298	#ifdef DEBUG_PARSE_FRAME_DUMP
1437		printbits(tms->new_frame_k_idx[i],tms->coeff->kbits[i]);
	1299	printbits(m_new_frame_k_idx[i],m_coeff->kbits[i]);
1438	1300	fprintf(stderr," ");
1439	1301	#endif
1440		update_status_and_ints(tms);
1441		if (!tms->talk_status) goto ranout;
	1302	update_status_and_ints();
	1303	if (!m_talk_status) goto ranout;
1442	1304	}
1443	1305
1444	1306	// if the pitch index was zero, we only need 4 K's...
1445		if (tms->new_frame_pitch_idx == 0)
	1307	if (m_new_frame_pitch_idx == 0)
1446	1308	{
1447	1309	/* and the rest of the coefficients are zeroed, but that's done in the generator code */
1448	1310	return;
1449	1311	}
1450	1312
1451	1313	// If we got here, we need the remaining 6 K's
1452		for (i = 4; i < tms->coeff->num_k; i++)
	1314	for (i = 4; i < m_coeff->num_k; i++)
1453	1315	{
1454		tms->new_frame_k_idx[i] = extract_bits(tms, tms->coeff->kbits[i]);
	1316	m_new_frame_k_idx[i] = extract_bits(m_coeff->kbits[i]);
1455	1317	#ifdef DEBUG_PARSE_FRAME_DUMP
1456		printbits(tms->new_frame_k_idx[i],tms->coeff->kbits[i]);
	1318	printbits(m_new_frame_k_idx[i],m_coeff->kbits[i]);
1457	1319	fprintf(stderr," ");
1458	1320	#endif
1459		update_status_and_ints(tms);
1460		if (!tms->talk_status) goto ranout;
	1321	update_status_and_ints();
	1322	if (!m_talk_status) goto ranout;
1461	1323	}
1462	1324	#ifdef VERBOSE
1463		if (tms->speak_external)
1464		logerror("Parsed a frame successfully in FIFO - %d bits remaining\n", (tms->fifo_count*8)-(tms->fifo_bits_taken));
	1325	if (m_speak_external)
	1326	logerror("Parsed a frame successfully in FIFO - %d bits remaining\n", (m_fifo_count*8)-(m_fifo_bits_taken));
1465	1327	else
1466	1328	logerror("Parsed a frame successfully in ROM\n");
1467	1329	#endif
r22818	r22819
1480	1342
1481	1343	***********************************************************************************************/
1482	1344
1483		static void set_interrupt_state(tms5220_state *tms, int state)
	1345	void tms5220_device::set_interrupt_state(int state)
1484	1346	{
1485	1347	#ifdef DEBUG_PIN_READS
1486	1348	logerror("irq pin set to state %d\n", state);
1487	1349	#endif
1488		if (!tms->irq_func.isnull() && state != tms->irq_pin)
1489		tms->irq_func(!state);
1490		tms->irq_pin = state;
	1350	if (!m_irq_handler.isnull() && state != m_irq_pin)
	1351	m_irq_handler(!state);
	1352	m_irq_pin = state;
1491	1353	}
1492	1354
1493	1355	/**********************************************************************************************
r22818	r22819
1496	1358
1497	1359	***********************************************************************************************/
1498	1360
1499		static void update_ready_state(tms5220_state *tms)
	1361	void tms5220_device::update_ready_state()
1500	1362	{
1501		int state = tms5220_ready_read(tms);
	1363	int state = ready_read();
1502	1364	#ifdef DEBUG_PIN_READS
1503	1365	logerror("ready pin set to state %d\n", state);
1504	1366	#endif
1505		if (!tms->readyq_func.isnull() && state != tms->ready_pin)
1506		tms->readyq_func(!state);
1507		tms->ready_pin = state;
	1367	if (!m_readyq_handler.isnull() && state != m_ready_pin)
	1368	m_readyq_handler(!state);
	1369	m_ready_pin = state;
1508	1370	}
1509	1371
1510	1372
r22818	r22819
1514	1376
1515	1377	***********************************************************************************************/
1516	1378
1517		static DEVICE_START( tms5220 )
	1379	//-------------------------------------------------
	1380	//  device_start - device-specific startup
	1381	//-------------------------------------------------
	1382
	1383	void tms5220_device::device_start()
1518	1384	{
1519		static const tms5220_interface dummy = { DEVCB_NULL };
1520		tms5220_state *tms = get_safe_token(device);
	1385	if (m_speechrom_tag)
	1386	{
	1387	m_speechrom = siblingdevice<speechrom_device>( m_speechrom_tag );
	1388	if( !m_speechrom )
	1389	{
	1390	throw new emu_fatalerror("Error: %s '%s' can't find speechrom '%s'\n", shortname(), tag(), m_speechrom_tag );
	1391	}
	1392	}
	1393	else
	1394	{
	1395	m_speechrom = NULL;
	1396	}
1521	1397
1522		tms->intf = device->static_config() ? (const tms5220_interface *)device->static_config() : &dummy;
1523		//tms->table = *device->region();
	1398	set_variant(TMS5220_IS_5220);
	1399	m_clock = clock();
1524	1400
1525		tms->device = device;
1526		tms5220_set_variant(tms, TMS5220_IS_5220);
1527		tms->clock = device->clock();
1528
1529		assert_always(tms != NULL, "Error creating TMS5220 chip");
1530
1531	1401	/* resolve irq and readyq line */
1532		tms->irq_func.resolve(tms->intf->irq_func, *device);
1533		tms->readyq_func.resolve(tms->intf->readyq_func, *device);
	1402	m_irq_handler.resolve();
	1403	m_readyq_handler.resolve();
1534	1404
1535	1405	/* initialize a stream */
1536		tms->stream = device->machine().sound().stream_alloc(*device, 0, 1, device->clock() / 80, tms, tms5220_update);
	1406	m_stream = machine().sound().stream_alloc(*this, 0, 1, clock() / 80);
1537	1407
1538		/*if (tms->table == NULL)
1539		{
1540		assert_always(tms->intf->M0_callback != NULL, "Missing _mandatory_ 'M0_callback' function pointer in the TMS5110 interface\n  This function is used by TMS5220 to call for a new single bit\n  needed to generate the speech when in VSM mode\n  Aborting startup...\n");
1541		tms->M0_callback = tms->intf->M0_callback;
1542		tms->set_load_address = tms->intf->load_address;
1543		}
1544		else
1545		{
1546		tms->M0_callback = speech_rom_read_bit;
1547		tms->set_load_address = speech_rom_set_addr;
1548		}*/
	1408	m_timer_io_ready = timer_alloc(0);
1549	1409
1550	1410	/* not during reset which is called frm within a write! */
1551		tms->io_ready = 1;
1552		tms->true_timing = 0;
1553		tms->rs_ws = 0x03; // rs and ws are assumed to be inactive on device startup
	1411	m_io_ready = 1;
	1412	m_true_timing = 0;
	1413	m_rs_ws = 0x03; // rs and ws are assumed to be inactive on device startup
1554	1414
1555		register_for_save_states(tms);
	1415	register_for_save_states();
1556	1416	}
1557	1417
1558		static DEVICE_START( tms5220c )
	1418	//-------------------------------------------------
	1419	//  device_start - device-specific startup
	1420	//-------------------------------------------------
	1421
	1422	void tms5220c_device::device_start()
1559	1423	{
1560		tms5220_state *tms = get_safe_token(device);
1561		DEVICE_START_CALL( tms5220 );
1562		tms5220_set_variant(tms, TMS5220_IS_5220C);
	1424	tms5220_device::device_start();
	1425	set_variant(TMS5220_IS_5220C);
1563	1426	}
1564	1427
1565		static DEVICE_START( tmc0285 )
	1428	//-------------------------------------------------
	1429	//  device_start - device-specific startup
	1430	//-------------------------------------------------
	1431
	1432	void tmc0285_device::device_start()
1566	1433	{
1567		tms5220_state *tms = get_safe_token(device);
1568		DEVICE_START_CALL( tms5220 );
1569		tms5220_set_variant(tms, TMS5220_IS_TMC0285);
	1434	tms5220_device::device_start();
	1435	set_variant(TMS5220_IS_TMC0285);
1570	1436	}
1571	1437
	1438	//-------------------------------------------------
	1439	//  device_start - device-specific startup
	1440	//-------------------------------------------------
1572	1441
1573		static DEVICE_START( tms5200 )
	1442	void tms5200_device::device_start()
1574	1443	{
1575		tms5220_state *tms = get_safe_token(device);
1576		DEVICE_START_CALL( tms5220 );
1577		tms5220_set_variant(tms, TMS5220_IS_5200);
	1444	tms5220_device::device_start();
	1445	set_variant(TMS5220_IS_5200);
1578	1446	}
1579	1447
1580	1448
1581		static DEVICE_RESET( tms5220 )
1582		{
1583		tms5220_state *tms = get_safe_token(device);
	1449	//-------------------------------------------------
	1450	//  device_reset - device-specific reset
	1451	//-------------------------------------------------
1584	1452
1585		tms->digital_select = FORCE_DIGITAL; // assume analog output
	1453	void tms5220_device::device_reset()
	1454	{
	1455	m_digital_select = FORCE_DIGITAL; // assume analog output
1586	1456	/* initialize the FIFO */
1587		/*memset(tms->fifo, 0, sizeof(tms->fifo));*/
1588		tms->fifo_head = tms->fifo_tail = tms->fifo_count = tms->fifo_bits_taken = 0;
	1457	/*memset(m_fifo, 0, sizeof(m_fifo));*/
	1458	m_fifo_head = m_fifo_tail = m_fifo_count = m_fifo_bits_taken = 0;
1589	1459
1590	1460	/* initialize the chip state */
1591		/* Note that we do not actually clear IRQ on start-up : IRQ is even raised if tms->buffer_empty or tms->buffer_low are 0 */
1592		tms->speaking_now = tms->speak_external = tms->talk_status = tms->irq_pin = tms->ready_pin = 0;
1593		set_interrupt_state(tms, 0);
1594		update_ready_state(tms);
1595		tms->buffer_empty = tms->buffer_low = 1;
	1461	/* Note that we do not actually clear IRQ on start-up : IRQ is even raised if m_buffer_empty or m_buffer_low are 0 */
	1462	m_speaking_now = m_speak_external = m_talk_status = m_irq_pin = m_ready_pin = 0;
	1463	set_interrupt_state(0);
	1464	update_ready_state();
	1465	m_buffer_empty = m_buffer_low = 1;
1596	1466
1597		tms->RDB_flag = FALSE;
	1467	m_RDB_flag = FALSE;
1598	1468
1599	1469	/* initialize the energy/pitch/k states */
1600	1470	#ifdef PERFECT_INTERPOLATION_HACK
1601		tms->old_frame_energy_idx = tms->old_frame_pitch_idx = 0;
1602		memset(tms->old_frame_k_idx, 0, sizeof(tms->old_frame_k_idx));
	1471	m_old_frame_energy_idx = m_old_frame_pitch_idx = 0;
	1472	memset(m_old_frame_k_idx, 0, sizeof(m_old_frame_k_idx));
1603	1473	#endif
1604		tms->new_frame_energy_idx = tms->current_energy = tms->target_energy = 0;
1605		tms->new_frame_pitch_idx = tms->current_pitch = tms->target_pitch = 0;
1606		memset(tms->new_frame_k_idx, 0, sizeof(tms->new_frame_k_idx));
1607		memset(tms->current_k, 0, sizeof(tms->current_k));
1608		memset(tms->target_k, 0, sizeof(tms->target_k));
	1474	m_new_frame_energy_idx = m_current_energy = m_target_energy = 0;
	1475	m_new_frame_pitch_idx = m_current_pitch = m_target_pitch = 0;
	1476	memset(m_new_frame_k_idx, 0, sizeof(m_new_frame_k_idx));
	1477	memset(m_current_k, 0, sizeof(m_current_k));
	1478	memset(m_target_k, 0, sizeof(m_target_k));
1609	1479
1610	1480	/* initialize the sample generators */
1611		tms->inhibit = 1;
1612		tms->subcycle = tms->tms5220c_rate = tms->pitch_count = tms->PC = 0;
1613		tms->subc_reload = FORCE_SUBC_RELOAD;
1614		tms->OLDE = tms->OLDP = 1;
1615		tms->IP = reload_table[tms->tms5220c_rate&0x3];
1616		tms->RNG = 0x1FFF;
1617		memset(tms->u, 0, sizeof(tms->u));
1618		memset(tms->x, 0, sizeof(tms->x));
	1481	m_inhibit = 1;
	1482	m_subcycle = m_tms5220c_rate = m_pitch_count = m_PC = 0;
	1483	m_subc_reload = FORCE_SUBC_RELOAD;
	1484	m_OLDE = m_OLDP = 1;
	1485	m_IP = reload_table[m_tms5220c_rate&0x3];
	1486	m_RNG = 0x1FFF;
	1487	memset(m_u, 0, sizeof(m_u));
	1488	memset(m_x, 0, sizeof(m_x));
1619	1489
1620		if (tms->intf->load_address)
1621		(*tms->intf->load_address)(tms->device, 0);
	1490	if (m_speechrom)
	1491	m_speechrom->load_address(0);
1622	1492
1623		tms->schedule_dummy_read = TRUE;
	1493	m_schedule_dummy_read = TRUE;
1624	1494	}
1625	1495
1626	1496	/**********************************************************************************************
r22818	r22819
1629	1499
1630	1500	***********************************************************************************************/
1631	1501
1632		static TIMER_CALLBACK( io_ready_cb )
	1502	void tms5220_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
1633	1503	{
1634		tms5220_state *tms = (tms5220_state *) ptr;
1635		if (param)
	1504	switch(id)
1636	1505	{
1637		switch (tms->rs_ws)
	1506	case 0:
	1507	if (param)
1638	1508	{
1639		case 0x02:
1640		/* Write */
1641		/* bring up to date first */
	1509	switch (m_rs_ws)
	1510	{
	1511	case 0x02:
	1512	/* Write */
	1513	/* bring up to date first */
1642	1514	#ifdef DEBUG_IO_READY
1643		logerror("Serviced write: %02x\n", tms->write_latch);
1644		//fprintf(stderr, "Processed write data: %02X\n", tms->write_latch);
	1515	logerror("Serviced write: %02x\n", m_write_latch);
	1516	//fprintf(stderr, "Processed write data: %02X\n", m_write_latch);
1645	1517	#endif
1646		tms->stream->update();
1647		tms5220_data_write(tms, tms->write_latch);
1648		break;
1649		case 0x01:
1650		/* Read */
1651		/* bring up to date first */
1652		tms->stream->update();
1653		tms->read_latch = tms5220_status_read(tms);
1654		break;
1655		case 0x03:
1656		/* High Impedance */
1657		case 0x00:
1658		/* illegal */
1659		break;
	1518	m_stream->update();
	1519	data_write(m_write_latch);
	1520	break;
	1521	case 0x01:
	1522	/* Read */
	1523	/* bring up to date first */
	1524	m_stream->update();
	1525	m_read_latch = status_read();
	1526	break;
	1527	case 0x03:
	1528	/* High Impedance */
	1529	case 0x00:
	1530	/* illegal */
	1531	break;
	1532	}
1660	1533	}
	1534
	1535	m_io_ready = param;
	1536	update_ready_state();
	1537	break;
1661	1538	}
1662		tms->io_ready = param;
1663		update_ready_state(tms);
1664	1539	}
1665	1540
1666	1541	/*
1667	1542	* /RS line write handler
1668	1543	*/
1669		WRITE_LINE_DEVICE_HANDLER( tms5220_rsq_w )
	1544	WRITE_LINE_MEMBER( tms5220_device::rsq_w )
1670	1545	{
1671		tms5220_state *tms = get_safe_token(device);
1672	1546	UINT8 new_val;
1673	1547
1674		tms->true_timing = 1;
	1548	m_true_timing = 1;
1675	1549	state &= 0x01;
1676	1550	#ifdef DEBUG_RS_WS
1677	1551	logerror("/RS written with data: %d\n", state);
1678	1552	#endif
1679		new_val = (tms->rs_ws & 0x01) | (state<<1);
1680		if (new_val != tms->rs_ws)
	1553	new_val = (m_rs_ws & 0x01) | (state<<1);
	1554	if (new_val != m_rs_ws)
1681	1555	{
1682		tms->rs_ws = new_val;
	1556	m_rs_ws = new_val;
1683	1557	if (new_val == 0)
1684	1558	{
1685		if (tms->variant == TMS5220_IS_5220C)
1686		device->reset();
	1559	if (m_variant == TMS5220_IS_5220C)
	1560	reset();
1687	1561	#ifdef DEBUG_RS_WS
1688	1562	else
1689	1563	/* illegal */
r22818	r22819
1694	1568	else if ( new_val == 3)
1695	1569	{
1696	1570	/* high impedance */
1697		tms->read_latch = 0xff;
	1571	m_read_latch = 0xff;
1698	1572	return;
1699	1573	}
1700	1574	if (state)
r22818	r22819
1708	1582	logerror("Scheduling ready cycle for /RS...\n");
1709	1583	#endif
1710	1584	/* upon /RS being activated, /READY goes inactive after 100 nsec from data sheet, through 3 asynchronous gates on patent. This is effectively within one clock, so we immediately set io_ready to 0 and activate the callback. */
1711		tms->io_ready = 0;
1712		update_ready_state(tms);
	1585	m_io_ready = 0;
	1586	update_ready_state();
1713	1587	/* How long does /READY stay inactive, when /RS is pulled low? I believe its almost always ~16 clocks (25 usec at 800khz as shown on the datasheet) */
1714		tms->device->machine().scheduler().timer_set(attotime::from_hz(device->clock()/16), FUNC(io_ready_cb), 1, tms); // this should take around 10-16 (closer to ~11?) cycles to complete
	1588	m_timer_io_ready->adjust(attotime::from_hz(clock()/16), 1); // this should take around 10-16 (closer to ~11?) cycles to complete
1715	1589	}
1716	1590	}
1717	1591	}
r22818	r22819
1719	1593	/*
1720	1594	* /WS line write handler
1721	1595	*/
1722		WRITE_LINE_DEVICE_HANDLER( tms5220_wsq_w )
	1596	WRITE_LINE_MEMBER( tms5220_device::wsq_w )
1723	1597	{
1724		tms5220_state *tms = get_safe_token(device);
1725	1598	UINT8 new_val;
1726	1599
1727		tms->true_timing = 1;
	1600	m_true_timing = 1;
1728	1601	state &= 0x01;
1729	1602	#ifdef DEBUG_RS_WS
1730	1603	logerror("/WS written with data: %d\n", state);
1731	1604	#endif
1732		new_val = (tms->rs_ws & 0x02) | (state<<0);
1733		if (new_val != tms->rs_ws)
	1605	new_val = (m_rs_ws & 0x02) | (state<<0);
	1606	if (new_val != m_rs_ws)
1734	1607	{
1735		tms->rs_ws = new_val;
	1608	m_rs_ws = new_val;
1736	1609	if (new_val == 0)
1737	1610	{
1738		if (tms->variant == TMS5220_IS_5220C)
1739		device->reset();
	1611	if (m_variant == TMS5220_IS_5220C)
	1612	reset();
1740	1613	#ifdef DEBUG_RS_WS
1741	1614	else
1742	1615	/* illegal */
r22818	r22819
1747	1620	else if ( new_val == 3)
1748	1621	{
1749	1622	/* high impedance */
1750		tms->read_latch = 0xff;
	1623	m_read_latch = 0xff;
1751	1624	return;
1752	1625	}
1753	1626	if (state)
r22818	r22819
1761	1634	logerror("Scheduling ready cycle for /WS...\n");
1762	1635	#endif
1763	1636	/* upon /WS being activated, /READY goes inactive after 100 nsec from data sheet, through 3 asynchronous gates on patent. This is effectively within one clock, so we immediately set io_ready to 0 and activate the callback. */
1764		tms->io_ready = 0;
1765		update_ready_state(tms);
	1637	m_io_ready = 0;
	1638	update_ready_state();
1766	1639	/* Now comes the complicated part: long does /READY stay inactive, when /WS is pulled low? This depends ENTIRELY on the command written, or whether the chip is in speak external mode or not...
1767	1640	Speak external mode: ~16 cycles
1768	1641	Command Mode:
r22818	r22819
1774	1647	SET RATE (5220C only): ? cycles (probably ~16)
1775	1648	*/
1776	1649	// TODO: actually HANDLE the timing differences! currently just assuming always 16 cycles
1777		tms->device->machine().scheduler().timer_set(attotime::from_hz(device->clock()/16), FUNC(io_ready_cb), 1, tms); // this should take around 10-16 (closer to ~15) cycles to complete for fifo writes, TODO: but actually depends on what command is written if in command mode
	1650	m_timer_io_ready->adjust(attotime::from_hz(clock()/16), 1); // this should take around 10-16 (closer to ~15) cycles to complete for fifo writes, TODO: but actually depends on what command is written if in command mode
1778	1651	}
1779	1652	}
1780	1653	}
r22818	r22819
1785	1658
1786	1659	***********************************************************************************************/
1787	1660
1788		WRITE8_DEVICE_HANDLER( tms5220_data_w )
	1661	WRITE8_MEMBER( tms5220_device::data_w )
1789	1662	{
1790		tms5220_state *tms = get_safe_token(device);
1791	1663	#ifdef DEBUG_RS_WS
1792	1664	logerror("tms5220_data_w: data %02x\n", data);
1793	1665	#endif
1794		if (!tms->true_timing)
	1666	if (!m_true_timing)
1795	1667	{
1796	1668	/* bring up to date first */
1797		tms->stream->update();
1798		tms5220_data_write(tms, data);
	1669	m_stream->update();
	1670	data_write(data);
1799	1671	}
1800	1672	else
1801	1673	{
1802	1674	/* actually in a write ? */
1803	1675	#ifdef DEBUG_RS_WS
1804		if (!(tms->rs_ws == 0x02))
1805		logerror("tms5220_data_w: data written outside ws, status: %02x!\n", tms->rs_ws);
	1676	if (!(m_rs_ws == 0x02))
	1677	logerror("tms5220_data_w: data written outside ws, status: %02x!\n", m_rs_ws);
1806	1678	#endif
1807		tms->write_latch = data;
	1679	m_write_latch = data;
1808	1680	}
1809	1681	}
1810	1682
r22818	r22819
1816	1688
1817	1689	***********************************************************************************************/
1818	1690
1819		READ8_DEVICE_HANDLER( tms5220_status_r )
	1691	READ8_MEMBER( tms5220_device::status_r )
1820	1692	{
1821		tms5220_state *tms = get_safe_token(device);
1822		if (!tms->true_timing)
	1693	if (!m_true_timing)
1823	1694	{
1824	1695	/* bring up to date first */
1825		tms->stream->update();
1826		return tms5220_status_read(tms);
	1696	m_stream->update();
	1697	return status_read();
1827	1698	}
1828	1699	else
1829	1700	{
1830	1701	/* actually in a read ? */
1831		if (tms->rs_ws == 0x01)
1832		return tms->read_latch;
	1702	if (m_rs_ws == 0x01)
	1703	return m_read_latch;
1833	1704	#ifdef DEBUG_RS_WS
1834	1705	else
1835	1706	logerror("tms5220_status_r: data read outside rs!\n");
r22818	r22819
1846	1717
1847	1718	***********************************************************************************************/
1848	1719
1849		READ_LINE_DEVICE_HANDLER( tms5220_readyq_r )
	1720	READ_LINE_MEMBER( tms5220_device::readyq_r )
1850	1721	{
1851		tms5220_state *tms = get_safe_token(device);
1852	1722	/* bring up to date first */
1853		tms->stream->update();
1854		return !tms5220_ready_read(tms);
	1723	m_stream->update();
	1724	return !ready_read();
1855	1725	}
1856	1726
1857	1727
r22818	r22819
1862	1732
1863	1733	***********************************************************************************************/
1864	1734
1865		double tms5220_time_to_ready(device_t *device)
	1735	double tms5220_device::time_to_ready()
1866	1736	{
1867		tms5220_state *tms = get_safe_token(device);
1868	1737	double cycles;
1869	1738
1870	1739	/* bring up to date first */
1871		tms->stream->update();
1872		cycles = tms5220_cycles_to_ready(tms);
1873		return cycles * 80.0 / tms->clock;
	1740	m_stream->update();
	1741	cycles = cycles_to_ready();
	1742	return cycles * 80.0 / m_clock;
1874	1743	}
1875	1744
1876	1745
r22818	r22819
1881	1750
1882	1751	***********************************************************************************************/
1883	1752
1884		READ_LINE_DEVICE_HANDLER( tms5220_intq_r )
	1753	READ_LINE_MEMBER( tms5220_device::intq_r )
1885	1754	{
1886		tms5220_state *tms = get_safe_token(device);
1887	1755	/* bring up to date first */
1888		tms->stream->update();
1889		return !tms5220_int_read(tms);
	1756	m_stream->update();
	1757	return !int_read();
1890	1758	}
1891	1759
1892	1760
r22818	r22819
1897	1765
1898	1766	***********************************************************************************************/
1899	1767
1900		static STREAM_UPDATE( tms5220_update )
	1768	//-------------------------------------------------
	1769	//  sound_stream_update - handle a stream update
	1770	//-------------------------------------------------
	1771
	1772	void tms5220_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples)
1901	1773	{
1902		tms5220_state *tms = (tms5220_state *)param;
1903	1774	INT16 sample_data[MAX_SAMPLE_CHUNK];
1904	1775	stream_sample_t *buffer = outputs[0];
1905	1776
r22818	r22819
1910	1781	int index;
1911	1782
1912	1783	/* generate the samples and copy to the target buffer */
1913		tms5220_process(tms, sample_data, length);
	1784	process(sample_data, length);
1914	1785	for (index = 0; index < length; index++)
1915	1786	*buffer++ = sample_data[index];
1916	1787
r22818	r22819
1927	1798
1928	1799	***********************************************************************************************/
1929	1800
1930		void tms5220_set_frequency(device_t *device, int frequency)
	1801	void tms5220_device::set_frequency(int frequency)
1931	1802	{
1932		tms5220_state *tms = get_safe_token(device);
1933		tms->stream->set_sample_rate(frequency / 80);
1934		tms->clock = frequency;
	1803	m_stream->set_sample_rate(frequency / 80);
	1804	m_clock = frequency;
1935	1805	}
1936	1806
1937	1807	const device_type TMS5220C = &device_creator<tms5220c_device>;
r22818	r22819
1941	1811	{
1942	1812	}
1943	1813
1944		//-------------------------------------------------
1945		//  device_start - device-specific startup
1946		//-------------------------------------------------
1947	1814
1948		void tms5220c_device::device_start()
1949		{
1950		DEVICE_START_NAME( tms5220c )(this);
1951		}
1952
1953		//-------------------------------------------------
1954		//  sound_stream_update - handle a stream update
1955		//-------------------------------------------------
1956
1957		void tms5220c_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples)
1958		{
1959		// should never get here
1960		fatalerror("sound_stream_update called; not applicable to legacy sound devices\n");
1961		}
1962
1963
1964	1815	const device_type TMS5220 = &device_creator<tms5220_device>;
1965	1816
1966	1817	tms5220_device::tms5220_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
1967	1818	: device_t(mconfig, TMS5220, "TMS5220", tag, owner, clock),
1968		device_sound_interface(mconfig, *this)
	1819	device_sound_interface(mconfig, *this),
	1820	m_irq_handler(*this),
	1821	m_readyq_handler(*this),
	1822	m_speechrom_tag(NULL)
1969	1823	{
1970		m_token = global_alloc_clear(tms5220_state);
1971	1824	}
	1825
1972	1826	tms5220_device::tms5220_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock)
1973	1827	: device_t(mconfig, type, name, tag, owner, clock),
1974		device_sound_interface(mconfig, *this)
	1828	device_sound_interface(mconfig, *this),
	1829	m_irq_handler(*this),
	1830	m_readyq_handler(*this),
	1831	m_speechrom_tag(NULL)
1975	1832	{
1976		m_token = global_alloc_clear(tms5220_state);
1977	1833	}
1978	1834
1979	1835	//-------------------------------------------------
r22818	r22819
1986	1842	{
1987	1843	}
1988	1844
1989		//-------------------------------------------------
1990		//  device_start - device-specific startup
1991		//-------------------------------------------------
1992	1845
1993		void tms5220_device::device_start()
1994		{
1995		DEVICE_START_NAME( tms5220 )(this);
1996		}
1997
1998		//-------------------------------------------------
1999		//  device_reset - device-specific reset
2000		//-------------------------------------------------
2001
2002		void tms5220_device::device_reset()
2003		{
2004		DEVICE_RESET_NAME( tms5220 )(this);
2005		}
2006
2007		//-------------------------------------------------
2008		//  sound_stream_update - handle a stream update
2009		//-------------------------------------------------
2010
2011		void tms5220_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples)
2012		{
2013		// should never get here
2014		fatalerror("sound_stream_update called; not applicable to legacy sound devices\n");
2015		}
2016
2017
2018	1846	const device_type TMC0285 = &device_creator<tmc0285_device>;
2019	1847
2020	1848	tmc0285_device::tmc0285_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
r22818	r22819
2022	1850	{
2023	1851	}
2024	1852
2025		//-------------------------------------------------
2026		//  device_start - device-specific startup
2027		//-------------------------------------------------
2028	1853
2029		void tmc0285_device::device_start()
2030		{
2031		DEVICE_START_NAME( tmc0285 )(this);
2032		}
2033
2034		//-------------------------------------------------
2035		//  sound_stream_update - handle a stream update
2036		//-------------------------------------------------
2037
2038		void tmc0285_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples)
2039		{
2040		// should never get here
2041		fatalerror("sound_stream_update called; not applicable to legacy sound devices\n");
2042		}
2043
2044
2045	1854	const device_type TMS5200 = &device_creator<tms5200_device>;
2046	1855
2047	1856	tms5200_device::tms5200_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
2048	1857	: tms5220_device(mconfig, TMS5200, "TMS5200", tag, owner, clock)
2049	1858	{
2050	1859	}
2051
2052		//-------------------------------------------------
2053		//  device_start - device-specific startup
2054		//-------------------------------------------------
2055
2056		void tms5200_device::device_start()
2057		{
2058		DEVICE_START_NAME( tms5200 )(this);
2059		}
2060
2061		//-------------------------------------------------
2062		//  sound_stream_update - handle a stream update
2063		//-------------------------------------------------
2064
2065		void tms5200_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples)
2066		{
2067		// should never get here
2068		fatalerror("sound_stream_update called; not applicable to legacy sound devices\n");
2069		}
2070
2071
2072
2073
2074		/******************************************************************************
2075		New class implementation
2076		******************************************************************************/
2077
2078		#define M_INTERP_SHIFT >> m_coeff->interp_coeff[m_IP]
2079
2080		tms52xx_device::tms52xx_device(const machine_config &mconfig, device_type type,  const char *name, const char *tag, const struct tms5100_coeffs* coeffs, const int var, device_t *owner, UINT32 clock)
2081		: device_t(mconfig, type, name, tag, owner, clock),
2082		device_sound_interface(mconfig, *this),
2083		m_variant(var),
2084		m_coeff(coeffs)
2085		{
2086		}
2087
2088
2089		tms5220n_device::tms5220n_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
2090		: tms52xx_device(mconfig, TMS5220N, "TMS5220N", tag, &tms5220_coeff, TMS5220_IS_5220, owner, clock)
2091		{
2092		}
2093
2094		tms5220cn_device::tms5220cn_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
2095		: tms52xx_device(mconfig, TMS5220CN, "TMS5220CN", tag, &tms5220_coeff, TMS5220_IS_5220C, owner, clock)
2096		{
2097		}
2098
2099		tmc0285n_device::tmc0285n_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
2100		: tms52xx_device(mconfig, TMC0285N, "TMC0285N", tag, &tms5200_coeff, TMS5220_IS_TMC0285, owner, clock)
2101		{
2102		}
2103
2104		tms5200n_device::tms5200n_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
2105		: tms52xx_device(mconfig, TMS5200N, "TMS5200N", tag, &tms5200_coeff, TMS5220_IS_5200, owner, clock)
2106		{
2107		}
2108
2109		void tms52xx_device::device_start()
2110		{
2111		const tms52xx_config *conf = reinterpret_cast<const tms52xx_config *>(static_config());
2112		//m_table = region();
2113
2114		/* resolve irq and readyq line */
2115		m_irq_func.resolve(conf->irq_func, *this);
2116		m_readyq_func.resolve(conf->readyq_func, *this);
2117		m_read_mem.resolve(conf->read_mem, *this);
2118		m_load_address.resolve(conf->load_address, *this);
2119		m_read_and_branch.resolve(conf->read_and_branch, *this);
2120
2121		/* initialize a stream */
2122		m_stream = machine().sound().stream_alloc(*this, 0, 1, clock() / 80, this);
2123
2124		/*if (m_table == NULL)
2125		{
2126		assert_always(m_conf->M0_callback != NULL, "Missing _mandatory_ 'M0_callback' function pointer in the TMS5110 interface\n  This function is used by TMS5220 to call for a new single bit\n  needed to generate the speech when in VSM mode\n  Aborting startup...\n");
2127		m_M0_callback = conf->M0_callback;
2128		m_set_load_address = conf->load_address;
2129		}
2130		else
2131		{
2132		m_M0_callback = speech_rom_read_bit;
2133		m_set_load_address = speech_rom_set_addr;
2134		}*/
2135
2136		/* not during reset which is called frm within a write! */
2137		m_io_ready = true;
2138		m_true_timing = false;
2139		m_rs_ws = 0x03; // rs and ws are assumed to be inactive on device startup
2140
2141		m_ready_timer = timer_alloc(0);
2142
2143		register_for_save_states();
2144		}
2145
2146		void tms52xx_device::device_reset()
2147		{
2148		m_digital_select = FORCE_DIGITAL;           // assume analog output
2149		// initialize the FIFO
2150		// should we do a memset here to clear the fifo contents?
2151		m_fifo_head = 0;
2152		m_fifo_tail = 0;
2153		m_fifo_count = 0;
2154		m_fifo_bits_taken = 0;
2155
2156		// initialize the chip state
2157		/* Note that we do not actually clear IRQ on start-up: IRQ is even raised
2158		* if m_buffer_empty or m_buffer_low are 0 */
2159		m_speaking_now = false;
2160		m_speak_external = false;
2161		m_talk_status = false;
2162		m_irq_pin = 0;      // CLEAR_LINE
2163		m_ready_pin = 0;    // CLEAR_LINE
2164
2165		set_interrupt_state(0);         // CLEAR_LINE
2166		update_ready_state();
2167		m_buffer_empty = true;
2168		m_buffer_low = true;
2169
2170		m_RDB_flag = false;
2171
2172		/* initialize the energy/pitch/k states */
2173		#ifdef PERFECT_INTERPOLATION_HACK
2174		m_old_frame_energy_idx = 0;
2175		m_old_frame_pitch_idx = 0;
2176		memset(m_old_frame_k_idx, 0, sizeof(m_old_frame_k_idx));
2177		#endif
2178
2179		m_new_frame_energy_idx = 0;
2180		m_current_energy = 0;
2181		m_target_energy = 0;
2182		m_new_frame_pitch_idx = 0;
2183		m_current_pitch = 0;
2184		m_target_pitch = 0;
2185
2186		memset(m_new_frame_k_idx, 0, sizeof(m_new_frame_k_idx));
2187		memset(m_current_k, 0, sizeof(m_current_k));
2188		memset(m_target_k, 0, sizeof(m_target_k));
2189
2190		/* initialize the sample generators */
2191		m_inhibit = true;
2192		m_subcycle = 0;
2193		m_tms5220c_rate = 0;
2194		m_pitch_count = 0;
2195		m_PC = 0;
2196
2197		m_subc_reload = FORCE_SUBC_RELOAD;
2198		m_OLDE = 1;
2199		m_OLDP = 1;
2200
2201		m_IP = reload_table[m_tms5220c_rate&0x3];
2202		m_RNG = 0x1FFF;
2203		memset(m_u, 0, sizeof(m_u));
2204		memset(m_x, 0, sizeof(m_x));
2205
2206		m_load_address(0, 0);
2207		m_schedule_dummy_read = true;
2208		}
2209
2210		/******************************************************************************
2211		set_interrupt_state -- generate an interrupt
2212		*******************************************************************************/
2213
2214		void tms52xx_device::set_interrupt_state(int state)
2215		{
2216		#ifdef DEBUG_PIN_READS
2217		logerror("tms52xx: irq pin set to state %d\n", state);
2218		#endif
2219		if (state != m_irq_pin) m_irq_func(!state);
2220		m_irq_pin = state;
2221		}
2222
2223		/******************************************************************************
2224		update_ready_state -- update the ready line
2225		*******************************************************************************/
2226
2227		void tms52xx_device::update_ready_state()
2228		{
2229		int state = ready_read();
2230		#ifdef DEBUG_PIN_READS
2231		logerror("tms52xx: ready pin set to state %d\n", state);
2232		#endif
2233		if (state != m_ready_pin) m_readyq_func(!state);
2234		m_ready_pin = state;
2235		}
2236
2237		/******************************************************************************
2238		tms5220_set_frequency -- adjusts the playback frequency
2239		*******************************************************************************/
2240
2241		void tms52xx_device::set_frequency(int frequency)
2242		{
2243		m_stream->set_sample_rate(frequency / 80);
2244		m_clock = frequency;
2245		}
2246
2247		/******************************************************************************
2248		tms5220_update -- update the sound chip so that it is in sync with CPU execution
2249		*******************************************************************************/
2250
2251		void tms52xx_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples)
2252		{
2253		INT16 sample_data[MAX_SAMPLE_CHUNK];
2254		stream_sample_t *buffer = outputs[0];
2255
2256		/* loop while we still have samples to generate */
2257		while (samples>0)
2258		{
2259		int length = (samples > MAX_SAMPLE_CHUNK) ? MAX_SAMPLE_CHUNK : samples;
2260		int index;
2261
2262		/* generate the samples and copy to the target buffer */
2263		process(sample_data, length);
2264		for (index = 0; index < length; index++)
2265		*buffer++ = sample_data[index];
2266
2267		/* account for the samples */
2268		samples -= length;
2269		}
2270		}
2271
2272		/******************************************************************************
2273		process -- fill the buffer with a specific number of samples
2274		*******************************************************************************/
2275
2276		void tms52xx_device::process(INT16 *buffer, unsigned int size)
2277		{
2278		int buf_count=0;
2279		int i, bitout;
2280		bool zpar;
2281		INT32 this_sample;
2282
2283		// The following gotos are probably safe to remove
2284		// if we're empty and still not speaking, fill with nothingness
2285		if (!m_speaking_now) goto empty;
2286
2287		// if speak external is set, but talk status is not (yet) set,
2288		// wait for buffer low to clear
2289		if (!m_talk_status && m_speak_external && m_buffer_low) goto empty;
2290
2291		// loop until the buffer is full or we've stopped speaking
2292		while ((size > 0) && m_speaking_now)
2293		{
2294		/* if it is the appropriate time to update the old energy/pitch idxes,
2295		* i.e. when IP=7, PC=12, T=17, subcycle=2, do so. Since IP=7 PC=12 T=17
2296		* is JUST BEFORE the transition to IP=0 PC=0 T=0 sybcycle=(0 or 1),
2297		* which happens 4 T-cycles later), we change on the latter.
2298		*/
2299		if ((m_IP == 0) && (m_PC == 0) && (m_subcycle < 2))
2300		{
2301		m_OLDE = (m_new_frame_energy_idx == 0);
2302		m_OLDP = (m_new_frame_pitch_idx == 0);
2303		}
2304
2305		/* if we're ready for a new frame to be applied, i.e. when IP=0, PC=12, Sub=1
2306		* (In reality, the frame was really loaded incrementally during the
2307		* entire IP=0 PC=x time period, but it doesn't affect anything until IP=0 PC=12 happens)
2308		*/
2309		if ((m_IP == 0) && (m_PC == 12) && (m_subcycle == 1))
2310		{
2311		// HACK for regression testing, be sure to comment out before release!
2312		// m_RNG = 0x1234;
2313		// end HACK
2314
2315		// appropriately override the interp count if needed; this will be incremented after the frame parse!
2316		m_IP = reload_table[m_tms5220c_rate & 0x3];
2317
2318		#ifdef PERFECT_INTERPOLATION_HACK
2319		// remember previous frame energy, pitch, and coefficients
2320		m_old_frame_energy_idx = m_new_frame_energy_idx;
2321		m_old_frame_pitch_idx = m_new_frame_pitch_idx;
2322		for (i = 0; i < m_coeff->num_k; i++)
2323		m_old_frame_k_idx[i] = m_new_frame_k_idx[i];
2324		#endif
2325
2326		// if the talk status was clear last frame, halt speech now.
2327		if (m_talk_status == false)
2328		{
2329		#ifdef DEBUG_GENERATION
2330		fprintf(stderr,"tms5220_process: processing frame: talk status = 0 caused by stop frame or buffer empty, halting speech.\n");
2331		#endif
2332		m_speaking_now = false; // finally halt speech
2333		goto empty;
2334		}
2335
2336		// Parse a new frame into the new_target_energy, new_target_pitch and new_target_k[]
2337		parse_frame();
2338		#ifdef DEBUG_PARSE_FRAME_DUMP
2339		fprintf(stderr,"\n");
2340		#endif
2341		// if the new frame is a stop frame, set an interrupt and set talk status to 0
2342		if (M_NEW_FRAME_STOP_FLAG == 1)
2343		{
2344		m_talk_status = false;
2345		m_speak_external = false;
2346		set_interrupt_state(1);
2347		update_status_and_ints();
2348		}
2349
2350		// in all cases where interpolation would be inhibited, set the inhibit flag; otherwise clear it.
2351		// Interpolation inhibit cases:
2352		// * Old frame was voiced, new is unvoiced
2353		// * Old frame was silence/zero energy, new has nonzero energy
2354		// * Old frame was unvoiced, new is voiced
2355
2356		if ( ((M_OLD_FRAME_UNVOICED_FLAG == false) && (M_NEW_FRAME_UNVOICED_FLAG == true))
2357		|| ((M_OLD_FRAME_UNVOICED_FLAG == true) && (M_NEW_FRAME_UNVOICED_FLAG == false)) /* this line needs further investigation, starwars tie fighters may sound better without it */
2358		|| ((M_OLD_FRAME_SILENCE_FLAG == true) && (M_NEW_FRAME_SILENCE_FLAG == false)) )
2359		m_inhibit = true;
2360		else // normal frame, normal interpolation
2361		m_inhibit = false;
2362
2363		// load new frame targets from tables, using parsed indices
2364		m_target_energy = m_coeff->energytable[m_new_frame_energy_idx];
2365		m_target_pitch = m_coeff->pitchtable[m_new_frame_pitch_idx];
2366		zpar = M_NEW_FRAME_UNVOICED_FLAG; // find out if parameters k5-k10 should be zeroed
2367		for (i = 0; i < 4; i++)
2368		m_target_k[i] = m_coeff->ktable[i][m_new_frame_k_idx[i]];
2369		for (i = 4; i < m_coeff->num_k; i++)
2370		m_target_k[i] = (m_coeff->ktable[i][m_new_frame_k_idx[i]] * (1-zpar));
2371
2372		#ifdef DEBUG_GENERATION
2373		/* Debug info for current parsed frame */
2374		fprintf(stderr, "OLDE: %d; OLDP: %d; ", m_OLDE, m_OLDP);
2375		fprintf(stderr,"Processing frame: ");
2376		if (m_inhibit == 0)
2377		fprintf(stderr, "Normal Frame\n");
2378		else
2379		fprintf(stderr,"Interpolation Inhibited\n");
2380		fprintf(stderr,"*** current Energy, Pitch and Ks =      %04d,   %04d, %04d, %04d, %04d, %04d, %04d, %04d, %04d, %04d, %04d, %04d\n",
2381		m_current_energy, m_current_pitch,
2382		m_current_k[0], m_current_k[1], m_current_k[2], m_current_k[3],
2383		m_current_k[4], m_current_k[5], m_current_k[6], m_current_k[7],
2384		m_current_k[8], m_current_k[9]);
2385		fprintf(stderr,"*** target Energy(idx), Pitch, and Ks = %04d(%x),%04d, %04d, %04d, %04d, %04d, %04d, %04d, %04d, %04d, %04d, %04d\n",
2386		m_target_energy, m_new_frame_energy_idx, m_target_pitch,
2387		m_target_k[0], m_target_k[1], m_target_k[2], m_target_k[3],
2388		m_target_k[4], m_target_k[5], m_target_k[6], m_target_k[7],
2389		m_target_k[8], m_target_k[9]);
2390		#endif
2391
2392		/* if TS is now 0, ramp the energy down to 0. Is this really correct to hardware? */
2393		if (!m_talk_status)
2394		{
2395		#ifdef DEBUG_GENERATION
2396		fprintf(stderr,"Talk status is 0, forcing target energy to 0\n");
2397		#endif
2398		m_target_energy = 0;
2399		}
2400		}
2401		else // Not a new frame, just interpolate the existing frame.
2402		{
2403		bool inhibit_state = (m_inhibit && (m_IP != 0)); // disable inhibit when reaching the last interp period, but don't overwrite the tms->inhibit value
2404		#ifdef PERFECT_INTERPOLATION_HACK
2405		int samples_per_frame = (m_subc_reload!=0)? 175:266;        // either (13 A cycles + 12 B cycles) * 7 interps for normal SPEAK/SPKEXT, or (13*2 A cycles + 12 B cycles) * 7 interps for SPKSLOW
2406		//int samples_per_frame = (m_subc_reload!=0)?200:304; // either (13 A cycles + 12 B cycles) * 8 interps for normal SPEAK/SPKEXT, or (13*2 A cycles + 12 B cycles) * 8 interps for SPKSLOW
2407		int current_sample = (m_subcycle - m_subc_reload)+(m_PC*(3-m_subc_reload))+((m_subc_reload?25:38)*((m_IP-1)&7));
2408
2409		zpar = M_OLD_FRAME_UNVOICED_FLAG;
2410		//fprintf(stderr, "CS: %03d", current_sample);
2411		// reset the current energy, pitch, etc to what it was at frame start
2412		m_current_energy = m_coeff->energytable[m_old_frame_energy_idx];
2413		m_current_pitch = m_coeff->pitchtable[m_old_frame_pitch_idx];
2414		for (i = 0; i < 4; i++)
2415		m_current_k[i] = m_coeff->ktable[i][m_old_frame_k_idx[i]];
2416		for (i = 4; i < m_coeff->num_k; i++)
2417		m_current_k[i] = (m_coeff->ktable[i][m_old_frame_k_idx[i]] * (1-zpar));
2418		// now adjust each value to be exactly correct for each of the samples per frame
2419		if (m_IP != 0) // if we're still interpolating...
2420		{
2421		if (!inhibit_state)
2422		{
2423		m_current_energy += ((m_target_energy - m_current_energy)*current_sample)/samples_per_frame;
2424		m_current_pitch += ((m_target_pitch - m_current_pitch)*current_sample)/samples_per_frame;
2425		for (i = 0; i < m_coeff->num_k; i++)
2426		{
2427		m_current_k[i] += ((m_target_k[i] - m_current_k[i])*current_sample)/samples_per_frame;
2428		}
2429		}
2430		}
2431		else // we're done, play this frame for 1/8 frame.
2432		{
2433		m_current_energy = m_target_energy;
2434		m_current_pitch = m_target_pitch;
2435		for (i = 0; i < m_coeff->num_k; i++)
2436		m_current_k[i] = m_target_k[i];
2437		}
2438		#else
2439		// Updates to parameters only happen on subcycle '2' (B cycle) of PCs.
2440		if (m_subcycle == 2)
2441		{
2442		if (!inhibit_state)
2443		{
2444		switch(m_PC)
2445		{
2446		case 0: // PC = 0, B cycle, write updated energy
2447		m_current_energy += ((m_target_energy - m_current_energy) M_INTERP_SHIFT);
2448		break;
2449		case 1: /* PC = 1, B cycle, write updated pitch */
2450		m_current_pitch += ((m_target_pitch - m_current_pitch) M_INTERP_SHIFT);
2451		break;
2452		case 2: case 3: case 4: case 5: case 6: case 7: case 8: case 9: case 10: case 11:
2453		/* PC = 2 through 11, B cycle, write updated K1 through K10 */
2454		m_current_k[m_PC-2] += ((m_target_k[m_PC-2] - m_current_k[m_PC-2]) M_INTERP_SHIFT);
2455		break;
2456		case 12: /* PC = 12, do nothing */
2457		break;
2458		}
2459		}
2460		}
2461		#endif
2462		}
2463
2464		// calculate the output
2465		if (M_OLD_FRAME_UNVOICED_FLAG == true)
2466		{
2467		// generate unvoiced samples here
2468		if (m_RNG & 1)
2469		m_excitation_data = ~0x3F; // according to the patent it is (either + or -) half of the maximum value in the chirp table, so either 01000000(0x40) or 11000000(0xC0)
2470		else
2471		m_excitation_data = 0x40;
2472		}
2473		else // (M_OLD_FRAME_UNVOICED_FLAG == false)
2474		{
2475		// generate voiced samples here
2476		// US patent 4331836 Figure 14B shows, and logic would hold, that a pitch based chirp
2477		// function has a chirp/peak and then a long chain of zeroes.
2478		// The last entry of the chirp rom is at address 0b110011 (51d), the 52nd sample,
2479		// and if the address reaches that point the ADDRESS incrementer is
2480		// disabled, forcing all samples beyond 51d to be == 51d
2481
2482		if (m_pitch_count >= 51)
2483		m_excitation_data = m_coeff->chirptable[51];
2484		else // tms->pitch_count < 51
2485		m_excitation_data = m_coeff->chirptable[m_pitch_count];
2486		}
2487
2488		// Update LFSR *20* times every sample (once per T cycle), like patent shows
2489		for (i=0; i<20; i++)
2490		{
2491		bitout = ((m_RNG >> 12) & 1) ^
2492		((m_RNG >>  3) & 1) ^
2493		((m_RNG >>  2) & 1) ^
2494		((m_RNG >>  0) & 1);
2495		m_RNG <<= 1;
2496		m_RNG |= bitout;
2497		}
2498
2499		this_sample = lattice_filter(); // execute lattice filter
2500		#ifdef DEBUG_GENERATION_VERBOSE
2501		//fprintf(stderr,"C:%01d; ",tms->subcycle);
2502		fprintf(stderr,"IP:%01d PC:%02d X:%04d E:%03d P:%03d Pc:%03d ",m_IP, m_PC,
2503		m_excitation_data, m_current_energy, m_current_pitch, m_pitch_count);
2504		//fprintf(stderr,"X:%04d E:%03d P:%03d Pc:%03d ", m_excitation_data, m_current_energy, m_current_pitch, m_pitch_count);
2505		for (i=0; i<10; i++)
2506		fprintf(stderr,"K%d:%04d ", i+1, m_current_k[i]);
2507		fprintf(stderr,"Out:%06d", this_sample);
2508		fprintf(stderr,"\n");
2509		#endif
2510		// next, force result to 14 bits (since its possible that the addition at the final (k1) stage of the lattice overflowed)
2511		while (this_sample > 16383) this_sample -= 32768;
2512		while (this_sample < -16384) this_sample += 32768;
2513		if (!m_digital_select) // analog SPK pin output is only 8 bits, with clipping
2514		buffer[buf_count] = clip_analog(this_sample);
2515		else // digital I/O pin output is 12 bits
2516		{
2517		#ifdef ALLOW_4_LSB
2518		// input:  ssss ssss ssss ssss ssnn nnnn nnnn nnnn
2519		// N taps:                       ^                 = 0x2000;
2520		// output: ssss ssss ssss ssss snnn nnnn nnnn nnnN
2521		buffer[buf_count] = (this_sample<<1)|((this_sample&0x2000)>>13);
2522		#else
2523		this_sample &= ~0xF;
2524		// input:  ssss ssss ssss ssss ssnn nnnn nnnn 0000
2525		// N taps:                       ^^ ^^^            = 0x3E00;
2526		// output: ssss ssss ssss ssss snnn nnnn nnnN NNNN
2527		buffer[buf_count] = (this_sample<<1)|((this_sample&0x3E00)>>9);
2528		#endif
2529		}
2530
2531		// Update all counts
2532		m_subcycle++;
2533		if ((m_subcycle == 2) && (m_PC == 12))
2534		{
2535		/* Circuit 412 in the patent acts a reset, resetting the pitch counter to 0
2536		* if INHIBIT was true during the most recent frame transition.
2537		* The exact time this occurs is betwen IP=7, PC=12 sub=0, T=t12
2538		* and tms->IP = 0, PC=0 sub=0, T=t12, a period of exactly 20 cycles,
2539		* which overlaps the time OLDE and OLDP are updated at IP=7 PC=12 T17
2540		* (and hence INHIBIT itself 2 t-cycles later). We do it here because it is
2541		* convenient and should make no difference in output.
2542		*/
2543		if ((m_IP == 7) && m_inhibit) m_pitch_count = 0;
2544		m_subcycle = m_subc_reload;
2545		m_PC = 0;
2546		m_IP++;
2547		m_IP &= 0x7;
2548		}
2549		else if (m_subcycle == 3)
2550		{
2551		m_subcycle = m_subc_reload;
2552		m_PC++;
2553		}
2554		m_pitch_count++;
2555		if (m_pitch_count >= m_current_pitch) m_pitch_count = 0;
2556		m_pitch_count &= 0x1FF;
2557		buf_count++;
2558		size--;
2559		}
2560
2561		empty:
2562
2563		while (size > 0)
2564		{
2565		m_subcycle++;
2566		if ((m_subcycle == 2) && (m_PC == 12))
2567		{
2568		m_subcycle = m_subc_reload;
2569		m_PC = 0;
2570		m_IP++;
2571		m_IP &= 0x7;
2572		}
2573		else if (m_subcycle == 3)
2574		{
2575		m_subcycle = m_subc_reload;
2576		m_PC++;
2577		}
2578		buffer[buf_count] = -1; // should be just -1; actual chip outputs -1 every idle sample; (cf note in data sheet, p 10, table 4)
2579		buf_count++;
2580		size--;
2581		}
2582		}
2583
2584		/******************************************************************************
2585		lattice_filter -- executes one 'full run' of the lattice filter on a
2586		specific byte of excitation data, and specific values of all the current k
2587		constants,  and returns the resulting sample.
2588		******************************************************************************/
2589
2590		INT32 tms52xx_device::lattice_filter()
2591		{
2592		/* Lattice filter here */
2593		/* Aug/05/07: redone as unrolled loop, for clarity - LN
2594		* Originally Copied verbatim from table I in US patent 4,209,804, now updated
2595		* to be in same order as the actual chip does it, not that it matters.
2596		* notation equivalencies from table:
2597		*      Yn(i) == m_u[n-1]
2598		*      Kn = m_current_k[n-1]
2599		*      bn = m_x[n-1]
2600		*/
2601
2602		m_u[10] = matrix_multiply(m_previous_energy, (m_excitation_data<<6));  //Y(11)
2603		m_u[9] = m_u[10] - matrix_multiply(m_current_k[9], m_x[9]);
2604		m_u[8] = m_u[9] - matrix_multiply(m_current_k[8], m_x[8]);
2605		m_u[7] = m_u[8] - matrix_multiply(m_current_k[7], m_x[7]);
2606		m_u[6] = m_u[7] - matrix_multiply(m_current_k[6], m_x[6]);
2607		m_u[5] = m_u[6] - matrix_multiply(m_current_k[5], m_x[5]);
2608		m_u[4] = m_u[5] - matrix_multiply(m_current_k[4], m_x[4]);
2609		m_u[3] = m_u[4] - matrix_multiply(m_current_k[3], m_x[3]);
2610		m_u[2] = m_u[3] - matrix_multiply(m_current_k[2], m_x[2]);
2611		m_u[1] = m_u[2] - matrix_multiply(m_current_k[1], m_x[1]);
2612		m_u[0] = m_u[1] - matrix_multiply(m_current_k[0], m_x[0]);
2613		m_x[9] = m_x[8] + matrix_multiply(m_current_k[8], m_u[8]);
2614		m_x[8] = m_x[7] + matrix_multiply(m_current_k[7], m_u[7]);
2615		m_x[7] = m_x[6] + matrix_multiply(m_current_k[6], m_u[6]);
2616		m_x[6] = m_x[5] + matrix_multiply(m_current_k[5], m_u[5]);
2617		m_x[5] = m_x[4] + matrix_multiply(m_current_k[4], m_u[4]);
2618		m_x[4] = m_x[3] + matrix_multiply(m_current_k[3], m_u[3]);
2619		m_x[3] = m_x[2] + matrix_multiply(m_current_k[2], m_u[2]);
2620		m_x[2] = m_x[1] + matrix_multiply(m_current_k[1], m_u[1]);
2621		m_x[1] = m_x[0] + matrix_multiply(m_current_k[0], m_u[0]);
2622		m_x[0] = m_u[0];
2623		m_previous_energy = m_current_energy;
2624		#ifdef DEBUG_LATTICE
2625
2626		int i;
2627		fprintf(stderr,"V:%04d ", m_u[10]);
2628		for (i = 9; i >= 0; i--)
2629		{
2630		fprintf(stderr,"Y%d:%04d ", i+1, m_u[i]);
2631		fprintf(stderr,"b%d:%04d ", i+1, m_x[i]);
2632		if ((i % 5) == 0) fprintf(stderr,"\n");
2633		}
2634		#endif
2635		return m_u[0];
2636		}
2637
2638		/**********************************************************************************************
2639		data_write -- handle a write to the TMS5220
2640		***********************************************************************************************/
2641
2642		void tms52xx_device::data_write(int data)
2643		{
2644		#ifdef DEBUG_DUMP_INPUT_DATA
2645		fprintf(stdout, "%c",data);
2646		#endif
2647		if (m_speak_external) // If we're in speak external mode
2648		{
2649		/* add this byte to the FIFO */
2650		if (m_fifo_count < FIFO_SIZE)
2651		{
2652		m_fifo[m_fifo_tail] = data;
2653		m_fifo_tail = (m_fifo_tail + 1) % FIFO_SIZE;
2654		m_fifo_count++;
2655		#ifdef DEBUG_FIFO
2656		logerror("tms52xx: data_write: Added byte to FIFO (current count=%2d)\n", m_fifo_count);
2657		#endif
2658		update_status_and_ints();
2659		if ((!m_talk_status) && (!m_buffer_low)) // we just unset buffer low with that last write, and talk status *was* zero...
2660		{
2661		int i;
2662		#ifdef DEBUG_FIFO
2663		logerror("tms52xx: data_write triggered talk status to go active!\n");
2664		#endif
2665		/* ...then we now have enough bytes to start talking; clear out
2666		* the new frame parameters (it will become old frame just before the first call to parse_frame())
2667		* TODO: the 3 lines below (and others) are needed for victory
2668		* to not fail its selftest due to a sample ending too late, may require additional investigation */
2669		m_subcycle = m_subc_reload;
2670		m_PC = 0;
2671		m_IP = reload_table[m_tms5220c_rate & 0x3]; // is this correct? should this be always 7 instead, so that the new frame is loaded quickly?
2672		m_new_frame_energy_idx = 0;
2673		m_new_frame_pitch_idx = 0;
2674
2675		for (i = 0; i < 4; i++)
2676		m_new_frame_k_idx[i] = 0;
2677		for (i = 4; i < 7; i++)
2678		m_new_frame_k_idx[i] = 0xF;
2679		for (i = 7; i < m_coeff->num_k; i++)
2680		m_new_frame_k_idx[i] = 0x7;
2681		m_talk_status = m_speaking_now = true;
2682		}
2683		}
2684		else
2685		{
2686		#ifdef DEBUG_FIFO
2687		logerror("tms52xx: data_write: Ran out of room in the tms52xx FIFO! this should never happen!\n");
2688		// at this point, /READY should remain HIGH/inactive until the fifo has at least one byte open in it.
2689		#endif
2690		}
2691
2692
2693		}
2694		else //(! m_speak_external)
2695		/* R Nabet : we parse commands at once.  It is necessary for such commands as read. */
2696		process_command(data);
2697		}
2698
2699		/******************************************************************************
2700		process_command -- extract a byte from the FIFO and interpret it as a command
2701		*******************************************************************************/
2702
2703		void tms52xx_device::process_command(unsigned char cmd)
2704		{
2705		#ifdef DEBUG_COMMAND_DUMP
2706		fprintf(stderr,"process_command called with parameter %02X\n",cmd);
2707		#endif
2708		// parse the command
2709		switch (cmd & 0x70)
2710		{
2711		case 0x10 : // read byte
2712		if (!m_talk_status) // TALKST must be clear for RDBY
2713		{
2714		if (m_schedule_dummy_read)
2715		{
2716		m_schedule_dummy_read = false;
2717		(void)m_read_mem(1);
2718		}
2719		m_data_register = m_read_mem(8);    // read one byte from speech ROM...
2720		m_RDB_flag = true;
2721		}
2722		break;
2723
2724		case 0x00:
2725		case 0x20: // set rate (tms5220c only), otherwise NOP
2726		if (m_variant == TMS5220_IS_5220C)
2727		{
2728		m_tms5220c_rate = cmd & 0x0F;
2729		}
2730		break;
2731
2732		case 0x30: // read and branch
2733		if (!m_talk_status) // TALKST must be clear for RB
2734		{
2735		#ifdef VERBOSE
2736		logerror("tms5520: read and branch command received\n");
2737		#endif
2738		m_RDB_flag = false;
2739		m_read_and_branch(0, 0);
2740		}
2741		break;
2742
2743		case 0x40 : // load address
2744		if (!m_talk_status) // TALKST must be clear for LA
2745		{
2746		// tms5220 data sheet says that if we load only one 4-bit nibble, it won't work.
2747		// This code does not care about this.
2748		m_load_address(0, cmd & 0x0f);
2749		m_schedule_dummy_read = true;
2750		}
2751		break;
2752
2753		case 0x50:  // speak
2754		if (m_schedule_dummy_read)
2755		{
2756		m_schedule_dummy_read = false;
2757		(void)m_read_mem(1);
2758		}
2759		m_speaking_now = true;
2760		m_speak_external = false;
2761		m_talk_status = true;  // start immediately
2762		// clear out variables before speaking
2763		// TODO: similar to the victory case described above, but for VSM speech
2764		m_subcycle = m_subc_reload;
2765		m_PC = 0;
2766		m_IP = reload_table[m_tms5220c_rate & 0x3];
2767		m_new_frame_energy_idx = 0;
2768		m_new_frame_pitch_idx = 0;
2769
2770		int i;
2771		for (i = 0; i < 4; i++)
2772		m_new_frame_k_idx[i] = 0;
2773		for (i = 4; i < 7; i++)
2774		m_new_frame_k_idx[i] = 0xF;
2775		for (i = 7; i < m_coeff->num_k; i++)
2776		m_new_frame_k_idx[i] = 0x7;
2777		break;
2778
2779		case 0x60: // speak external
2780		//SPKEXT going active activates SPKEE which clears the fifo
2781		m_fifo_head = m_fifo_tail = 0;
2782		m_fifo_count = m_fifo_bits_taken = 0;
2783		m_speak_external = true;
2784		m_RDB_flag = false;
2785		break;
2786
2787		case 0x70: // reset
2788		if (m_schedule_dummy_read)
2789		{
2790		m_schedule_dummy_read = false;
2791		(void)m_read_mem(1);
2792		}
2793		device_reset();
2794		break;
2795		}
2796
2797		// update the buffer low state
2798		update_status_and_ints();
2799		}
2800
2801		/******************************************************************************
2802		parse_frame -- parse a new frame's worth of data; returns 0 if not
2803		enough bits in buffer
2804		*******************************************************************************/
2805
2806		void tms52xx_device::parse_frame()
2807		{
2808		int indx, i, rep_flag;
2809
2810		/* We actually don't care how many bits are left in the fifo here; the
2811		* frame subpart will be processed normally, and any bits extracted 'past
2812		* the end' of the fifo will be read as zeroes; the fifo being emptied will
2813		* set the /BE latch which will halt speech exactly as if a stop frame had
2814		* been encountered (instead of whatever partial frame was read); the same
2815		* exact circuitry is used for both on the real chip, see us patent 4335277
2816		* sheet 16, gates 232a (decode stop frame) and 232b (decode /BE plus DDIS
2817		* (decode disable) which is active during speak external). */
2818
2819		/* if the chip is a tms5220C, and the rate mode is set to that each frame (0x04 bit set)
2820		* has a 2 bit rate preceding it, grab two bits here and store them as the rate; */
2821		if ((m_variant == TMS5220_IS_5220C) && (m_tms5220c_rate & 0x04))
2822		{
2823		indx = extract_bits(2);
2824		#ifdef DEBUG_PARSE_FRAME_DUMP
2825		printbits(indx,2);
2826		fprintf(stderr," ");
2827		#endif
2828		m_IP = reload_table[indx];
2829		}
2830		else // non-5220C and 5220C in fixed rate mode
2831		m_IP = reload_table[m_tms5220c_rate & 0x3];
2832
2833		update_status_and_ints();
2834		if (!m_talk_status) goto ranout;
2835
2836		// attempt to extract the energy index
2837		m_new_frame_energy_idx = extract_bits(m_coeff->energy_bits);
2838		#ifdef DEBUG_PARSE_FRAME_DUMP
2839		printbits(m_new_frame_energy_idx,m_coeff->energy_bits);
2840		fprintf(stderr," ");
2841		#endif
2842		update_status_and_ints();
2843		if (!m_talk_status) goto ranout;
2844		// if the energy index is 0 or 15, we're done
2845		if ((m_new_frame_energy_idx == 0) || (m_new_frame_energy_idx == 15))
2846		return;
2847
2848		// attempt to extract the repeat flag
2849		rep_flag = extract_bits(1);
2850		#ifdef DEBUG_PARSE_FRAME_DUMP
2851		printbits(rep_flag, 1);
2852		fprintf(stderr," ");
2853		#endif
2854
2855		// attempt to extract the pitch
2856		m_new_frame_pitch_idx = extract_bits(m_coeff->pitch_bits);
2857		#ifdef DEBUG_PARSE_FRAME_DUMP
2858		printbits(m_new_frame_pitch_idx, m_coeff->pitch_bits);
2859		fprintf(stderr," ");
2860		#endif
2861		update_status_and_ints();
2862		if (!m_talk_status) goto ranout;
2863		/* if this is a repeat frame, just do nothing, it will reuse the
2864		* old coefficients */
2865		if (rep_flag) return;
2866
2867		// extract first 4 K coefficients
2868		for (i = 0; i < 4; i++)
2869		{
2870		m_new_frame_k_idx[i] = extract_bits(m_coeff->kbits[i]);
2871		#ifdef DEBUG_PARSE_FRAME_DUMP
2872		printbits(m_new_frame_k_idx[i], m_coeff->kbits[i]);
2873		fprintf(stderr," ");
2874		#endif
2875		update_status_and_ints();
2876		if (!m_talk_status) goto ranout;
2877		}
2878
2879		// if the pitch index was zero, we only need 4 K's...
2880		if (m_new_frame_pitch_idx == 0)
2881		{
2882		// and the rest of the coefficients are zeroed, but that's done in the generator code
2883		return;
2884		}
2885
2886		// If we got here, we need the remaining 6 K's
2887		for (i = 4; i < m_coeff->num_k; i++)
2888		{
2889		m_new_frame_k_idx[i] = extract_bits(m_coeff->kbits[i]);
2890		#ifdef DEBUG_PARSE_FRAME_DUMP
2891		printbits(m_new_frame_k_idx[i], m_coeff->kbits[i]);
2892		fprintf(stderr," ");
2893		#endif
2894		update_status_and_ints();
2895		if (!m_talk_status) goto ranout;
2896		}
2897		#ifdef VERBOSE
2898		if (m_speak_external)
2899		logerror("tms52xx: Parsed a frame successfully in FIFO - %d bits remaining\n", (m_fifo_count*8)-(m_fifo_bits_taken));
2900		else
2901		logerror("tms52xx: Parsed a frame successfully in ROM\n");
2902		#endif
2903		return;
2904
2905		ranout:
2906		#ifdef DEBUG_FRAME_ERRORS
2907		logerror("tms52xx: Ran out of bits on a parse!\n");
2908		#endif
2909		return;
2910		}
2911
2912		/**********************************************************************************************
2913
2914		update_status_and_ints -- check to see if the various flags should be on or off
2915		Description of flags, and their position in the status register:
2916		From the data sheet:
2917		bit D0(bit 7) = TS - Talk Status is active (high) when the VSP is processing speech data.
2918		Talk Status goes active at the initiation of a Speak command or after nine
2919		bytes of data are loaded into the FIFO following a Speak External command. It
2920		goes inactive (low) when the stop code (Energy=1111) is processed, or
2921		immediately by a buffer empty condition or a reset command.
2922		bit D1(bit 6) = BL - Buffer Low is active (high) when the FIFO buffer is more than half empty.
2923		Buffer Low is set when the "Last-In" byte is shifted down past the half-full
2924		boundary of the stack. Buffer Low is cleared when data is loaded to the stack
2925		so that the "Last-In" byte lies above the half-full boundary and becomes the
2926		eighth data byte of the stack.
2927		bit D2(bit 5) = BE - Buffer Empty is active (high) when the FIFO buffer has run out of data
2928		while executing a Speak External command. Buffer Empty is set when the last bit
2929		of the "Last-In" byte is shifted out to the Synthesis Section. This causes
2930		Talk Status to be cleared. Speech is terminated at some abnormal point and the
2931		Speak External command execution is terminated.
2932
2933		***********************************************************************************************/
2934
2935		void tms52xx_device::update_status_and_ints()
2936		{
2937		// update flags and set ints if needed
2938		update_ready_state();
2939
2940		/* BL is set if neither byte 9 nor 8 of the fifo are in use; this
2941		* translates to having fifo_count (which ranges from 0 bytes in use to 16
2942		* bytes used) being less than or equal to 8. Victory/Victorba depends on this. */
2943		if (m_fifo_count <= 8)
2944		{
2945		// generate an interrupt if necessary; if /BL was inactive and is now active, set int.
2946		if (!m_buffer_low) set_interrupt_state(1);
2947		m_buffer_low = true;
2948		}
2949		else
2950		m_buffer_low = false;
2951
2952		/* BE is set if neither byte 15 nor 14 of the fifo are in use; this
2953		* translates to having fifo_count equal to exactly 0 */
2954		if (m_fifo_count == 0)
2955		{
2956		// generate an interrupt if necessary; if /BE was inactive and is now active, set int.
2957		if (!m_buffer_empty) set_interrupt_state(1);
2958		m_buffer_empty = true;
2959		}
2960		else
2961		m_buffer_empty = false;
2962
2963		/* TS is talk status and is set elsewhere in the fifo parser and in
2964		* the SPEAK command handler; however, if /BE is true during speak external
2965		* mode, it is immediately unset here. */
2966		if (m_speak_external && m_buffer_empty)
2967		{
2968		// generate an interrupt: /TS was active, and is now inactive.
2969		if (m_talk_status)
2970		{
2971		m_talk_status = m_speak_external = false;
2972		set_interrupt_state(1);
2973		}
2974		}
2975		/* Note that TS being unset will also generate an interrupt when a STOP
2976		* frame is encountered; this is handled in the sample generator code and not here */
2977		}
2978
2979		/******************************************************************************
2980		extract_bits -- extract a specific number of bits from the current input stream (FIFO or VSM)
2981		*******************************************************************************/
2982
2983		int tms52xx_device::extract_bits(int count)
2984		{
2985		int val = 0;
2986
2987		if (m_speak_external)
2988		{
2989		// extract from FIFO
2990		while (count--)
2991		{
2992		val = (val << 1) | ((m_fifo[m_fifo_head] >> m_fifo_bits_taken) & 1);
2993		m_fifo_bits_taken++;
2994		if (m_fifo_bits_taken >= 8)
2995		{
2996		m_fifo_count--;
2997		m_fifo[m_fifo_head] = 0; // zero the newly depleted fifo head byte
2998		m_fifo_head = (m_fifo_head + 1) % FIFO_SIZE;
2999		m_fifo_bits_taken = 0;
3000		update_status_and_ints();
3001		}
3002		}
3003		}
3004		else
3005		{
3006		// extract from VSM (speech ROM)
3007		val = m_read_mem(count);
3008		}
3009		return val;
3010		}
3011
3012		/******************************************************************************
3013		status_read -- read status or data from the TMS5220
3014		*******************************************************************************/
3015
3016		int tms52xx_device::status_read()
3017		{
3018		if (m_RDB_flag)
3019		{   // if last command was read, return data register
3020		m_RDB_flag = false;
3021		return m_data_register;
3022		}
3023		else
3024		{   // read status
3025		// clear the interrupt pin on status read
3026		set_interrupt_state(0);
3027		#ifdef DEBUG_PIN_READS
3028		logerror("tms52xx: Status read: TS=%d BL=%d BE=%d\n", m_talk_status, m_buffer_low, m_buffer_empty);
3029		#endif
3030
3031		int retvalue = 0;
3032		if (m_talk_status) retvalue |= 0x80;
3033		if (m_buffer_low) retvalue |= 0x40;
3034		if (m_buffer_empty) retvalue |= 0x20;
3035		return retvalue;
3036		}
3037		}
3038
3039		/******************************************************************************
3040		ready_read -- returns the ready state of the TMS5220
3041		*******************************************************************************/
3042
3043		inline bool tms52xx_device::ready_read()
3044		{
3045		#ifdef DEBUG_PIN_READS
3046		logerror("tms52xx: ready_read: ready pin read, io_ready is %d, fifo count is %d\n", m_io_ready, m_fifo_count);
3047		#endif
3048		return ((m_fifo_count < FIFO_SIZE)||(!m_speak_external)) && m_io_ready;
3049		}
3050
3051		/******************************************************************************
3052		int_read -- returns the interrupt state of the TMS5220
3053		*******************************************************************************/
3054
3055		inline int tms52xx_device::int_read()
3056		{
3057		#ifdef DEBUG_PIN_READS
3058		logerror("tms52xx: int_read: irq pin read, state is %d\n", m_irq_pin);
3059		#endif
3060		return m_irq_pin;
3061		}
3062
3063		/******************************************************************************
3064		cycles_to_ready -- returns the number of cycles until ready is asserted
3065		NOTE: this function is deprecated and is known to be VERY inaccurate.
3066		Use at your own peril!
3067		*******************************************************************************/
3068
3069		int tms52xx_device::cycles_to_ready()
3070		{
3071		int answer;
3072
3073		if (ready_read()) answer = 0;
3074		else
3075		{
3076		int val;
3077		int samples_per_frame = (m_subc_reload!=0)?200:304; // either (13 A cycles + 12 B cycles) * 8 interps for normal SPEAK/SPKEXT, or (13*2 A cycles + 12 B cycles) * 8 interps for SPKSLOW
3078		int current_sample = ((m_PC * (3-m_subc_reload)) + (((m_subc_reload!=0)? 38:25) * m_IP));
3079		answer = samples_per_frame - current_sample + 8;
3080
3081		// total number of bits available in current byte is (8 - tms->fifo_bits_taken)
3082		// if more than 4 are available, we need to check the energy
3083		if (m_fifo_bits_taken < 4)
3084		{
3085		// read energy
3086		val = (m_fifo[m_fifo_head] >> m_fifo_bits_taken) & 0xf;
3087		if (val == 0)
3088		// 0 -> silence frame: we will only read 4 bits, and we will
3089		// therefore need to read another frame before the FIFO is not
3090		// full any more
3091		answer += (m_subc_reload!=0)?200:304;
3092		// 15 -> stop frame, we will only read 4 bits, but the FIFO will
3093		// we cleared
3094		//otherwise, we need to parse the repeat flag (1 bit) and the
3095		// pitch (6 bits), so everything will be OK.
3096		}
3097		}
3098		return answer;
3099		}
3100
3101		/******************************************************************************
3102		True timing
3103		*******************************************************************************/
3104
3105		void tms52xx_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
3106		{
3107		if (param)
3108		{
3109		switch (m_rs_ws)
3110		{
3111		case 0x02:
3112		// Write
3113		// bring up to date first
3114		#ifdef DEBUG_IO_READY
3115		logerror("tms52xx: Serviced write: %02x\n", tms->write_latch);
3116		//fprintf(stderr, "Processed write data: %02X\n", tms->write_latch);
3117		#endif
3118		m_stream->update();
3119		data_write(m_write_latch);
3120		break;
3121		case 0x01:
3122		// Read
3123		// bring up to date first
3124		m_stream->update();
3125		m_read_latch = status_read();
3126		break;
3127		case 0x03:
3128		// High Impedance
3129		case 0x00:
3130		// illegal
3131		break;
3132		}
3133		}
3134		m_io_ready = param;
3135		update_ready_state();
3136		}
3137
3138		/*****************************************************
3139		/RS line write handler
3140		*****************************************************/
3141
3142		WRITE_LINE_MEMBER( tms52xx_device::rsq_w )
3143		{
3144		UINT8 new_val;
3145
3146		m_true_timing = true;
3147		state &= 0x01;
3148		#ifdef DEBUG_RS_WS
3149		logerror("tms52xx: /RS written with data: %d\n", state);
3150		#endif
3151		new_val = (m_rs_ws & 0x01) | (state<<1);
3152		if (new_val != m_rs_ws)
3153		{
3154		m_rs_ws = new_val;
3155		if (new_val == 0)
3156		{
3157		if (m_variant == TMS5220_IS_5220C)
3158		reset();
3159		#ifdef DEBUG_RS_WS
3160		else
3161		// illegal
3162		logerror("tms52xx: illegal line setting /RS=0 and /WS=0\n");
3163		#endif
3164		return;
3165		}
3166		else if (new_val == 3)
3167		{
3168		// high impedance
3169		m_read_latch = 0xff;
3170		return;
3171		}
3172		if (state)
3173		{
3174		// low to high
3175		}
3176		else
3177		{
3178		// high to low - schedule ready cycle
3179		#ifdef DEBUG_RS_WS
3180		logerror("tms52xx: Scheduling ready cycle for /RS...\n");
3181		#endif
3182		/* upon /RS being activated, /READY goes inactive after 100 nsec from
3183		* data sheet, through 3 asynchronous gates on patent. This is effectively
3184		* within one clock, so we immediately set io_ready to 0 and activate the callback. */
3185		m_io_ready = 0;
3186		update_ready_state();
3187		/* How long does /READY stay inactive, when /RS is pulled low?
3188		* I believe its almost always ~16 clocks (25 usec at 800khz as shown on the datasheet) */
3189		m_ready_timer->adjust(attotime::from_hz(clock()/16));
3190		}
3191		}
3192		}
3193
3194		/*****************************************************
3195		/WS line write handler
3196		*****************************************************/
3197
3198		WRITE_LINE_MEMBER( tms52xx_device::wsq_w )
3199		{
3200		UINT8 new_val;
3201
3202		m_true_timing = true;
3203		state &= 0x01;
3204		#ifdef DEBUG_RS_WS
3205		logerror("tms52xx: /WS written with data: %d\n", state);
3206		#endif
3207		new_val = (m_rs_ws & 0x02) | (state<<0);
3208		if (new_val != m_rs_ws)
3209		{
3210		m_rs_ws = new_val;
3211		if (new_val == 0)
3212		{
3213		if (m_variant == TMS5220_IS_5220C)
3214		reset();
3215		#ifdef DEBUG_RS_WS
3216		else
3217		// illegal
3218		logerror("tms52xx: illegal line setting /RS=0 and /WS=0\n");
3219		#endif
3220		return;
3221		}
3222		else if ( new_val == 3)
3223		{
3224		// high impedance
3225		m_read_latch = 0xff;
3226		return;
3227		}
3228		if (state)
3229		{
3230		// low to high
3231		}
3232		else
3233		{
3234		// high to low - schedule ready cycle
3235		#ifdef DEBUG_RS_WS
3236		logerror("tms52xx: Scheduling ready cycle for /WS...\n");
3237		#endif
3238		/* upon /WS being activated, /READY goes inactive after 100 nsec
3239		* from data sheet, through 3 asynchronous gates on patent.
3240		* This is effectively within one clock, so we immediately set
3241		* io_ready to 0 and activate the callback. */
3242		m_io_ready = 0;
3243		update_ready_state();
3244		/* Now comes the complicated part: long does /READY stay inactive
3245		* when /WS is pulled low? This depends ENTIRELY on the command written,
3246		* or whether the chip is in speak external mode or not...
3247		* Speak external mode: ~16 cycles
3248		* Command Mode:
3249		* SPK: ? cycles
3250		* SPKEXT: ? cycles
3251		* RDBY: between 60 and 140 cycles
3252		* RB: ? cycles (80?)
3253		* RST: between 60 and 140 cycles
3254		* SET RATE (5220C only): ? cycles (probably ~16) */
3255
3256		// TODO: actually HANDLE the timing differences! currently just assuming always 16 cycles
3257		m_ready_timer->adjust(attotime::from_hz(clock()/16));
3258		}
3259		}
3260		}
3261
3262		/*****************************************************************************
3263		write -- write data to the sound chip
3264		*******************************************************************************/
3265
3266		WRITE8_MEMBER( tms52xx_device::write )
3267		{
3268		#ifdef DEBUG_RS_WS
3269		logerror("tms52xx: write data %02x\n", data);
3270		#endif
3271		if (!m_true_timing)
3272		{
3273		// bring up to date first
3274		m_stream->update();
3275		data_write(data);
3276		}
3277		else
3278		{
3279		// actually in a write?
3280		#ifdef DEBUG_RS_WS
3281		if (!(m_rs_ws == 0x02))
3282		logerror("tms52xx: write data written outside ws, status: %02x!\n", m_rs_ws);
3283		#endif
3284		m_write_latch = data;
3285		}
3286		}
3287
3288		/******************************************************************************
3289		read -- read status or data from the sound chip
3290		*******************************************************************************/
3291
3292		READ8_MEMBER( tms52xx_device::read )
3293		{
3294		if (!m_true_timing)
3295		{
3296		// bring up-to-date first
3297		m_stream->update();
3298		return status_read();
3299		}
3300		else
3301		{
3302		// actually in a read?
3303		if (m_rs_ws == 0x01)
3304		return m_read_latch;
3305		#ifdef DEBUG_RS_WS
3306		else
3307		logerror("tms52xx: data read outside rs!\n");
3308		#endif
3309		return 0xff;
3310		}
3311		}
3312
3313		/*******************************************************************************
3314		ready -- return the not ready status from the sound chip
3315		*******************************************************************************/
3316
3317		READ_LINE_MEMBER( tms52xx_device::readyq )
3318		{
3319		// bring up-to-date first
3320		m_stream->update();
3321		return !ready_read();
3322		}
3323
3324
3325		/******************************************************************************
3326		time_to_ready -- return the time in seconds until the
3327		ready line is asserted
3328		*******************************************************************************/
3329
3330		double tms52xx_device::time_to_ready()
3331		{
3332		double cycles;
3333
3334		// bring up-to-date
3335		m_stream->update();
3336		cycles = cycles_to_ready();
3337		return cycles * 80.0 / m_clock;
3338		}
3339
3340		/******************************************************************************
3341		intq -- return the interrupt status from the sound chip
3342		******************************************************************************/
3343
3344		READ_LINE_MEMBER( tms52xx_device::intq )
3345		{
3346		// bring up-to-date first
3347		m_stream->update();
3348		return !int_read();
3349		}
3350
3351		void tms52xx_device::register_for_save_states()
3352		{
3353		save_item(NAME(m_fifo));
3354		save_item(NAME(m_fifo_head));
3355		save_item(NAME(m_fifo_tail));
3356		save_item(NAME(m_fifo_count));
3357		save_item(NAME(m_fifo_bits_taken));
3358
3359		save_item(NAME(m_speaking_now));
3360		save_item(NAME(m_speak_external));
3361		save_item(NAME(m_talk_status));
3362		save_item(NAME(m_buffer_low));
3363		save_item(NAME(m_buffer_empty));
3364		save_item(NAME(m_irq_pin));
3365		save_item(NAME(m_ready_pin));
3366
3367		save_item(NAME(m_OLDE));
3368		save_item(NAME(m_OLDP));
3369
3370		save_item(NAME(m_new_frame_energy_idx));
3371		save_item(NAME(m_new_frame_pitch_idx));
3372		save_item(NAME(m_new_frame_k_idx));
3373		#ifdef PERFECT_INTERPOLATION_HACK
3374		save_item(NAME(m_old_frame_energy_idx));
3375		save_item(NAME(m_old_frame_pitch_idx));
3376		save_item(NAME(m_old_frame_k_idx));
3377		#endif
3378		save_item(NAME(m_current_energy));
3379		save_item(NAME(m_current_pitch));
3380		save_item(NAME(m_current_k));
3381
3382		save_item(NAME(m_target_energy));
3383		save_item(NAME(m_target_pitch));
3384		save_item(NAME(m_target_k));
3385
3386		save_item(NAME(m_previous_energy));
3387
3388		save_item(NAME(m_subcycle));
3389		save_item(NAME(m_subc_reload));
3390		save_item(NAME(m_PC));
3391		save_item(NAME(m_IP));
3392		save_item(NAME(m_inhibit));
3393		save_item(NAME(m_tms5220c_rate));
3394		save_item(NAME(m_pitch_count));
3395
3396		save_item(NAME(m_u));
3397		save_item(NAME(m_x));
3398
3399		save_item(NAME(m_RNG));
3400		save_item(NAME(m_excitation_data));
3401
3402		save_item(NAME(m_schedule_dummy_read));
3403		save_item(NAME(m_data_register));
3404		save_item(NAME(m_RDB_flag));
3405		save_item(NAME(m_digital_select));
3406
3407		save_item(NAME(m_io_ready));
3408		}
3409
3410
3411		const device_type TMS5220N = &device_creator<tms5220n_device>;
3412		const device_type TMS5220CN = &device_creator<tms5220cn_device>;
3413		const device_type TMC0285N = &device_creator<tmc0285n_device>;
3414		const device_type TMS5200N = &device_creator<tms5200n_device>;

trunk/src/emu/sound/tms5220.h

r22818	r22819
3	3	#ifndef __TMS5220_H__
4	4	#define __TMS5220_H__
5	5
6		#include "devlegcy.h"
	6	#include "emu.h"
	7	#include "machine/spchrom.h"
7	8
	9	/* HACK: if defined, uses impossibly perfect 'straight line' interpolation */
	10	#undef PERFECT_INTERPOLATION_HACK
	11
8	12	#define FIFO_SIZE 16
9	13
10	14	/* clock rate = 80 * output sample rate,     */
11	15	/* usually 640000 for 8000 Hz sample rate or */
12	16	/* usually 800000 for 10000 Hz sample rate.  */
13	17
14		struct tms5220_interface
15		{
16		devcb_write_line irq_func;      /* IRQ callback function, active low, i.e. state=0 */
17		devcb_write_line readyq_func;   /* Ready callback function, active low, i.e. state=0 */
	18	/* IRQ callback function, active low, i.e. state=0 */
	19	#define MCFG_TMS52XX_IRQ_HANDLER(_devcb) \
	20	devcb = &tms5220_device::set_irq_handler(*device, DEVCB2_##_devcb);
18	21
19		int (*read)(device_t *device, int count);           /* speech ROM read callback */
20		void (*load_address)(device_t *device, int data);   /* speech ROM load address callback */
21		void (*read_and_branch)(device_t *device);      /* speech ROM read and branch callback */
22		};
	22	/* Ready callback function, active low, i.e. state=0 */
	23	#define MCFG_TMS52XX_READYQ_HANDLER(_devcb) \
	24	devcb = &tms5220_device::set_readyq_handler(*device, DEVCB2_##_devcb);
23	25
24		/* Control lines - once written to will switch interface into
25		* "true" timing behaviour.
26		*/
	26	#define MCFG_TMS52XX_SPEECHROM(_tag) \
	27	tms5220_device::set_speechrom_tag(*device, _tag);
27	28
28		/* all lines with suffix q are active low! */
29
30		WRITE_LINE_DEVICE_HANDLER( tms5220_rsq_w );
31		WRITE_LINE_DEVICE_HANDLER( tms5220_wsq_w );
32
33		DECLARE_WRITE8_DEVICE_HANDLER( tms5220_data_w );
34		DECLARE_READ8_DEVICE_HANDLER( tms5220_status_r );
35
36		READ_LINE_DEVICE_HANDLER( tms5220_readyq_r );
37		READ_LINE_DEVICE_HANDLER( tms5220_intq_r );
38
39
40		double tms5220_time_to_ready(device_t *device);
41
42		void tms5220_set_frequency(device_t *device, int frequency);
43
44	29	class tms5220_device : public device_t,
45	30	public device_sound_interface
46	31	{
47	32	public:
48	33	tms5220_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
49	34	tms5220_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock);
50		~tms5220_device() { global_free(m_token); }
51	35
52		// access to legacy token
53		void *token() const { assert(m_token != NULL); return m_token; }
54		protected:
55		// device-level overrides
56		virtual void device_config_complete();
57		virtual void device_start();
58		virtual void device_reset();
	36	// static configuration helpers
	37	template<class _Object> static devcb2_base &set_irq_handler(device_t &device, _Object object) { return downcast<tms5220_device &>(device).m_irq_handler.set_callback(object); }
	38	template<class _Object> static devcb2_base &set_readyq_handler(device_t &device, _Object object) { return downcast<tms5220_device &>(device).m_readyq_handler.set_callback(object); }
	39	static void set_speechrom_tag(device_t &device, const char *_tag) { downcast<tms5220_device &>(device).m_speechrom_tag = _tag; }
59	40
60		// sound stream update overrides
61		virtual void sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples);
62		private:
63		// internal state
64		void *m_token;
65		};
	41	/* Control lines - once written to will switch interface into
	42	* "true" timing behaviour.
	43	*/
66	44
67		extern const device_type TMS5220;
	45	/* all lines with suffix q are active low! */
68	46
69		class tms5220c_device : public tms5220_device
70		{
71		public:
72		tms5220c_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
73		protected:
74		// device-level overrides
75		virtual void device_start();
	47	WRITE_LINE_MEMBER( rsq_w );
	48	WRITE_LINE_MEMBER( wsq_w );
76	49
77		// sound stream update overrides
78		virtual void sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples);
79		};
	50	DECLARE_WRITE8_MEMBER( data_w );
	51	DECLARE_READ8_MEMBER( status_r );
80	52
81		extern const device_type TMS5220C;
	53	READ_LINE_MEMBER( readyq_r );
	54	READ_LINE_MEMBER( intq_r );
82	55
83		class tmc0285_device : public tms5220_device
84		{
85		public:
86		tmc0285_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
87		protected:
88		// device-level overrides
89		virtual void device_start();
	56	double time_to_ready();
90	57
91		// sound stream update overrides
92		virtual void sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples);
93		};
	58	void set_frequency(int frequency);
94	59
95		extern const device_type TMC0285;
96
97		class tms5200_device : public tms5220_device
98		{
99		public:
100		tms5200_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
101	60	protected:
102	61	// device-level overrides
	62	virtual void device_config_complete();
103	63	virtual void device_start();
	64	virtual void device_reset();
104	65
	66	virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
	67
105	68	// sound stream update overrides
106	69	virtual void sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples);
107		};
108	70
109		extern const device_type TMS5200;
	71	void set_variant(int variant);
110	72
111
112
113		/***************************************************************************
114		New class implementation
115		Michael Zapf, June 2012
116		***************************************************************************/
117
118		extern const device_type TMS5220N;
119		extern const device_type TMS5220CN;
120		extern const device_type TMC0285N;
121		extern const device_type TMS5200N;
122
123
124		struct tms52xx_config
125		{
126		devcb_write_line        irq_func;                   // IRQ callback function, active low, i.e. state=0  (TODO: change to ASSERT/CLEAR)
127		devcb_write_line        readyq_func;                // Ready callback function, active low, i.e. state=0
128
129		devcb_read8             read_mem;                   // speech ROM read callback
130		devcb_write8            load_address;               // speech ROM load address callback
131		devcb_write8            read_and_branch;            // speech ROM read and branch callback
132
133		};
134
135		// Change back from 5220n to 5220 when all client drivers will be converted
136		class tms52xx_device : public device_t, public device_sound_interface
137		{
138		public:
139		tms52xx_device(const machine_config &mconfig, device_type type,  const char *name, const char *tag, const struct tms5100_coeffs* coeffs, const int var, device_t *owner, UINT32 clock);
140		virtual void sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples);
141		virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
142
143		DECLARE_WRITE_LINE_MEMBER( rsq_w );
144		DECLARE_WRITE_LINE_MEMBER( wsq_w );
145		DECLARE_WRITE8_MEMBER( write );
146		DECLARE_READ8_MEMBER( read );
147		DECLARE_READ_LINE_MEMBER( readyq );
148		DECLARE_READ_LINE_MEMBER( intq );
149
150		double time_to_ready();
151
152		protected:
153		virtual void device_start();
154		virtual void device_reset();
155
156	73	private:
157		// Methods
158		void set_interrupt_state(int state);
159	74	void register_for_save_states();
160		void update_ready_state();
161		void set_frequency(int frequency);
162		void process(INT16 *buffer, unsigned int size);
163	75	void data_write(int data);
164	76	void update_status_and_ints();
165		void parse_frame();
166
167	77	int extract_bits(int count);
168	78	int status_read();
	79	int ready_read();
169	80	int cycles_to_ready();
	81	int int_read();
	82	void process(INT16 *buffer, unsigned int size);
170	83	INT32 lattice_filter();
171	84	void process_command(unsigned char cmd);
	85	void parse_frame();
	86	void set_interrupt_state(int state);
	87	void update_ready_state();
172	88
173		inline bool ready_read();
174		inline int int_read();
	89	// internal state
175	90
176		// coefficient tables
177		const int m_variant;                // Variant of the 5xxx - see tms5110r.h
	91	/* coefficient tables */
	92	int m_variant;                /* Variant of the 5xxx - see tms5110r.h */
178	93
179		// coefficient tables
	94	/* coefficient tables */
180	95	const struct tms5100_coeffs *m_coeff;
181	96
182		// callbacks
183		devcb_resolved_write_line   m_irq_func;
184		devcb_resolved_write_line   m_readyq_func;
185		devcb_resolved_read8        m_read_mem;
186		devcb_resolved_write8       m_load_address;
187		devcb_resolved_write8       m_read_and_branch;
	97	/* these contain data that describes the 128-bit data FIFO */
	98	UINT8 m_fifo[FIFO_SIZE];
	99	UINT8 m_fifo_head;
	100	UINT8 m_fifo_tail;
	101	UINT8 m_fifo_count;
	102	UINT8 m_fifo_bits_taken;
188	103
189		// these contain data that describes the 128-bit data FIFO
190		UINT8   m_fifo[FIFO_SIZE];
191		UINT8   m_fifo_head;
192		UINT8   m_fifo_tail;
193		int     m_fifo_count;
194		int     m_fifo_bits_taken;
195	104
196		// these contain global status bits
197		bool    m_speaking_now;     // True only if actual speech is being generated right now. Is set when a speak vsm command happens OR when speak external happens and buffer low becomes nontrue; Is cleared when speech halts after the last stop frame or the last frame after talk status is otherwise cleared.
198		bool    m_speak_external;   // If 1, DDIS is 1, i.e. Speak External command in progress, writes go to FIFO.
199		bool    m_talk_status;      // If 1, TS status bit is 1, i.e. speak or speak external is in progress and we have not encountered a stop frame yet; talk_status differs from speaking_now in that speaking_now is set as soon as a speak or speak external command is started; talk_status does NOT go active until after 8 bytes are written to the fifo on a speak external command, otherwise the two are the same. TS is cleared by 3 things: 1. when a STOP command has just been processed as a new frame in the speech stream; 2. if the fifo runs out in speak external mode; 3. on power-up/during a reset command; When it gets cleared, speak_external is also cleared, an interrupt is generated, and speaking_now will be cleared when the next frame starts.
200		bool    m_buffer_low;       // If 1, FIFO has less than 8 bytes in it
201		bool    m_buffer_empty;     // If 1, FIFO is empty
202		int     m_irq_pin;          // state of the IRQ pin (output)
203		int     m_ready_pin;        // state of the READY pin (output)
	105	/* these contain global status bits */
	106	UINT8 m_speaking_now;     /* True only if actual speech is being generated right now. Is set when a speak vsm command happens OR when speak external happens and buffer low becomes nontrue; Is cleared when speech halts after the last stop frame or the last frame after talk status is otherwise cleared.*/
	107	UINT8 m_speak_external;   /* If 1, DDIS is 1, i.e. Speak External command in progress, writes go to FIFO. */
	108	UINT8 m_talk_status;      /* If 1, TS status bit is 1, i.e. speak or speak external is in progress and we have not encountered a stop frame yet; talk_status differs from speaking_now in that speaking_now is set as soon as a speak or speak external command is started; talk_status does NOT go active until after 8 bytes are written to the fifo on a speak external command, otherwise the two are the same. TS is cleared by 3 things: 1. when a STOP command has just been processed as a new frame in the speech stream; 2. if the fifo runs out in speak external mode; 3. on power-up/during a reset command; When it gets cleared, speak_external is also cleared, an interrupt is generated, and speaking_now will be cleared when the next frame starts. */
	109	UINT8 m_buffer_low;       /* If 1, FIFO has less than 8 bytes in it */
	110	UINT8 m_buffer_empty;     /* If 1, FIFO is empty */
	111	UINT8 m_irq_pin;          /* state of the IRQ pin (output) */
	112	UINT8 m_ready_pin;        /* state of the READY pin (output) */
204	113
205		// these contain data describing the current and previous voice frames
206		#define M_OLD_FRAME_SILENCE_FLAG m_OLDE // 1 if E=0, 0 otherwise.
207		#define M_OLD_FRAME_UNVOICED_FLAG m_OLDP // 1 if P=0 (unvoiced), 0 if voiced
208		bool    m_OLDE;
209		bool    m_OLDP;
	114	/* these contain data describing the current and previous voice frames */
	115	#define OLD_FRAME_SILENCE_FLAG m_OLDE // 1 if E=0, 0 otherwise.
	116	#define OLD_FRAME_UNVOICED_FLAG m_OLDP // 1 if P=0 (unvoiced), 0 if voiced
	117	UINT8 m_OLDE;
	118	UINT8 m_OLDP;
210	119
211		#define M_NEW_FRAME_STOP_FLAG (m_new_frame_energy_idx == 0xF)       // 1 if this is a stop (Energy = 0xF) frame
212		#define M_NEW_FRAME_SILENCE_FLAG (m_new_frame_energy_idx == 0)  // ditto as above
213		#define M_NEW_FRAME_UNVOICED_FLAG (m_new_frame_pitch_idx == 0)  // ditto as above
214		int     m_new_frame_energy_idx;
215		int     m_new_frame_pitch_idx;
216		int     m_new_frame_k_idx[10];
	120	#define NEW_FRAME_STOP_FLAG (m_new_frame_energy_idx == 0xF) // 1 if this is a stop (Energy = 0xF) frame
	121	#define NEW_FRAME_SILENCE_FLAG (m_new_frame_energy_idx == 0) // ditto as above
	122	#define NEW_FRAME_UNVOICED_FLAG (m_new_frame_pitch_idx == 0) // ditto as above
	123	UINT8 m_new_frame_energy_idx;
	124	UINT8 m_new_frame_pitch_idx;
	125	UINT8 m_new_frame_k_idx[10];
217	126
218		// these are all used to contain the current state of the sound generation
	127
	128	/* these are all used to contain the current state of the sound generation */
219	129	#ifndef PERFECT_INTERPOLATION_HACK
220		INT16   m_current_energy;
221		INT16   m_current_pitch;
222		INT16   m_current_k[10];
	130	INT16 m_current_energy;
	131	INT16 m_current_pitch;
	132	INT16 m_current_k[10];
223	133
224		INT16   m_target_energy;
225		INT16   m_target_pitch;
226		INT16   m_target_k[10];
	134	INT16 m_target_energy;
	135	INT16 m_target_pitch;
	136	INT16 m_target_k[10];
227	137	#else
228		int     m_old_frame_energy_idx;
229		int     m_old_frame_pitch_idx;
230		int     m_old_frame_k_idx[10];
	138	UINT8 m_old_frame_energy_idx;
	139	UINT8 m_old_frame_pitch_idx;
	140	UINT8 m_old_frame_k_idx[10];
231	141
232		INT32   m_current_energy;
233		INT32   m_current_pitch;
234		INT32   m_current_k[10];
	142	INT32 m_current_energy;
	143	INT32 m_current_pitch;
	144	INT32 m_current_k[10];
235	145
236		INT32   m_target_energy;
237		INT32   m_target_pitch;
238		INT32   m_target_k[10];
	146	INT32 m_target_energy;
	147	INT32 m_target_pitch;
	148	INT32 m_target_k[10];
239	149	#endif
240	150
241		UINT16  m_previous_energy;  // needed for lattice filter to match patent
242		int     m_subcycle;         // contains the current subcycle for a given PC: 0 is A' (only used on SPKSLOW mode on 51xx), 1 is A, 2 is B
243		int     m_subc_reload;      // contains 1 for normal speech, 0 when SPKSLOW is active
244		int     m_PC;               // current parameter counter (what param is being interpolated), ranges from 0 to 12
	151	UINT16 m_previous_energy; /* needed for lattice filter to match patent */
245	152
246		// TODO/NOTE: the current interpolation period, counts 1,2,3,4,5,6,7,0 for divide by 8,8,8,4,4,2,2,1
247		int     m_IP;    // the current interpolation period
248		bool    m_inhibit;          // If 1, interpolation is inhibited until the DIV1 period
249		UINT8   m_tms5220c_rate;    // only relevant for tms5220C's multi frame rate feature; is the actual 4 bit value written on a 0x2* or 0x0* command
250		UINT16  m_pitch_count;      // pitch counter; provides chirp rom address
	153	UINT8 m_subcycle;         /* contains the current subcycle for a given PC: 0 is A' (only used on SPKSLOW mode on 51xx), 1 is A, 2 is B */
	154	UINT8 m_subc_reload;      /* contains 1 for normal speech, 0 when SPKSLOW is active */
	155	UINT8 m_PC;               /* current parameter counter (what param is being interpolated), ranges from 0 to 12 */
	156	/* TODO/NOTE: the current interpolation period, counts 1,2,3,4,5,6,7,0 for divide by 8,8,8,4,4,2,2,1 */
	157	UINT8 m_IP;               /* the current interpolation period */
	158	UINT8 m_inhibit;          /* If 1, interpolation is inhibited until the DIV1 period */
	159	UINT8 m_tms5220c_rate;    /* only relevant for tms5220C's multi frame rate feature; is the actual 4 bit value written on a 0x2* or 0x0* command */
	160	UINT16 m_pitch_count;     /* pitch counter; provides chirp rom address */
251	161
252		INT32   m_u[11];
253		INT32   m_x[10];
	162	INT32 m_u[11];
	163	INT32 m_x[10];
254	164
255		UINT16  m_RNG;      // the random noise generator configuration is: 1 + x + x^3 + x^4 + x^13
256		INT16   m_excitation_data;
	165	UINT16 m_RNG;             /* the random noise generator configuration is: 1 + x + x^3 + x^4 + x^13 */
	166	INT16 m_excitation_data;
257	167
258		// R Nabet : These have been added to emulate speech Roms
259		bool    m_schedule_dummy_read;  // set after each load address, so that next read operation is preceded by a dummy read
260		UINT8   m_data_register;        // data register, used by read command
261		bool    m_RDB_flag;             // whether we should read data register or status register
	168	/* R Nabet : These have been added to emulate speech Roms */
	169	UINT8 m_schedule_dummy_read;          /* set after each load address, so that next read operation is preceded by a dummy read */
	170	UINT8 m_data_register;                /* data register, used by read command */
	171	UINT8 m_RDB_flag;                 /* whether we should read data register or status register */
262	172
263		// io_ready: page 3 of the datasheet specifies that READY will be asserted until
264		// data is available or processed by the system.
265		int     m_io_ready;
	173	/* io_ready: page 3 of the datasheet specifies that READY will be asserted until
	174	* data is available or processed by the system.
	175	*/
	176	UINT8 m_io_ready;
266	177
267		// flag for "true" timing involving rs/ws
268		bool    m_true_timing;
	178	/* flag for "true" timing involving rs/ws */
	179	UINT8 m_true_timing;
269	180
270		// rsws - state, rs bit 1, ws bit 0
271		int     m_rs_ws;
272		UINT8   m_read_latch;
273		UINT8   m_write_latch;
	181	/* rsws - state, rs bit 1, ws bit 0 */
	182	UINT8 m_rs_ws;
	183	UINT8 m_read_latch;
	184	UINT8 m_write_latch;
274	185
275		// The TMS52xx has two different ways of providing output data: the
276		// analog speaker pin (which was usually used) and the Digital I/O pin.
277		// The internal DAC used to feed the analog pin is only 8 bits, and has the
278		// funny clipping/clamping logic, while the digital pin gives full 12? bit
279		// resolution of the output data.
280		// TODO: add a way to set/reset this other than the FORCE_DIGITAL define
281		bool            m_digital_select;
	186	/* The TMS52xx has two different ways of providing output data: the
	187	analog speaker pin (which was usually used) and the Digital I/O pin.
	188	The internal DAC used to feed the analog pin is only 8 bits, and has the
	189	funny clipping/clamping logic, while the digital pin gives full 10 bit
	190	resolution of the output data.
	191	TODO: add a way to set/reset this other than the FORCE_DIGITAL define
	192	*/
	193	UINT8 m_digital_select;
282	194
283		sound_stream    *m_stream;
	195	sound_stream *m_stream;
	196	int m_clock;
	197	emu_timer *m_timer_io_ready;
284	198
285		emu_timer       *m_ready_timer;
	199	/* callbacks */
	200	devcb2_write_line m_irq_handler;
	201	devcb2_write_line m_readyq_handler;
	202	const char *m_speechrom_tag;
	203	speechrom_device *m_speechrom;
286	204	};
287	205
288		class tms5220n_device : public tms52xx_device
289		{
290		public:
291		tms5220n_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
292		};
	206	extern const device_type TMS5220;
293	207
294		class tms5220cn_device : public tms52xx_device
	208	class tms5220c_device : public tms5220_device
295	209	{
296	210	public:
297		tms5220cn_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
	211	tms5220c_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
	212	protected:
	213	// device-level overrides
	214	virtual void device_start();
298	215	};
299	216
300		class tmc0285n_device : public tms52xx_device
	217	extern const device_type TMS5220C;
	218
	219	class tmc0285_device : public tms5220_device
301	220	{
302	221	public:
303		tmc0285n_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
	222	tmc0285_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
	223	protected:
	224	// device-level overrides
	225	virtual void device_start();
304	226	};
305	227
306		class tms5200n_device : public tms52xx_device
	228	extern const device_type TMC0285;
	229
	230	class tms5200_device : public tms5220_device
307	231	{
308	232	public:
309		tms5200n_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
	233	tms5200_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
	234	protected:
	235	// device-level overrides
	236	virtual void device_start();
310	237	};
311	238
	239	extern const device_type TMS5200;
312	240
313		#endif /* __TMS5220_H__ */
	241	#endif

trunk/src/mess/drivers/exelv.c

r22818	r22819
54	54	#include "cpu/tms7000/tms7000.h"
55	55	#include "video/tms3556.h"
56	56	#include "sound/tms5220.h"
57		#include "audio/spchroms.h"
	57	#include "machine/spchrom.h"
58	58	//#include "imagedev/cartslot.h"
59	59	//#include "imagedev/cassette.h"
60	60
r22818	r22819
74	74	required_device<tms5220c_device> m_tms5220c;
75	75
76	76	virtual void machine_start();
77		virtual void machine_reset();
78	77
79	78	DECLARE_READ8_MEMBER( mailbox_wx319_r );
80	79	DECLARE_WRITE8_MEMBER( mailbox_wx318_w );
r22818	r22819
281	280	logerror("tms7041_porta_r\n");
282	281
283	282	data |= (m_tms7020_portb & 0x01 ) ? 0x04 : 0x00;
284		data |= tms5220_intq_r(m_tms5220c) ? 0x08 : 0x00;
	283	data |= m_tms5220c->intq_r() ? 0x08 : 0x00;
285	284	data |= (m_tms7020_portb & 0x02) ? 0x10 : 0x00;
286		data |= tms5220_readyq_r(m_tms5220c) ? 0x80 : 0x00;
	285	data |= m_tms5220c->readyq_r() ? 0x80 : 0x00;
287	286
288	287	return data;
289	288	}
r22818	r22819
319	318	{
320	319	logerror("tms7041_portb_w: data = 0x%02x\n", data);
321	320
322		tms5220_wsq_w(m_tms5220c, (data & 0x01) ? 1 : 0);
323		tms5220_rsq_w(m_tms5220c, (data & 0x02) ? 1 : 0);
	321	m_tms5220c->wsq_w((data & 0x01) ? 1 : 0);
	322	m_tms5220c->rsq_w((data & 0x02) ? 1 : 0);
324	323
325	324	m_maincpu->set_input_line(TMS7000_IRQ1_LINE, (data & 0x04) ? CLEAR_LINE : ASSERT_LINE);
326	325
r22818	r22819
381	380	{
382	381	logerror("tms7041_portd_w: data = 0x%02x\n", data);
383	382
384		tms5220_data_w(m_tms5220c, space, 0, BITSWAP8(data,0,1,2,3,4,5,6,7));
	383	m_tms5220c->data_w(space, 0, BITSWAP8(data,0,1,2,3,4,5,6,7));
385	384	m_tms7041_portd = data;
386	385	}
387	386
r22818	r22819
475	474	INPUT_PORTS_END
476	475
477	476
478		static const tms5220_interface exl100_tms5220_interface =
479		{
480		DEVCB_NULL,                     /* no IRQ callback */
481		DEVCB_NULL,                     /* no Ready callback */
482		spchroms_read,                  /* speech ROM read handler */
483		spchroms_load_address,          /* speech ROM load address handler */
484		spchroms_read_and_branch        /* speech ROM read and branch handler */
485		};
486
487
488	477	void exelv_state::palette_init()
489	478	{
490	479	int i, red, green, blue;
r22818	r22819
519	508	save_item(NAME(m_wx319));
520	509	}
521	510
522		void exelv_state::machine_reset()
523		{
524		static const spchroms_interface exelv_speech_intf = {"tms5220c"};
525		spchroms_config(machine(), &exelv_speech_intf);
526		}
527
528	511	static MACHINE_CONFIG_START( exl100, exelv_state )
529	512	/* basic machine hardware */
530	513	MCFG_CPU_ADD("maincpu", TMS7000_EXL, XTAL_4_9152MHz)    /* TMS7020 */
r22818	r22819
557	540	MCFG_SCREEN_REFRESH_RATE(50)
558	541	MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500)) /* not accurate */
559	542
	543	MCFG_DEVICE_ADD("vsm", SPEECHROM, 0)
	544
560	545	/* sound */
561	546	MCFG_SPEAKER_STANDARD_MONO("mono")
562	547	MCFG_SOUND_ADD("tms5220c", TMS5220C, 640000)
563		MCFG_SOUND_CONFIG(exl100_tms5220_interface)
	548	MCFG_TMS52XX_SPEECHROM("vsm")
564	549	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00)
565	550	MACHINE_CONFIG_END
566	551
r22818	r22819
597	582	MCFG_SCREEN_REFRESH_RATE(50)
598	583	MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500)) /* not accurate */
599	584
	585	MCFG_DEVICE_ADD("vsm", SPEECHROM, 0)
	586
600	587	/* sound */
601	588	MCFG_SPEAKER_STANDARD_MONO("mono")
602	589	MCFG_SOUND_ADD("tms5220c", TMS5220C, 640000)
603		MCFG_SOUND_CONFIG(exl100_tms5220_interface)
	590	MCFG_TMS52XX_SPEECHROM("vsm")
604	591	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.00)
605	592	MACHINE_CONFIG_END
606	593
r22818	r22819
618	605	ROM_REGION(0x10000, "user1", ROMREGION_ERASEFF)         /* cartridge area */
619	606
620	607	/* is this correct for exl100? */
621		ROM_REGION(0x8000, "tms5220c", 0)
	608	ROM_REGION(0x8000, "vsm", 0)
622	609	ROM_LOAD("cm62312.bin", 0x0000, 0x4000, CRC(93b817de) SHA1(03863087a071b8f22d36a52d18243f1c33e17ff7)) /* system speech ROM */
623	610	ROM_END
624	611
r22818	r22819
636	623	ROM_SYSTEM_BIOS( 1, "spanish", "Spanish" )
637	624	ROMX_LOAD("amper.bin", 0x0000, 0x10000, CRC(45af256c) SHA1(3bff16542f8ac55b9841084ea38034132459facb), ROM_BIOS(2)) /* Spanish system rom */
638	625
639		ROM_REGION(0x8000, "tms5220c", 0)
	626	ROM_REGION(0x8000, "vsm", 0)
640	627	ROM_LOAD("cm62312.bin", 0x0000, 0x4000, CRC(93b817de) SHA1(03863087a071b8f22d36a52d18243f1c33e17ff7)) /* system speech ROM */
641	628	ROM_END
642	629

trunk/src/mess/drivers/mpf1.c

r22818	r22819
64	64	AM_RANGE(0x00, 0x03) AM_MIRROR(0x3c) AM_DEVREADWRITE(I8255A_TAG, i8255_device, read, write)
65	65	AM_RANGE(0x40, 0x43) AM_MIRROR(0x3c) AM_DEVREADWRITE(Z80CTC_TAG, z80ctc_device, read, write)
66	66	AM_RANGE(0x80, 0x83) AM_MIRROR(0x3c) AM_DEVREADWRITE(Z80PIO_TAG, z80pio_device, read, write)
67		AM_RANGE(0xfe, 0xfe) AM_MIRROR(0x01) AM_DEVREADWRITE_LEGACY(TMS5220_TAG, tms5220_status_r, tms5220_data_w)
	67	AM_RANGE(0xfe, 0xfe) AM_MIRROR(0x01) AM_DEVREADWRITE(TMS5220_TAG, tms5220_device, status_r, data_w)
68	68	ADDRESS_MAP_END
69	69
70	70	static ADDRESS_MAP_START( mpf1p_io_map, AS_IO, 8, mpf1_state )
r22818	r22819
317	317	NULL
318	318	};
319	319
320		/* TMS5220 Interface */
321
322		static const tms5220_interface mpf1_tms5220_intf =
323		{
324		DEVCB_NULL,                 /* no IRQ callback */
325		DEVCB_NULL,                 /* no Ready callback */
326		#if 1
327		spchroms_read,              /* speech ROM read handler */
328		spchroms_load_address,      /* speech ROM load address handler */
329		spchroms_read_and_branch    /* speech ROM read and branch handler */
330		#endif
331		};
332
333	320	/* Machine Initialization */
334	321
335	322	TIMER_DEVICE_CALLBACK_MEMBER(mpf1_state::check_halt_callback)
r22818	r22819
404	391	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.25)
405	392
406	393	MCFG_SOUND_ADD(TMS5220_TAG, TMS5220, 680000L)
407		MCFG_SOUND_CONFIG(mpf1_tms5220_intf)
408	394	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
409	395
410	396	MCFG_TIMER_DRIVER_ADD_PERIODIC("halt_timer", mpf1_state, check_halt_callback, attotime::from_hz(1))

trunk/src/mess/drivers/pes.c

r22818	r22819
126	126	#ifdef DEBUG_PORTS
127	127	logerror("port0 write: RSWS states updated: /RS: %d, /WS: %d\n", m_rsstate, m_wsstate);
128	128	#endif
129		tms5220_rsq_w(state->m_speech, m_rsstate);
130		tms5220_wsq_w(state->m_speech, m_wsstate);
	129	state->m_speech->rsq_w(m_rsstate);
	130	state->m_speech->wsq_w(m_wsstate);
131	131	}
132	132
133	133	WRITE8_MEMBER( pes_state::port1_w )
r22818	r22819
136	136	#ifdef DEBUG_PORTS
137	137	logerror("port1 write: tms5220 data written: %02X\n", data);
138	138	#endif
139		tms5220_data_w(state->m_speech, space, 0, data);
	139	state->m_speech->data_w(space, 0, data);
140	140
141	141	}
142	142
r22818	r22819
144	144	{
145	145	UINT8 data = 0xFF;
146	146	pes_state *state = machine().driver_data<pes_state>();
147		data = tms5220_status_r(state->m_speech, space, 0);
	147	data = state->m_speech->status_r(space, 0);
148	148	#ifdef DEBUG_PORTS
149	149	logerror("port1 read: tms5220 data read: 0x%02X\n", data);
150	150	#endif
r22818	r22819
186	186	{
187	187	data |= 0x10; // set RTS bit
188	188	}
189		data |= (tms5220_intq_r(state->m_speech)<<2);
190		data |= (tms5220_readyq_r(state->m_speech)<<3);
	189	data |= (state->m_speech->intq_r()<<2);
	190	data |= (state->m_speech->readyq_r()<<3);
191	191	#ifdef DEBUG_PORTS
192	192	logerror("port3 read: returning 0x%02X: ", data);
193	193	logerror("RXD: %d; ", BIT(data,0));

trunk/src/mess/mess.mak

r22818	r22819
509	509
510	510	$(MESSOBJ)/shared.a: \
511	511	$(MESS_AUDIO)/mea8000.o     \
512		$(MESS_AUDIO)/spchroms.o    \
513	512	$(MESS_MACHINE)/3c503.o     \
514	513	$(MESS_MACHINE)/68561mpcc.o \
515	514	$(MESS_MACHINE)/8530scc.o   \

trunk/src/mess/audio/spchroms.c

r22818	r22819
1		/*
2		spchroms.c - This is an emulator for "typical" speech ROMs from TI, as used by TI99/4(a).
3
4		In order to support its speech processor, TI designed some ROMs with a 1-bit data bus
5		and 4-bit address bus (multiplexed 5 times to provide a 18-bit address).
6		A fairly complete description of such a ROM (tms6100) is found in the tms5220 datasheet.
7
8		One notable thing is that the address is a byte address (*NOT* a bit address).
9
10		This file is designed to be interfaced with the tms5220 core.
11		Interfacing it with the tms5110 would make sense, too.
12		*/
13
14		#include "emu.h"
15		#include "spchroms.h"
16
17		static UINT8 *speechrom_data = NULL;    /* pointer to speech ROM data */
18		static unsigned long speechROMlen = 0;  /* length of data pointed by speechrom_data, from 0 to 2^18 */
19		static unsigned long speechROMaddr;     /* 18 bit pointer in ROM */
20		#define TMS5220_ADDRESS_MASK 0x3FFFFUL  /* 18-bit mask for tms5220 address */
21		static int load_pointer = 0;            /* which 4-bit nibble will be affected by load address */
22		static int ROM_bits_count;              /* current bit position in ROM */
23
24		/*
25		set the speech ROMs
26		*/
27		void spchroms_config(running_machine &machine, const spchroms_interface *intf)
28		{
29		if (intf->memory_region == NULL)
30		{   /* no speech ROM */
31		speechrom_data = NULL;
32		speechROMlen = 0;
33		}
34		else
35		{   /* speech ROM */
36		speechrom_data = machine.root_device().memregion(intf->memory_region)->base();
37		/* take region length */
38		speechROMlen = machine.root_device().memregion(intf->memory_region)->bytes();
39		}
40		}
41
42		/*
43		Read 'count' bits serially from speech ROM
44		*/
45		int spchroms_read(device_t *device, int count)
46		{
47		int val;
48
49		if (load_pointer)
50		{   /* first read after load address is ignored */
51		load_pointer = 0;
52		count--;
53		}
54
55		if (speechROMaddr < speechROMlen)
56		if (count < ROM_bits_count)
57		{
58		ROM_bits_count -= count;
59		val = (speechrom_data[speechROMaddr] >> ROM_bits_count) & (0xFF >> (8 - count));
60		}
61		else
62		{
63		val = ((int) speechrom_data[speechROMaddr]) << 8;
64
65		speechROMaddr = (speechROMaddr + 1) & TMS5220_ADDRESS_MASK;
66
67		if (speechROMaddr < speechROMlen)
68		val |= speechrom_data[speechROMaddr];
69
70		ROM_bits_count += 8 - count;
71
72		val = (val >> ROM_bits_count) & (0xFF >> (8 - count));
73		}
74		else
75		val = 0;
76
77		return val;
78		}
79
80		/*
81		Write an address nibble to speech ROM
82		*/
83		void spchroms_load_address(device_t *device, int data)
84		{
85		/* tms5220 data sheet says that if we load only one 4-bit nibble, it won't work.
86		This code does not care about this. */
87		speechROMaddr = ( (speechROMaddr & ~(0xf << load_pointer))
88		| (((unsigned long) (data & 0xf)) << load_pointer) ) & TMS5220_ADDRESS_MASK;
89		load_pointer += 4;
90		ROM_bits_count = 8;
91		}
92
93		/*
94		Perform a read and branch command
95		*/
96		void spchroms_read_and_branch(device_t *device)
97		{
98		/* tms5220 data sheet says that if more than one speech ROM (tms6100) is present,
99		there is a bus contention.  This code does not care about this. */
100		if (speechROMaddr < speechROMlen-1)
101		speechROMaddr = (speechROMaddr & 0x3c000UL)
102		| (((((unsigned long) speechrom_data[speechROMaddr]) << 8)
103		| speechrom_data[speechROMaddr+1]) & 0x3fffUL);
104		else if (speechROMaddr == speechROMlen-1)
105		speechROMaddr = (speechROMaddr & 0x3c000UL)
106		| ((((unsigned long) speechrom_data[speechROMaddr]) << 8) & 0x3fffUL);
107		else
108		speechROMaddr = (speechROMaddr & 0x3c000UL);
109
110		ROM_bits_count = 8;
111		}

trunk/src/mess/audio/spchroms.h

r22818	r22819
1		#ifndef __SPCHROMS_H
2		#define __SPCHROMS_H
3
4		struct spchroms_interface
5		{
6		const char *memory_region;          /* memory region where the speech ROM is.  NULL means no speech ROM */
7		};
8
9		void spchroms_config(running_machine &machine, const spchroms_interface *intf);
10
11		int spchroms_read(device_t *device, int count);
12		void spchroms_load_address(device_t *device, int data);
13		void spchroms_read_and_branch(device_t *device);
14
15		#endif

trunk/src/mess/machine/a2mockingboard.c

r22818	r22819
545	545	switch (offset)
546	546	{
547	547	case 0:
548		return 0x1f | tms5220_status_r(m_tms, space, 0);
	548	return 0x1f | m_tms->status_r(space, 0);
549	549	}
550	550
551	551	return 0;
r22818	r22819
556	556	switch (offset)
557	557	{
558	558	case 0:
559		tms5220_data_w(m_tms, space, offset, data);
	559	m_tms->data_w(space, offset, data);
560	560	break;
561	561	}
562	562	}

trunk/src/mess/machine/a2echoii.c

r22818	r22819
79	79	switch (offset)
80	80	{
81	81	case 0:
82		return 0x1f | tms5220_status_r(m_tms, space, 0);
	82	return 0x1f | m_tms->status_r(space, 0);
83	83	}
84	84
85	85	return 0;
r22818	r22819
90	90	switch (offset)
91	91	{
92	92	case 0:
93		tms5220_data_w(m_tms, space, offset, data);
	93	m_tms->data_w(space, offset, data);
94	94	break;
95	95	}
96	96	}

trunk/src/mess/machine/ti99/spchsyn.c

r22818	r22819
20	20
21	21	#include "spchsyn.h"
22	22	#include "sound/wave.h"
	23	#include "machine/spchrom.h"
23	24
24	25	#define TMS5220_ADDRESS_MASK 0x3FFFFUL  /* 18-bit mask for tms5220 address */
25	26
26	27	#define VERBOSE 1
27	28	#define LOG logerror
28	29
29		#define SPEECHROM_TAG "speechrom"
30
31	30	#define REAL_TIMING 0
32	31
33	32	/****************************************************************************/
r22818	r22819
108	107	if ((offset & m_select_mask)==m_select_value)
109	108	{
110	109	machine().device("maincpu")->execute().adjust_icount(-(18+3));      /* this is just a minimum, it can be more */
111		*value = m_vsp->read(space, offset, 0xff) & 0xff;
	110	*value = m_vsp->status_r(space, offset, 0xff) & 0xff;
112	111	if (VERBOSE>4) LOG("spchsyn: read value = %02x\n", *value);
113	112	}
114	113	}
r22818	r22819
126	125	/* when there are 15 bytes in FIFO.  It should be 16.  Of course, if */
127	126	/* it were the case, we would need to store the value on the bus, */
128	127	/* which would be more complex. */
129		if (!m_vsp->readyq())
	128	if (!m_vsp->readyq_r())
130	129	{
131	130	attotime time_to_ready = attotime::from_double(m_vsp->time_to_ready());
132	131	int cycles_to_ready = machine().device<cpu_device>("maincpu")->attotime_to_cycles(time_to_ready);
r22818	r22819
136	135	machine().scheduler().timer_set(attotime::zero, FUNC_NULL);
137	136	}
138	137	if (VERBOSE>4) LOG("spchsyn: write value = %02x\n", data);
139		m_vsp->write(space, offset, data);
	138	m_vsp->data_w(space, offset, data);
140	139	}
141	140	}
142	141	#endif
143	142
144		/****************************************************************************
145		Callbacks from TMS5220
146		*****************************************************************************/
147		/*
148		Read 'count' bits serially from speech ROM. The offset is used as the count.
149		*/
150		READ8_MEMBER( ti_speech_synthesizer_device::spchrom_read )
151		{
152		int val;
153		int count = offset;
154
155		if (m_load_pointer != 0)
156		{   // first read after load address is ignored
157		m_load_pointer = 0;
158		count--;
159		}
160
161		if (m_sprom_address < m_sprom_length)
162		{
163		if (count < m_rombits_count)
164		{
165		m_rombits_count -= count;
166		val = (m_speechrom[m_sprom_address] >> m_rombits_count) & (0xFF >> (8 - count));
167		}
168		else
169		{
170		val = ((int)m_speechrom[m_sprom_address]) << 8;
171
172		m_sprom_address = (m_sprom_address + 1) & TMS5220_ADDRESS_MASK;
173
174		if (m_sprom_address < m_sprom_length)
175		val |= m_speechrom[m_sprom_address];
176
177		m_rombits_count += 8 - count;
178
179		val = (val >> m_rombits_count) & (0xFF >> (8 - count));
180		}
181		}
182		else
183		val = 0;
184
185		return val;
186		}
187
188		/*
189		Write an address nibble to speech ROM. The address nibble is in the data,
190		the offset is ignored.
191		*/
192		WRITE8_MEMBER( ti_speech_synthesizer_device::spchrom_load_address )
193		{
194		// tms5220 data sheet says that if we load only one 4-bit nibble, it won't work.
195		// This code does not care about this.
196		m_sprom_address = ((m_sprom_address & ~(0xf << m_load_pointer))
197		| (((unsigned long) (data & 0xf)) << m_load_pointer) ) & TMS5220_ADDRESS_MASK;
198		m_load_pointer += 4;
199		m_rombits_count = 8;
200		}
201
202		/*
203		Perform a read and branch command. We do not use the offset or data parameter.
204		*/
205		WRITE8_MEMBER( ti_speech_synthesizer_device::spchrom_read_and_branch )
206		{
207		// tms5220 data sheet says that if more than one speech ROM (tms6100) is present,
208		// there is a bus contention.  This code does not care about this. */
209		if (m_sprom_address < m_sprom_length-1)
210		m_sprom_address = (m_sprom_address & 0x3c000UL)
211		| (((((unsigned long) m_speechrom[m_sprom_address]) << 8)
212		| m_speechrom[m_sprom_address+1]) & 0x3fffUL);
213		else if (m_sprom_address == m_sprom_length-1)
214		m_sprom_address = (m_sprom_address & 0x3c000UL)
215		| ((((unsigned long) m_speechrom[m_sprom_address]) << 8) & 0x3fffUL);
216		else
217		m_sprom_address = (m_sprom_address & 0x3c000UL);
218
219		m_rombits_count = 8;
220		}
221
222	143	/****************************************************************************/
223	144
224		/*
225		Callback interface instance
226		*/
227		static const tms52xx_config ti99_4x_tms5200interface =
228		{
229		DEVCB_NULL,                     // no IRQ callback
230		DEVCB_DEVICE_LINE_MEMBER(DEVICE_SELF_OWNER, ti_speech_synthesizer_device, speech_ready),
231
232		DEVCB_DEVICE_MEMBER(DEVICE_SELF_OWNER, ti_speech_synthesizer_device, spchrom_read),             // speech ROM read handler
233		DEVCB_DEVICE_MEMBER(DEVICE_SELF_OWNER, ti_speech_synthesizer_device, spchrom_load_address),     // speech ROM load address handler
234		DEVCB_DEVICE_MEMBER(DEVICE_SELF_OWNER, ti_speech_synthesizer_device, spchrom_read_and_branch)   // speech ROM read and branch handler
235		};
236
237		/****************************************************************************/
238
239	145	WRITE_LINE_MEMBER( ti_speech_synthesizer_device::speech_ready )
240	146	{
241	147	// The TMS5200 implementation uses TRUE/FALSE, not ASSERT/CLEAR semantics
r22818	r22819
260	166
261	167	void ti_speech_synthesizer_device::device_config_complete()
262	168	{
263		m_vsp = subdevice<tmc0285n_device>("speechsyn");
	169	m_vsp = subdevice<tmc0285_device>("speechsyn");
264	170	}
265	171
266	172	void ti_speech_synthesizer_device::device_reset()
267	173	{
268		m_speechrom = memregion(SPEECHROM_TAG)->base();
269		m_sprom_length = memregion(SPEECHROM_TAG)->bytes();
270		m_sprom_address = 0;
271		m_load_pointer = 0;
272		m_rombits_count = 0;
273
274	174	if (m_genmod)
275	175	{
276	176	m_select_mask = 0x1ffc01;
r22818	r22819
284	184	}
285	185
286	186	MACHINE_CONFIG_FRAGMENT( ti99_speech )
	187	MCFG_DEVICE_ADD("vsm", SPEECHROM, 0)
	188
287	189	MCFG_SPEAKER_STANDARD_MONO("mono")
288		MCFG_SOUND_ADD("speechsyn", TMC0285N, 640000L)
289		MCFG_SOUND_CONFIG(ti99_4x_tms5200interface)
	190	MCFG_SOUND_ADD("speechsyn", TMC0285, 640000L)
	191	MCFG_TMS52XX_READYQ_HANDLER(DEVWRITELINE(DEVICE_SELF_OWNER, ti_speech_synthesizer_device, speech_ready))
	192	MCFG_TMS52XX_SPEECHROM("vsm")
290	193	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
291	194	MACHINE_CONFIG_END
292	195
293	196	ROM_START( ti99_speech )
294		ROM_REGION(0x8000, SPEECHROM_TAG, 0)
	197	ROM_REGION(0x8000, "vsm", 0)
295	198	ROM_LOAD_OPTIONAL("spchrom.bin", 0x0000, 0x8000, CRC(58b155f7) SHA1(382292295c00dff348d7e17c5ce4da12a1d87763)) /* system speech ROM */
296	199	ROM_END
297	200

trunk/src/mess/machine/ti99/spchsyn.h

r22818	r22819
41	41	virtual void            device_config_complete();
42	42
43	43	private:
44		tmc0285n_device *m_vsp;
45
46		UINT8           *m_speechrom;           // pointer to speech ROM data
47		int             m_load_pointer;         // which 4-bit nibble will be affected by load address
48		int             m_rombits_count;        // current bit position in ROM
49		UINT32          m_sprom_address;        // 18 bit pointer in ROM
50		UINT32          m_sprom_length;         // length of data pointed by speechrom_data, from 0 to 2^18
	44	tmc0285_device *m_vsp;
51	45	};
52	46
53	47	#endif

trunk/src/mess/machine/ti99/speech8.c

r22818	r22819
13	13
14	14	#include "speech8.h"
15	15	#include "sound/wave.h"
	16	#include "machine/spchrom.h"
16	17
17	18	#define TMS5220_ADDRESS_MASK 0x3FFFFUL  /* 18-bit mask for tms5220 address */
18	19
r22818	r22819
20	21	#define LOG logerror
21	22
22	23	#define SPEECHSYN_TAG "speechsyn"
23		#define SPEECHROM_TAG "speechrom"
24	24
25	25	#define REAL_TIMING 0
26	26
r22818	r22819
31	31
32	32	ti998_spsyn_device::ti998_spsyn_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
33	33	: bus8z_device(mconfig, TI99_SPEECH8, "TI-99/8 Speech synthesizer (onboard)", tag, owner, clock, "ti99_speech8", __FILE__)
34		, m_load_pointer(0)
35	34	{
36	35	}
37	36
r22818	r22819
73	72	if ((offset & m_select_mask)==m_select_value)
74	73	{
75	74	machine().device("maincpu")->execute().adjust_icount(-(18+3));      /* this is just a minimum, it can be more */
76		*value = m_vsp->read(space, offset, 0xff) & 0xff;
	75	*value = m_vsp->status_r(space, offset, 0xff) & 0xff;
77	76	if (VERBOSE>4) LOG("speech8: read value = %02x\n", *value);
78	77	}
79	78	}
r22818	r22819
91	90	/* when there are 15 bytes in FIFO.  It should be 16.  Of course, if */
92	91	/* it were the case, we would need to store the value on the bus, */
93	92	/* which would be more complex. */
94		if (!m_vsp->readyq())
	93	if (!m_vsp->readyq_r())
95	94	{
96	95	attotime time_to_ready = attotime::from_double(m_vsp->time_to_ready());
97	96	int cycles_to_ready = machine().device<cpu_device>("maincpu")->attotime_to_cycles(time_to_ready);
r22818	r22819
101	100	machine().scheduler().timer_set(attotime::zero, FUNC_NULL);
102	101	}
103	102	if (VERBOSE>4) LOG("speech8: write value = %02x\n", data);
104		m_vsp->write(space, offset, data);
	103	m_vsp->data_w(space, offset, data);
105	104	}
106	105	}
107	106	#endif
108	107
109		/****************************************************************************
110		Callbacks from TMS5220
111		*****************************************************************************/
112		/*
113		Read 'count' bits serially from speech ROM
114		*/
115		READ8_MEMBER( ti998_spsyn_device::spchrom_read )
116		{
117		int val;
118		int count = offset;
119
120		if (m_load_pointer != 0)
121		{   // first read after load address is ignored
122		m_load_pointer = 0;
123		count--;
124		}
125
126		if (m_sprom_address < m_sprom_length)
127		{
128		if (count < m_rombits_count)
129		{
130		m_rombits_count -= count;
131		val = (m_speechrom[m_sprom_address] >> m_rombits_count) & (0xFF >> (8 - count));
132		}
133		else
134		{
135		val = ((int)m_speechrom[m_sprom_address]) << 8;
136
137		m_sprom_address = (m_sprom_address + 1) & TMS5220_ADDRESS_MASK;
138
139		if (m_sprom_address < m_sprom_length)
140		val |= m_speechrom[m_sprom_address];
141
142		m_rombits_count += 8 - count;
143
144		val = (val >> m_rombits_count) & (0xFF >> (8 - count));
145		}
146		}
147		else
148		val = 0;
149
150		return val;
151		}
152
153		/*
154		Write an address nibble to speech ROM
155		*/
156		WRITE8_MEMBER( ti998_spsyn_device::spchrom_load_address )
157		{
158		// tms5220 data sheet says that if we load only one 4-bit nibble, it won't work.
159		// This code does not care about this.
160		m_sprom_address = ((m_sprom_address & ~(0xf << m_load_pointer))
161		| (((unsigned long) (data & 0xf)) << m_load_pointer) ) & TMS5220_ADDRESS_MASK;
162		m_load_pointer += 4;
163		m_rombits_count = 8;
164		}
165
166		/*
167		Perform a read and branch command
168		*/
169		WRITE8_MEMBER( ti998_spsyn_device::spchrom_read_and_branch )
170		{
171		// tms5220 data sheet says that if more than one speech ROM (tms6100) is present,
172		// there is a bus contention.  This code does not care about this. */
173		if (m_sprom_address < m_sprom_length-1)
174		m_sprom_address = (m_sprom_address & 0x3c000UL)
175		| (((((unsigned long) m_speechrom[m_sprom_address]) << 8)
176		| m_speechrom[m_sprom_address+1]) & 0x3fffUL);
177		else if (m_sprom_address == m_sprom_length-1)
178		m_sprom_address = (m_sprom_address & 0x3c000UL)
179		| ((((unsigned long) m_speechrom[m_sprom_address]) << 8) & 0x3fffUL);
180		else
181		m_sprom_address = (m_sprom_address & 0x3c000UL);
182
183		m_rombits_count = 8;
184		}
185
186		/*****************************************************************************/
187		/*
188		Callback interface instance
189		*/
190		static const tms52xx_config ti99_8_tms5200interface =
191		{
192		DEVCB_NULL,                     // no IRQ callback
193		DEVCB_DEVICE_LINE_MEMBER(DEVICE_SELF_OWNER, ti998_spsyn_device, speech8_ready),
194
195		DEVCB_DEVICE_MEMBER(DEVICE_SELF_OWNER, ti998_spsyn_device, spchrom_read),               // speech ROM read handler
196		DEVCB_DEVICE_MEMBER(DEVICE_SELF_OWNER, ti998_spsyn_device, spchrom_load_address),       // speech ROM load address handler
197		DEVCB_DEVICE_MEMBER(DEVICE_SELF_OWNER, ti998_spsyn_device, spchrom_read_and_branch) // speech ROM read and branch handler
198		};
199
200	108	/**************************************************************************/
201	109
202	110	WRITE_LINE_MEMBER( ti998_spsyn_device::speech8_ready )
r22818	r22819
219	127	{
220	128	const speech8_config *conf = reinterpret_cast<const speech8_config *>(static_config());
221	129	m_ready.resolve(conf->ready, *this);
222		m_vsp = subdevice<tms5220n_device>(SPEECHSYN_TAG);
	130	m_vsp = subdevice<tms5220_device>(SPEECHSYN_TAG);
223	131	}
224	132
225	133	void ti998_spsyn_device::device_reset()
226	134	{
227		m_speechrom = memregion(SPEECHROM_TAG)->base();
228		m_sprom_length = memregion(SPEECHROM_TAG)->bytes();
229		m_sprom_address = 0;
230		m_load_pointer = 0;
231		m_rombits_count = 0;
232
233	135	m_select_mask = 0xfc01;
234	136	m_select_value = 0x9000;
235	137	if (VERBOSE>4) LOG("speech8: reset\n");
r22818	r22819
237	139
238	140	// Unlike the TI-99/4A, the 99/8 uses the TMS5220
239	141	MACHINE_CONFIG_FRAGMENT( ti998_speech )
	142	MCFG_DEVICE_ADD("vsm", SPEECHROM, 0)
	143
240	144	MCFG_SPEAKER_STANDARD_MONO("mono")
241		MCFG_SOUND_ADD(SPEECHSYN_TAG, TMS5220N, 640000L)
242		MCFG_SOUND_CONFIG(ti99_8_tms5200interface)
	145	MCFG_SOUND_ADD(SPEECHSYN_TAG, TMS5220, 640000L)
	146	MCFG_TMS52XX_READYQ_HANDLER(DEVWRITELINE(DEVICE_SELF_OWNER, ti998_spsyn_device, speech8_ready))
	147	MCFG_TMS52XX_SPEECHROM("vsm")
243	148	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
244	149	MACHINE_CONFIG_END
245	150
246	151	ROM_START( ti998_speech )
247		ROM_REGION(0x8000, SPEECHROM_TAG, 0)
	152	ROM_REGION(0x8000, "vsm", 0)
248	153	ROM_LOAD_OPTIONAL("spchrom.bin", 0x0000, 0x8000, BAD_DUMP CRC(58b155f7) SHA1(382292295c00dff348d7e17c5ce4da12a1d87763)) /* system speech ROM */
249	154	ROM_END
250	155

trunk/src/mess/machine/ti99/speech8.h

r22818	r22819
53	53	virtual machine_config_constructor device_mconfig_additions() const;
54	54
55	55	private:
56		tms5220n_device *m_vsp;
57		UINT8           *m_speechrom;           // pointer to speech ROM data
58		int             m_load_pointer;         // which 4-bit nibble will be affected by load address
59		int             m_rombits_count;        // current bit position in ROM
60		UINT32          m_sprom_address;        // 18 bit pointer in ROM
61		UINT32          m_sprom_length;         // length of data pointed by speechrom_data, from 0 to 2^18
	56	tms5220_device  *m_vsp;
	57	//   UINT8           *m_speechrom;           // pointer to speech ROM data
	58	//   int             m_load_pointer;         // which 4-bit nibble will be affected by load address
	59	//   int             m_rombits_count;        // current bit position in ROM
	60	//   UINT32          m_sprom_address;        // 18 bit pointer in ROM
	61	//   UINT32          m_sprom_length;         // length of data pointed by speechrom_data, from 0 to 2^18
62	62
63	63	// Ready line to the CPU
64	64	devcb_resolved_write_line m_ready;

trunk/src/mess/machine/rmnimbus.c

r22818	r22819
2707	2707	//device_t *ay8910 = machine().device(AY8910_TAG);
2708	2708	device_t *msm5205 = machine().device(MSM5205_TAG);
2709	2709
2710		//ay8910_reset_ym(ay8910);
	2710	//ay8910->reset();
2711	2711	msm5205_reset_w(msm5205, 1);
2712	2712
2713	2713	m_last_playmode=MSM5205_S48_4B;

trunk/src/mess/includes/mpf1.h

r22818	r22819
5	5
6	6
7	7	#include "emu.h"
8		#include "audio/spchroms.h"
	8	#include "machine/spchrom.h"
9	9	#include "cpu/z80/z80.h"
10	10	#include "cpu/z80/z80daisy.h"
11	11	#include "imagedev/cassette.h"

trunk/src/mame/machine/mhavoc.c

r22818	r22819
203	203
204	204	CUSTOM_INPUT_MEMBER(mhavoc_state::tms5220_r)
205	205	{
206		return tms5220_readyq_r(machine().device("tms")) ? 1 : 0;
	206	tms5220_device *tms5220 = machine().device<tms5220_device>("tms");
	207	return tms5220->readyq_r() ? 1 : 0;
207	208	}
208	209
209	210	CUSTOM_INPUT_MEMBER(mhavoc_state::mhavoc_bit67_r)
r22818	r22819
308	309
309	310	WRITE8_MEMBER(mhavoc_state::mhavocrv_speech_strobe_w)
310	311	{
311		device_t *tms = machine().device("tms");
312		tms5220_data_w(tms, space, 0, m_speech_write_buffer);
	312	tms5220_device *tms5220 = machine().device<tms5220_device>("tms");
	313	tms5220->data_w(space, 0, m_speech_write_buffer);
313	314	}
314	315
315	316	/*************************************

trunk/src/mame/includes/esripsys.h

r22818	r22819
11	11
12	12	#include "cpu/esrip/esrip.h"
13	13	#include "sound/dac.h"
	14	#include "sound/tms5220.h"
14	15
15	16	/* TODO */
16	17	#define ESRIPSYS_PIXEL_CLOCK    (XTAL_25MHz / 2)
r22818	r22819
48	49	required_device<esrip_device> m_videocpu;
49	50	required_device<cpu_device> m_gamecpu;
50	51	required_device<cpu_device> m_soundcpu;
51		required_device<device_t> m_tms;
	52	required_device<tms5220_device> m_tms;
52	53
53	54	UINT8 m_g_iodata;
54	55	UINT8 m_g_ioaddr;

trunk/src/mame/includes/polepos.h

r22818	r22819
23	23	m_subcpu(*this, "sub"),
24	24	m_subcpu2(*this, "sub2") { }
25	25
26		optional_device<tms5220n_device> m_tms;
	26	optional_device<tms5220_device> m_tms;
27	27	UINT8 m_steer_last;
28	28	UINT8 m_steer_delta;
29	29	INT16 m_steer_accum;

trunk/src/mame/includes/portrait.h

r22818	r22819
11	11	m_spriteram(*this, "spriteram"),
12	12	m_maincpu(*this, "maincpu") { }
13	13
14		required_device<tms5200n_device> m_tms;
	14	required_device<tms5200_device> m_tms;
15	15	required_shared_ptr<UINT8> m_bgvideoram;
16	16	required_shared_ptr<UINT8> m_fgvideoram;
17	17	int m_scroll;

trunk/src/mame/drivers/portrait.c

r22818	r22819
240	240	GFXDECODE_ENTRY( "gfx1", 0x00000, tile_layout, 0, 0x800/8 )
241	241	GFXDECODE_END
242	242
243		static const tms52xx_config tms_intf =
244		{
245		DEVCB_NULL
246		};
247	243
248
249	244	static MACHINE_CONFIG_START( portrait, portrait_state )
250	245	MCFG_CPU_ADD("maincpu", Z80, 4000000)     /* 4 MHz ? */
251	246	MCFG_CPU_PROGRAM_MAP(portrait_map)
r22818	r22819
270	265
271	266	/* sound hardware */
272	267	MCFG_SPEAKER_STANDARD_MONO("mono")
273		MCFG_SOUND_ADD("tms", TMS5200N, 640000)
	268	MCFG_SOUND_ADD("tms", TMS5200, 640000)
274	269	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
275		MCFG_SOUND_CONFIG(tms_intf)
276	270	MACHINE_CONFIG_END
277	271
278	272

trunk/src/mame/drivers/tomcat.c

r22818	r22819
46	46	m_maincpu(*this, "maincpu"),
47	47	m_dsp(*this, "dsp") { }
48	48
49		required_device<tms5220n_device> m_tms;
	49	required_device<tms5220_device> m_tms;
50	50	int m_control_num;
51	51	required_shared_ptr<UINT16> m_shared_ram;
52	52	UINT8 m_nvram[0x800];
r22818	r22819
400	400	DEVCB_NULL  // connected to IRQ line of 6502
401	401	};
402	402
403		static const tms52xx_config tms_intf =
404		{
405		DEVCB_NULL
406		};
407
408	403	static MACHINE_CONFIG_START( tomcat, tomcat_state )
409	404	MCFG_CPU_ADD("maincpu", M68010, XTAL_12MHz / 2)
410	405	MCFG_CPU_PROGRAM_MAP(tomcat_map)
r22818	r22819
444	439	MCFG_POKEY_ADD("pokey2", XTAL_14_31818MHz / 8)
445	440	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 0.20)
446	441
447		MCFG_SOUND_ADD("tms", TMS5220N, 325000)
	442	MCFG_SOUND_ADD("tms", TMS5220, 325000)
448	443	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 0.50)
449	444	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 0.50)
450		MCFG_SOUND_CONFIG(tms_intf)
451	445
452	446	MCFG_YM2151_ADD("ymsnd", XTAL_14_31818MHz / 4)
453	447	MCFG_SOUND_ROUTE(0, "lspeaker", 0.60)

trunk/src/mame/drivers/zaccaria.c

r22818	r22819
96	96	/* 150 below to scale to volume 100 */
97	97	v = (150 * table[ba]) / (4700 + table[ba]);
98	98	//printf("dac1w %02d %04d\n", ba, v);
99		ay8910_set_volume(machine().device("ay2"), 1, v);
	99	machine().device<ay8910_device>("ay2")->set_volume(1, v);
100	100	}
101	101
102	102
r22818	r22819
160	160
161	161	WRITE8_MEMBER(zaccaria_state::zaccaria_port1b_w)
162	162	{
163		device_t *tms = machine().device("tms");
	163	tms5220_device *tms5220 = machine().device<tms5220_device>("tms");
164	164
165	165	// bit 0 = /RS
166		tms5220_rsq_w(tms, (data >> 0) & 0x01);
	166	tms5220->rsq_w((data >> 0) & 0x01);
167	167	// bit 1 = /WS
168		tms5220_wsq_w(tms, (data >> 1) & 0x01);
	168	tms5220->wsq_w((data >> 1) & 0x01);
169	169
170	170	// bit 3 = "ACS" (goes, inverted, to input port 6 bit 3)
171	171	m_acs = ~data & 0x08;
r22818	r22819
546	546
547	547	static const pia6821_interface pia_1_config =
548	548	{
549		DEVCB_DEVICE_HANDLER("tms", tms5220_status_r),  /* port A in */
	549	DEVCB_DEVICE_MEMBER("tms", tms5220_device, status_r),  /* port A in */
550	550	DEVCB_NULL,                                     /* port B in */
551	551	DEVCB_NULL,                                     /* line CA1 in */
552	552	DEVCB_NULL,                                     /* line CB1 in */   // tms5220_intq_r, handled below in tms5220_config
553	553	DEVCB_NULL,                                     /* line CA2 in */   // tms5220_readyq_r, "
554	554	DEVCB_NULL,                                     /* line CB2 in */
555		DEVCB_DEVICE_HANDLER("tms", tms5220_data_w),    /* port A out */
	555	DEVCB_DEVICE_MEMBER("tms", tms5220_device, data_w),    /* port A out */
556	556	DEVCB_DRIVER_MEMBER(zaccaria_state,zaccaria_port1b_w),              /* port B out */
557	557	DEVCB_NULL,                                     /* line CA2 out */
558	558	DEVCB_NULL,                                     /* port CB2 out */
r22818	r22819
560	560	DEVCB_NULL                                      /* IRQB */
561	561	};
562	562
563		static const tms5220_interface tms5220_config =
564		{
565		DEVCB_DEVICE_LINE_MEMBER("pia1", pia6821_device, cb1_w),    /* IRQ handler */
566		DEVCB_DEVICE_LINE_MEMBER("pia1", pia6821_device, ca2_w)     /* READYQ handler */
567		};
568
569	563	INTERRUPT_GEN_MEMBER(zaccaria_state::vblank_irq)
570	564	{
571	565	if(m_nmi_mask)
r22818	r22819
622	616	/* There is no xtal, the clock is obtained from a RC oscillator as shown in the TMS5220 datasheet (R=100kOhm C=22pF) */
623	617	/* 162kHz measured on pin 3 20 minutesa fter power on. Clock would then be 162*4=648kHz. */
624	618	MCFG_SOUND_ADD("tms", TMS5200, 649200) /* ROMCLK pin measured at 162.3Khz, OSC is exactly *4 of that) */
625		MCFG_SOUND_CONFIG(tms5220_config)
	619	MCFG_TMS52XX_IRQ_HANDLER(DEVWRITELINE("pia1", pia6821_device, cb1_w))
	620	MCFG_TMS52XX_READYQ_HANDLER(DEVWRITELINE("pia1", pia6821_device, ca2_w))
626	621	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.80)
627	622	MACHINE_CONFIG_END
628	623

trunk/src/mame/drivers/atarisy2.c

r22818	r22819
350	350
351	351	if (m_cpu_to_sound_ready) result |= 0x01;
352	352	if (m_sound_to_cpu_ready) result |= 0x02;
353		if ((m_has_tms5220) && (tms5220_readyq_r(machine().device("tms")) == 0))
	353	if ((m_has_tms5220) && (machine().device<tms5220_device>("tms")->readyq_r() == 0))
354	354	result &= ~0x04;
355	355	if (!(ioport("1801")->read() & 0x80)) result |= 0x10;
356	356
r22818	r22819
363	363	if (m_has_tms5220)
364	364	{
365	365	data = 12 | ((data >> 5) & 1);
366		tms5220_set_frequency(machine().device("tms"), MASTER_CLOCK/4 / (16 - data) / 2);
	366	machine().device<tms5220_device>("tms")->set_frequency(MASTER_CLOCK/4 / (16 - data) / 2);
367	367	}
368	368	}
369	369
r22818	r22819
736	736	{
737	737	if (m_has_tms5220)
738	738	{
739		tms5220_data_w(machine().device("tms"), space, 0, data);
	739	machine().device<tms5220_device>("tms")->data_w(space, 0, data);
740	740	}
741	741	}
742	742
r22818	r22819
744	744	{
745	745	if (m_has_tms5220)
746	746	{
747		tms5220_wsq_w(machine().device("tms"), 1-(offset & 1));
	747	machine().device<tms5220_device>("tms")->wsq_w(1-(offset & 1));
748	748	}
749	749	}
750	750
r22818	r22819
3178	3178
3179	3179	m_pedal_count = 0;
3180	3180	m_has_tms5220 = 1;
3181		tms5220_rsq_w(machine().device("tms"),  1); // /RS is tied high on sys2 hw
	3181	machine().device<tms5220_device>("tms")->rsq_w(1); // /RS is tied high on sys2 hw
3182	3182	}
3183	3183
3184	3184
r22818	r22819
3191	3191
3192	3192	m_pedal_count = -1;
3193	3193	m_has_tms5220 = 1;
3194		tms5220_rsq_w(machine().device("tms"),  1); // /RS is tied high on sys2 hw
	3194	machine().device<tms5220_device>("tms")->rsq_w(1); // /RS is tied high on sys2 hw
3195	3195	}
3196	3196
3197	3197
r22818	r22819
3233	3233
3234	3234	m_pedal_count = 2;
3235	3235	m_has_tms5220 = 1;
3236		tms5220_rsq_w(machine().device("tms"),  1); // /RS is tied high on sys2 hw
	3236	machine().device<tms5220_device>("tms")->rsq_w(1); // /RS is tied high on sys2 hw
3237	3237	}
3238	3238
3239	3239

trunk/src/mame/drivers/maygay1b.c

r22818	r22819
795	795
796	796	READ8_MEMBER(maygay1b_state::m1_meter_r)
797	797	{
798		device_t *ay8910 = machine().device("aysnd");
799		return ~ay8910_read_ym(ay8910);
	798	ay8910_device *ay8910 = machine().device<ay8910_device>("aysnd");
	799	return ~ay8910->data_r(space, offset);
800	800	}
801	801
802	802	static ADDRESS_MAP_START( m1_memmap, AS_PROGRAM, 8, maygay1b_state )

trunk/src/mame/drivers/firefox.c

r22818	r22819
351	351
352	352	READ8_MEMBER(firefox_state::riot_porta_r)
353	353	{
354		device_t *tms = machine().device("tms");
	354	tms5220_device *tms5220 = machine().device<tms5220_device>("tms");
	355
355	356	/* bit 7 = MAINFLAG */
356	357	/* bit 6 = SOUNDFLAG */
357	358	/* bit 5 = PA5 */
r22818	r22819
361	362	/* bit 1 = TMS /read */
362	363	/* bit 0 = TMS /write */
363	364
364		return (m_main_to_sound_flag << 7) | (m_sound_to_main_flag << 6) | 0x10 | (tms5220_readyq_r(tms) << 2);
	365	return (m_main_to_sound_flag << 7) | (m_sound_to_main_flag << 6) | 0x10 | (tms5220->readyq_r() << 2);
365	366	}
366	367
367	368	WRITE8_MEMBER(firefox_state::riot_porta_w)
368	369	{
369		device_t *tms = machine().device("tms");
	370	tms5220_device *tms5220 = machine().device<tms5220_device>("tms");
370	371
371	372	/* handle 5220 read */
372		tms5220_rsq_w(tms, (data>>1) & 1);
	373	tms5220->rsq_w((data>>1) & 1);
373	374
374	375	/* handle 5220 write */
375		tms5220_wsq_w(tms, data & 1);
	376	tms5220->wsq_w(data & 1);
376	377	}
377	378
378	379	WRITE_LINE_MEMBER(firefox_state::riot_irq)
r22818	r22819
695	696	static const riot6532_interface riot_intf =
696	697	{
697	698	DEVCB_DRIVER_MEMBER(firefox_state,riot_porta_r),
698		DEVCB_DEVICE_HANDLER("tms", tms5220_status_r),
	699	DEVCB_DEVICE_MEMBER("tms", tms5220_device, status_r),
699	700	DEVCB_DRIVER_MEMBER(firefox_state,riot_porta_w),
700		DEVCB_DEVICE_HANDLER("tms", tms5220_data_w),
	701	DEVCB_DEVICE_MEMBER("tms", tms5220_device, data_w),
701	702	DEVCB_DRIVER_LINE_MEMBER(firefox_state,riot_irq)
702	703	};
703	704

trunk/src/mame/drivers/atarisy1.c

r22818	r22819
394	394
395	395	WRITE8_MEMBER(atarisy1_state::via_pa_w)
396	396	{
397		device_t *device = machine().device("tms");
398		tms5220_data_w(device, space, 0, data);
	397	tms5220_device *tms5220 = machine().device<tms5220_device>("tms");
	398	tms5220->data_w(space, 0, data);
399	399	}
400	400
401	401
402	402	READ8_MEMBER(atarisy1_state::via_pa_r)
403	403	{
404		device_t *device = machine().device("tms");
405		return tms5220_status_r(device, space, 0);
	404	tms5220_device *tms5220 = machine().device<tms5220_device>("tms");
	405	return tms5220->status_r(space, 0);
406	406	}
407	407
408	408
409	409	WRITE8_MEMBER(atarisy1_state::via_pb_w)
410	410	{
411		device_t *device = machine().device("tms");
	411	tms5220_device *tms5220 = machine().device<tms5220_device>("tms");
412	412	/* write strobe */
413		tms5220_wsq_w(device, data & 1);
	413	tms5220->wsq_w(data & 1);
414	414
415	415	/* read strobe */
416		tms5220_rsq_w(device, (data & 2)>>1);
	416	tms5220->rsq_w((data & 2)>>1);
417	417
418	418	/* bit 4 is connected to an up-counter, clocked by SYCLKB */
419	419	data = 5 | ((data >> 3) & 2);
420		tms5220_set_frequency(device, ATARI_CLOCK_14MHz/2 / (16 - data));
	420	tms5220->set_frequency(ATARI_CLOCK_14MHz/2 / (16 - data));
421	421	}
422	422
423	423
424	424	READ8_MEMBER(atarisy1_state::via_pb_r)
425	425	{
426		device_t *device = machine().device("tms");
427		return (tms5220_readyq_r(device) << 2) | (tms5220_intq_r(device) << 3);
	426	tms5220_device *tms5220 = machine().device<tms5220_device>("tms");
	427	return (tms5220->readyq_r() << 2) | (tms5220->intq_r() << 3);
428	428	}
429	429
430	430

trunk/src/mame/drivers/looping.c

r22818	r22819
552	552	AM_RANGE(0x3c00, 0x3c00) AM_MIRROR(0x00f4) AM_DEVREADWRITE("aysnd", ay8910_device, data_r, address_w)
553	553	AM_RANGE(0x3c02, 0x3c02) AM_MIRROR(0x00f4) AM_READNOP AM_DEVWRITE("aysnd", ay8910_device, data_w)
554	554	AM_RANGE(0x3c03, 0x3c03) AM_MIRROR(0x00f6) AM_NOP
555		AM_RANGE(0x3e00, 0x3e00) AM_MIRROR(0x00f4) AM_READNOP AM_DEVWRITE("tms", tms5220n_device, write)
556		AM_RANGE(0x3e02, 0x3e02) AM_MIRROR(0x00f4) AM_DEVREAD("tms", tms5220n_device, read) AM_WRITENOP
	555	AM_RANGE(0x3e00, 0x3e00) AM_MIRROR(0x00f4) AM_READNOP AM_DEVWRITE("tms", tms5220_device, data_w)
	556	AM_RANGE(0x3e02, 0x3e02) AM_MIRROR(0x00f4) AM_DEVREAD("tms", tms5220_device, status_r) AM_WRITENOP
557	557	AM_RANGE(0x3e03, 0x3e03) AM_MIRROR(0x00f6) AM_NOP
558	558	ADDRESS_MAP_END
559	559
r22818	r22819
612	612	*
613	613	*************************************/
614	614
615		static const tms52xx_config tms5220interface =
616		{
617		DEVCB_DRIVER_LINE_MEMBER(looping_state,looping_spcint),     // IRQ
618		DEVCB_NULL                      // READYQ
619		};
620
621	615	static const ay8910_interface ay8910_config =
622	616	{
623	617	AY8910_LEGACY_OUTPUT,
r22818	r22819
676	670	MCFG_SOUND_CONFIG(ay8910_config)
677	671	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.20)
678	672
679		MCFG_SOUND_ADD("tms", TMS5220N, TMS_CLOCK)
680		MCFG_SOUND_CONFIG(tms5220interface)
	673	MCFG_SOUND_ADD("tms", TMS5220, TMS_CLOCK)
	674	MCFG_TMS52XX_IRQ_HANDLER(WRITELINE(looping_state, looping_spcint))
681	675	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
682	676
683	677	MCFG_DAC_ADD("dac")

trunk/src/mame/drivers/icecold.c

r22818	r22819
163	163	void icecold_state::machine_reset()
164	164	{
165	165	// CH-C is used for generate a 30hz clock
166		ay8910_set_volume(m_ay8910_0, 2, 0);
	166	m_ay8910_0->set_volume(2, 0);
167	167
168	168	m_rmotor = m_lmotor = 10;
169	169	m_sint = 0;

trunk/src/mame/drivers/esripsys.c

r22818	r22819
30	30	#include "machine/6840ptm.h"
31	31	#include "machine/nvram.h"
32	32	#include "sound/dac.h"
33		#include "sound/tms5220.h"
34	33	#include "includes/esripsys.h"
35	34
36	35
r22818	r22819
521	520	if (offset == 0)
522	521	{
523	522	/* TMS5220 core returns status bits in D7-D6 */
524		UINT8 status = tms5220_status_r(m_tms, space, 0);
	523	UINT8 status = m_tms->status_r(space, 0);
525	524
526	525	status = ((status & 0x80) >> 5) | ((status & 0x40) >> 5) | ((status & 0x20) >> 5);
527		return (tms5220_readyq_r(m_tms) << 7) | (tms5220_intq_r(m_tms) << 6) | status;
	526	return (m_tms->readyq_r() << 7) | (m_tms->intq_r() << 6) | status;
528	527	}
529	528
530	529	return 0xff;
r22818	r22819
536	535	if (offset == 0)
537	536	{
538	537	m_tms_data = data;
539		tms5220_data_w(m_tms, space, 0, m_tms_data);
	538	m_tms->data_w(space, 0, m_tms_data);
540	539	}
541	540	#if 0
542	541	if (offset == 1)
543	542	{
544		tms5220_data_w(m_tms, space, 0, m_tms_data);
	543	m_tms->data_w(space, 0, m_tms_data);
545	544	}
546	545	#endif
547	546	}

trunk/src/mame/drivers/polepos.c

r22818	r22819
957	957	"maincpu", "51xx", NULL, NULL, NULL
958	958	};
959	959
960		static const tms52xx_config tms_intf =
961		{
962		DEVCB_NULL
963		};
964
965	960	static MACHINE_CONFIG_START( topracern, polepos_state )
966	961
967	962	/* basic machine hardware */
r22818	r22819
1030	1025	MCFG_CPU_PROGRAM_MAP(sound_z80_bootleg_map)
1031	1026	MCFG_CPU_IO_MAP(sound_z80_bootleg_iomap)
1032	1027
1033		MCFG_SOUND_ADD("tms", TMS5220N, 600000) /* ? Mhz */
	1028	MCFG_SOUND_ADD("tms", TMS5220, 600000) /* ? Mhz */
1034	1029	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "lspeaker", 0.80)
1035	1030	MCFG_SOUND_ROUTE(ALL_OUTPUTS, "rspeaker", 0.80)
1036		MCFG_SOUND_CONFIG(tms_intf)
1037	1031	MACHINE_CONFIG_END
1038	1032
1039	1033

trunk/src/mame/drivers/gauntlet.c

r22818	r22819
207	207	if (m_sound_reset_val & 1)
208	208	{
209	209	machine().device("ymsnd")->reset();
210		machine().device("tms")->reset();
211		tms5220_set_frequency(machine().device("tms"), ATARI_CLOCK_14MHz/2 / 11);
	210	tms5220_device *tms5220 = machine().device<tms5220_device>("tms");
	211	tms5220->reset();
	212	tms5220->set_frequency(ATARI_CLOCK_14MHz/2 / 11);
212	213	set_ym2151_volume(0);
213	214	set_pokey_volume(0);
214	215	set_tms5220_volume(0);
r22818	r22819
227	228
228	229	READ8_MEMBER(gauntlet_state::switch_6502_r)
229	230	{
	231	tms5220_device *tms5220 = machine().device<tms5220_device>("tms");
230	232	int temp = 0x30;
231	233
232	234	if (m_cpu_to_sound_ready) temp ^= 0x80;
233	235	if (m_sound_to_cpu_ready) temp ^= 0x40;
234		if (!tms5220_readyq_r(machine().device("tms"))) temp ^= 0x20;
	236	if (!tms5220->readyq_r()) temp ^= 0x20;
235	237	if (!(ioport("803008")->read() & 0x0008)) temp ^= 0x10;
236	238
237	239	return temp;
r22818	r22819
246	248
247	249	WRITE8_MEMBER(gauntlet_state::sound_ctl_w)
248	250	{
249		device_t *tms = machine().device("tms");
	251	tms5220_device *tms5220 = machine().device<tms5220_device>("tms");
250	252	switch (offset & 7)
251	253	{
252	254	case 0: /* music reset, bit D7, low reset */
r22818	r22819
254	256	break;
255	257
256	258	case 1: /* speech write, bit D7, active low */
257		tms5220_wsq_w(tms, data >> 7);
	259	tms5220->wsq_w(data >> 7);
258	260	break;
259	261
260	262	case 2: /* speech reset, bit D7, active low */
261		tms5220_rsq_w(tms, data >> 7);
	263	tms5220->rsq_w(data >> 7);
262	264	break;
263	265
264	266	case 3: /* speech squeak, bit D7 */
265	267	data = 5 | ((data >> 6) & 2);
266		tms5220_set_frequency(tms, ATARI_CLOCK_14MHz/2 / (16 - data));
	268	tms5220->set_frequency(ATARI_CLOCK_14MHz/2 / (16 - data));
267	269	break;
268	270	}
269	271	}
r22818	r22819
342	344	AM_RANGE(0x1030, 0x103f) AM_MIRROR(0x27c0) AM_READWRITE(switch_6502_r, sound_ctl_w)
343	345	AM_RANGE(0x1800, 0x180f) AM_MIRROR(0x27c0) AM_DEVREADWRITE("pokey", pokey_device, read, write)
344	346	AM_RANGE(0x1810, 0x1811) AM_MIRROR(0x27ce) AM_DEVREADWRITE("ymsnd", ym2151_device, read, write)
345		AM_RANGE(0x1820, 0x182f) AM_MIRROR(0x27c0) AM_DEVWRITE_LEGACY("tms", tms5220_data_w)
	347	AM_RANGE(0x1820, 0x182f) AM_MIRROR(0x27c0) AM_DEVWRITE("tms", tms5220_device, data_w)
346	348	AM_RANGE(0x1830, 0x183f) AM_MIRROR(0x27c0) AM_READWRITE(m6502_irq_ack_r, m6502_irq_ack_w)
347	349	AM_RANGE(0x4000, 0xffff) AM_ROM
348	350	ADDRESS_MAP_END

trunk/src/mame/audio/cinemat.c

r22818	r22819
1410	1410	state->m_last_portb_write = 0xff;
1411	1411
1412	1412	/* turn off channel A on AY8910 #0 because it is used as a low-pass filter */
1413		ay8910_set_volume(machine.device("ay1"), 0, 0);
	1413	machine.device<ay8910_device>("ay1")->set_volume(0, 0);
1414	1414	}
1415	1415
1416	1416

trunk/src/mame/audio/exidy.c

r22818	r22819
103	103
104	104	/* 5220/CVSD variables */
105	105	device_t *m_cvsd;
106		device_t *m_tms;
	106	tms5220_device *m_tms;
107	107	pia6821_device *m_pia1;
108	108
109	109	/* sound streaming variables */
r22818	r22819
533	533	if (state->m_tms != NULL)
534	534	{
535	535	logerror("(%f)%s:TMS5220 data write = %02X\n", space.machine().time().as_double(), space.machine().describe_context(), state->m_riot->porta_out_get());
536		tms5220_data_w(state->m_tms, space, 0, data);
	536	state->m_tms->data_w(space, 0, data);
537	537	}
538	538	}
539	539
r22818	r22819
542	542	exidy_sound_state *state = get_safe_token(device);
543	543	if (state->m_tms != NULL)
544	544	{
545		logerror("(%f)%s:TMS5220 status read = %02X\n", space.machine().time().as_double(), space.machine().describe_context(), tms5220_status_r(state->m_tms, space, 0));
546		return tms5220_status_r(state->m_tms, space, 0);
	545	logerror("(%f)%s:TMS5220 status read = %02X\n", space.machine().time().as_double(), space.machine().describe_context(), state->m_tms->status_r(space, 0));
	546	return state->m_tms->status_r(space, 0);
547	547	}
548	548	else
549	549	return 0xff;
r22818	r22819
554	554	exidy_sound_state *state = get_safe_token(device);
555	555	if (state->m_tms != NULL)
556	556	{
557		tms5220_rsq_w(state->m_tms, data & 0x01);
558		tms5220_wsq_w(state->m_tms, (data >> 1) & 0x01);
	557	state->m_tms->rsq_w(data & 0x01);
	558	state->m_tms->wsq_w((data >> 1) & 0x01);
559	559	}
560	560	}
561	561
r22818	r22819
567	567	if (state->m_tms != NULL)
568	568	{
569	569	newdata &= ~0x0c;
570		if (tms5220_readyq_r(state->m_tms)) newdata |= 0x04;
571		if (tms5220_intq_r(state->m_tms)) newdata |= 0x08;
	570	if (state->m_tms->readyq_r()) newdata |= 0x04;
	571	if (state->m_tms->intq_r()) newdata |= 0x08;
572	572	}
573	573	return newdata;
574	574	}
r22818	r22819
1126	1126	device->save_item(NAME(state->m_victory_sound_response_ack_clk));
1127	1127
1128	1128	DEVICE_START_CALL(venture_common_sh_start);
1129		state->m_tms = device->machine().device("tms");
	1129	state->m_tms = device->machine().device<tms5220_device>("tms");
1130	1130	}
1131	1131
1132	1132

trunk/src/mame/audio/midway.c

r22818	r22819
372	372
373	373	void midway_ssio_device::update_volumes()
374	374	{
375		ay8910_set_volume(m_ay0, 0, m_mute ? 0 : m_ayvolume_lookup[m_duty_cycle[0][0]]);
376		ay8910_set_volume(m_ay0, 1, m_mute ? 0 : m_ayvolume_lookup[m_duty_cycle[0][1]]);
377		ay8910_set_volume(m_ay0, 2, m_mute ? 0 : m_ayvolume_lookup[m_duty_cycle[0][2]]);
378		ay8910_set_volume(m_ay1, 0, m_mute ? 0 : m_ayvolume_lookup[m_duty_cycle[1][0]]);
379		ay8910_set_volume(m_ay1, 1, m_mute ? 0 : m_ayvolume_lookup[m_duty_cycle[1][1]]);
380		ay8910_set_volume(m_ay1, 2, m_mute ? 0 : m_ayvolume_lookup[m_duty_cycle[1][2]]);
	375	m_ay0->set_volume(0, m_mute ? 0 : m_ayvolume_lookup[m_duty_cycle[0][0]]);
	376	m_ay0->set_volume(1, m_mute ? 0 : m_ayvolume_lookup[m_duty_cycle[0][1]]);
	377	m_ay0->set_volume(2, m_mute ? 0 : m_ayvolume_lookup[m_duty_cycle[0][2]]);
	378	m_ay1->set_volume(0, m_mute ? 0 : m_ayvolume_lookup[m_duty_cycle[1][0]]);
	379	m_ay1->set_volume(1, m_mute ? 0 : m_ayvolume_lookup[m_duty_cycle[1][1]]);
	380	m_ay1->set_volume(2, m_mute ? 0 : m_ayvolume_lookup[m_duty_cycle[1][2]]);
381	381	}
382	382
383	383
r22818	r22819
1198	1198	// write strobe -- pass the current command to the TMS5200
1199	1199	if (((data ^ m_tms_strobes) & 0x02) && !(data & 0x02))
1200	1200	{
1201		tms5220_data_w(m_tms5200, space, offset, m_tms_command);
	1201	m_tms5200->data_w(space, offset, m_tms_command);
1202	1202
1203	1203	// DoT expects the ready line to transition on a command/write here, so we oblige
1204	1204	m_pia1->ca2_w(1);
r22818	r22819
1208	1208	// read strobe -- read the current status from the TMS5200
1209	1209	else if (((data ^ m_tms_strobes) & 0x01) && !(data & 0x01))
1210	1210	{
1211		m_pia1->porta_w(tms5220_status_r(m_tms5200, space, offset));
	1211	m_pia1->porta_w(m_tms5200->status_r(space, offset));
1212	1212
1213	1213	// DoT expects the ready line to transition on a command/write here, so we oblige
1214	1214	m_pia1->ca2_w(1);

trunk/src/mame/audio/starwars.c

r22818	r22819
34	34	/* Note: bit 4 is always set to avoid sound self test */
35	35	UINT8 olddata = m_riot->porta_in_get();
36	36
37		return (olddata & 0xc0) | 0x10 | (tms5220_readyq_r(machine().device("tms")) << 2);
	37	tms5220_device *tms5220 = machine().device<tms5220_device>("tms");
	38	return (olddata & 0xc0) | 0x10 | (tms5220->readyq_r() << 2);
38	39	}
39	40
40	41
41	42	WRITE8_MEMBER(starwars_state::r6532_porta_w)
42	43	{
43		device_t *device = machine().device("tms");
	44	tms5220_device *tms5220 = machine().device<tms5220_device>("tms");
44	45	/* handle 5220 read */
45		tms5220_rsq_w(device, (data & 2)>>1);
	46	tms5220->rsq_w((data & 2)>>1);
46	47	/* handle 5220 write */
47		tms5220_wsq_w(device, (data & 1)>>0);
	48	tms5220->wsq_w((data & 1)>>0);
48	49	}
49	50
50	51
r22818	r22819
57	58	const riot6532_interface starwars_riot6532_intf =
58	59	{
59	60	DEVCB_DRIVER_MEMBER(starwars_state,r6532_porta_r),
60		DEVCB_DEVICE_HANDLER("tms", tms5220_status_r),
	61	DEVCB_DEVICE_MEMBER("tms", tms5220_device, status_r),
61	62	DEVCB_DRIVER_MEMBER(starwars_state,r6532_porta_w),
62		DEVCB_DEVICE_HANDLER("tms", tms5220_data_w),
	63	DEVCB_DEVICE_MEMBER("tms", tms5220_device, data_w),
63	64	DEVCB_DRIVER_LINE_MEMBER(starwars_state,snd_interrupt)
64	65	};
65	66

trunk/src/mame/audio/jedi.c

r22818	r22819
139	139
140	140	if ((new_speech_strobe_state != m_speech_strobe_state) && new_speech_strobe_state)
141	141	{
142		device_t *tms = machine().device("tms");
143		tms5220_data_w(tms, space, 0, *m_speech_data);
	142	tms5220_device *tms5220 = machine().device<tms5220_device>("tms");
	143	tms5220->data_w(space, 0, *m_speech_data);
144	144	}
145	145	m_speech_strobe_state = new_speech_strobe_state;
146	146	}
r22818	r22819
148	148
149	149	READ8_MEMBER(jedi_state::speech_ready_r)
150	150	{
151		return (tms5220_readyq_r(machine().device("tms"))) << 7;
	151	tms5220_device *tms5220 = machine().device<tms5220_device>("tms");
	152	return (tms5220->readyq_r()) << 7;
152	153	}
153	154
154	155

trunk/src/mame/audio/atarijsa.c

r22818	r22819
59	59
60	60	static pokey_device *pokey;
61	61	static ym2151_device *ym2151;
62		static device_t *tms5220;
	62	static tms5220_device *tms5220;
63	63	static okim6295_device *oki6295;
64	64	static okim6295_device *oki6295_l, *oki6295_r;
65	65
r22818	r22819
138	138	bank_source_data = &rgn[0x10000];
139	139
140	140	/* determine which sound hardware is installed */
141		tms5220 = machine.device("tms");
	141	tms5220 = machine.device<tms5220_device>("tms");
142	142	ym2151 = machine.device<ym2151_device>("ymsnd");
143	143	pokey = machine.device<pokey_device>("pokey");
144	144	oki6295 = machine.device<okim6295_device>("adpcm");
r22818	r22819
231	231	if (!(space.machine().root_device().ioport(test_port)->read() & test_mask)) result ^= 0x80;
232	232	if (atarigen->m_cpu_to_sound_ready) result ^= 0x40;
233	233	if (atarigen->m_sound_to_cpu_ready) result ^= 0x20;
234		if ((tms5220 != NULL) && (tms5220_readyq_r(tms5220) == 0))
	234	if ((tms5220 != NULL) && (tms5220->readyq_r() == 0))
235	235	result |= 0x10;
236	236	else
237	237	result &= ~0x10;
r22818	r22819
269	269
270	270	case 0x200:     /* /VOICE */
271	271	if (tms5220 != NULL)
272		tms5220_data_w(tms5220, space, 0, data);
	272	tms5220->data_w(space, 0, data);
273	273	break;
274	274
275	275	case 0x202:     /* /WRP */
r22818	r22819
291	291	if (tms5220 != NULL)
292	292	{
293	293	int count;
294		tms5220_wsq_w(tms5220, (data&0x02)>>1);
295		tms5220_rsq_w(tms5220, (data&0x04)>>2);
	294	tms5220->wsq_w((data&0x02)>>1);
	295	tms5220->rsq_w((data&0x04)>>2);
296	296	count = 5 | ((data >> 2) & 2);
297		tms5220_set_frequency(tms5220, JSA_MASTER_CLOCK*2 / (16 - count));
	297	tms5220->set_frequency(JSA_MASTER_CLOCK*2 / (16 - count));
298	298	}
299	299
300	300	/* reset the YM2151 if needed */

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team