MAME SVN History

199869 Revisions

r26073 Saturday 9th November, 2013 at 16:46:56 UTC by Jürgen Buchmüller
Define LOG_xxx constants for the sections, m_log_type enable mask and m_log_level verbosity. Log output into the debug console.

[/branches/alto2/src/emu/cpu/alto2]	a2curt.c a2dht.c a2disk.c a2disp.c a2drive.c a2dvt.c a2dwt.c a2emu.c a2ether.c a2ksec.c a2kwd.c a2mem.c a2mrt.c a2ram.c alto2.c alto2.h
[/branches/alto2/src/mess/includes]	alto2.h

branches/alto2/src/emu/cpu/alto2/a2ether.c
r26072	r26073
127	127
128	128	etac = m_task == task_ether;
129	129
130		LOG((0,0,"eth_wakeup: ibusy=%d obusy=%d ", GET_ETH_IBUSY(m_eth.status), GET_ETH_OBUSY(m_eth.status)));
	130	LOG((LOG_ETH,0,"eth_wakeup: ibusy=%d obusy=%d ", GET_ETH_IBUSY(m_eth.status), GET_ETH_OBUSY(m_eth.status)));
131	131	busy = GET_ETH_IBUSY(m_eth.status) \| GET_ETH_OBUSY(m_eth.status);
132	132	/* if not busy, reset the FIFO read and write counters */
133	133	if (busy == 0) {
r26072	r26073
144	144	* input gone
145	145	*/
146	146	if (GET_ETH_IDL(m_eth.status)) {
147		LOG((0,0,"post (input data late)\n"));
	147	LOG((LOG_ETH,0,"post (input data late)\n"));
148	148	m_task_wakeup \|= 1 << task_ether;
149	149	return;
150	150	}
151	151	if (GET_ETH_OCMD(m_eth.status)) {
152		LOG((0,0,"post (output command)\n"));
	152	LOG((LOG_ETH,0,"post (output command)\n"));
153	153	m_task_wakeup \|= 1 << task_ether;
154	154	return;
155	155	}
156	156	if (GET_ETH_ICMD(m_eth.status)) {
157		LOG((0,0,"post (input command)\n"));
	157	LOG((LOG_ETH,0,"post (input command)\n"));
158	158	m_task_wakeup \|= 1 << task_ether;
159	159	return;
160	160	}
161	161	if (GET_ETH_OGONE(m_eth.status)) {
162		LOG((0,0,"post (output gone)\n"));
	162	LOG((LOG_ETH,0,"post (output gone)\n"));
163	163	m_task_wakeup \|= 1 << task_ether;
164	164	return;
165	165	}
166	166	if (GET_ETH_IGONE(m_eth.status)) {
167		LOG((0,0,"post (input gone)\n"));
	167	LOG((LOG_ETH,0,"post (input gone)\n"));
168	168	m_task_wakeup \|= 1 << task_ether;
169	169	return;
170	170	}
r26072	r26073
181	181	idr = GET_ETH_IBUSY(m_eth.status) && (ETHER_A49_BNNE \|\| (ETHER_A49_BNE == 0 && etac));
182	182	if (idr) {
183	183	m_task_wakeup \|= 1 << task_ether;
184		LOG((0,0,"input data ready\n"));
	184	LOG((LOG_ETH,0,"input data ready\n"));
185	185	return;
186	186	}
187	187
r26072	r26073
197	197	odr = GET_ETH_OBUSY(m_eth.status) && (GET_ETH_OEOT(m_eth.status) \|\| (GET_ETH_WLF(m_eth.status) && ETHER_A49_BF == 0));
198	198	if (odr) {
199	199	m_task_wakeup \|= 1 << task_ether;
200		LOG((0,0,"output data ready\n"));
	200	LOG((LOG_ETH,0,"output data ready\n"));
201	201	return;
202	202	}
203	203
r26072	r26073
209	209	*/
210	210	if (m_ewfct) {
211	211	m_task_wakeup \|= 1 << task_ether;
212		LOG((0,0,"ether wake function\n"));
	212	LOG((LOG_ETH,0,"ether wake function\n"));
213	213	return;
214	214	}
215	215
216	216	/* otherwise no more wakeup for the Ether task */
217		LOG((0,0,"-/-\n"));
	217	LOG((LOG_ETH,0,"-/-\n"));
218	218	m_task_wakeup &= ~(1 << task_ether);
219	219	}
220	220
r26072	r26073
389	389	if (m_eth.tx_timer)
390	390	m_eth.tx_timer->enable(false);
391	391	/* TODO: send the CRC as final word of the packet */
392		LOG((0,0," CRC:%06o\n", m_eth.tx_crc));
	392	LOG((LOG_ETH,0," CRC:%06o\n", m_eth.tx_crc));
393	393	m_eth.tx_crc = 0;
394	394	PUT_ETH_OGONE(m_eth.status, 1); // set the OGONE flip flop
395	395	eth_wakeup();
r26072	r26073
399	399	data = m_eth.fifo[m_eth.fifo_rd];
400	400	m_eth.tx_crc = f9401_7(m_eth.tx_crc, data);
401	401	if (m_eth.fifo_rd % 8)
402		LOG((0,0," %06o", data));
	402	LOG((LOG_ETH,0," %06o", data));
403	403	else
404		LOG((0,0,"\n%06o: %06o", m_eth.tx_count, data));
	404	LOG((LOG_ETH,0,"\n%06o: %06o", m_eth.tx_count, data));
405	405	m_eth.fifo_rd = (m_eth.fifo_rd + 1) % ALTO2_ETHER_FIFO_SIZE;
406	406	m_eth.tx_count++;
407	407
r26072	r26073
440	440	{
441	441	UINT16 r = m_eth.fifo[m_eth.fifo_rd];
442	442
443		LOG((0,3, " <-EIDFCT; pull %06o from FIFO[%02o]\n", r, m_eth.fifo_rd));
	443	LOG((LOG_ETH,3, " <-EIDFCT; pull %06o from FIFO[%02o]\n", r, m_eth.fifo_rd));
444	444	m_eth.fifo_rd = (m_eth.fifo_rd + 1) % ALTO2_ETHER_FIFO_SIZE;
445	445	m_bus &= r;
446	446	m_eth.rx_count++;
r26072	r26073
453	453	*/
454	454	void alto2_cpu_device::f1_eth_block_0()
455	455	{
456		LOG((0,2," BLOCK %s\n", task_name(m_task)));
	456	LOG((LOG_ETH,2," BLOCK %s\n", task_name(m_task)));
457	457	m_task_wakeup &= ~(1 << task_ether);
458	458	}
459	459
r26072	r26073
466	466	void alto2_cpu_device::f1_eilfct_0()
467	467	{
468	468	UINT16 r = m_eth.fifo[m_eth.fifo_rd];
469		LOG((0,3, " <-EILFCT; %06o at FIFO[%02o]\n", r, m_eth.fifo_rd));
	469	LOG((LOG_ETH,3, " <-EILFCT; %06o at FIFO[%02o]\n", r, m_eth.fifo_rd));
470	470	m_bus &= r;
471	471	}
472	472
r26072	r26073
487	487	{
488	488	UINT16 r = ~A2_GET16(m_eth.status,16,10,15) & 0177777;
489	489
490		LOG((0,3, " <-EPFCT; BUS[8-15] = STATUS (%#o)\n", r));
	490	LOG((LOG_ETH,3, " <-EPFCT; BUS[8-15] = STATUS (%#o)\n", r));
491	491	m_bus &= r;
492	492
493	493	m_eth.status = 0;
r26072	r26073
519	519	*/
520	520	void alto2_cpu_device::f2_eodfct_1()
521	521	{
522		LOG((0,3, " EODFCT<-; push %06o into FIFO[%02o]\n", m_bus, m_eth.fifo_wr));
	522	LOG((LOG_ETH,3, " EODFCT<-; push %06o into FIFO[%02o]\n", m_bus, m_eth.fifo_wr));
523	523
524	524	m_eth.fifo[m_eth.fifo_wr] = m_bus;
525	525	m_eth.fifo_wr = (m_eth.fifo_wr + 1) % ALTO2_ETHER_FIFO_SIZE;
r26072	r26073
545	545	*/
546	546	void alto2_cpu_device::f2_eosfct_1()
547	547	{
548		LOG((0,3, " EOSFCT\n"));
	548	LOG((LOG_ETH,3, " EOSFCT\n"));
549	549	PUT_ETH_WLF(m_eth.status, 0);
550	550	PUT_ETH_OBUSY(m_eth.status, 0);
551	551	eth_wakeup();
r26072	r26073
566	566	UINT16 r = 0;
567	567	A2_PUT16(r,10,6,6,GET_ETH_ICMD(m_eth.status));
568	568	A2_PUT16(r,10,7,7,GET_ETH_OCMD(m_eth.status));
569		LOG((0,3, " ERBFCT; NEXT[6-7] = ICMD,OCMD (%#o \| %#o)\n", m_next2, r));
	569	LOG((LOG_ETH,3, " ERBFCT; NEXT[6-7] = ICMD,OCMD (%#o \| %#o)\n", m_next2, r));
570	570	m_next2 \|= r;
571	571	eth_wakeup();
572	572	}
r26072	r26073
608	608	GET_ETH_OCMD(m_eth.status) \|
609	609	GET_ETH_IGONE(m_eth.status) \|
610	610	GET_ETH_OGONE(m_eth.status));
611		LOG((0,3, " EBFCT; NEXT ... (%#o \| %#o)\n", m_next2, r));
	611	LOG((LOG_ETH,3, " EBFCT; NEXT ... (%#o \| %#o)\n", m_next2, r));
612	612	m_next2 \|= r;
613	613	}
614	614
r26072	r26073
622	622	UINT16 r = 0;
623	623	/* TODO: the BE' (buffer empty) signal is output D0 of PROM a49 */
624	624	A2_PUT16(r,10,7,7,ETHER_A49_BE);
625		LOG((0,3, " ECBFCT; NEXT[7] = FIFO %sempty (%#o \| %#o)\n", r ? "not " : "is ", m_next2, r));
	625	LOG((LOG_ETH,3, " ECBFCT; NEXT[7] = FIFO %sempty (%#o \| %#o)\n", r ? "not " : "is ", m_next2, r));
626	626	m_next2 \|= r;
627	627	}
628	628
r26072	r26073
636	636	*/
637	637	void alto2_cpu_device::f2_eisfct_1()
638	638	{
639		LOG((0,3, " EISFCT\n"));
	639	LOG((LOG_ETH,3, " EISFCT\n"));
640	640	PUT_ETH_IBUSY(m_eth.status, 0);
641	641	eth_wakeup();
642	642	}

branches/alto2/src/emu/cpu/alto2/a2drive.c
r26072	r26073
51	51	return;
52	52	}
53	53	if (d->cylinder < 0 \|\| d->cylinder >= DIABLO_DRIVE_CYLINDERS) {
54		LOG((0,9," DRIVE C/H/S:%d/%d/%d => invalid cylinder\n", d->cylinder, d->head, d->sector));
	54	LOG((LOG_DRIVE,9," DRIVE C/H/S:%d/%d/%d => invalid cylinder\n", d->cylinder, d->head, d->sector));
55	55	d->page = -1;
56	56	return;
57	57	}
58	58	/* calculate the new disk relative sector offset */
59	59	d->page = DRIVE_PAGE(d->cylinder, d->head, d->sector);
60		LOG((0,9," DRIVE C/H/S:%d/%d/%d => page:%d\n", d->cylinder, d->head, d->sector, d->page));
	60	LOG((LOG_DRIVE,9," DRIVE C/H/S:%d/%d/%d => page:%d\n", d->cylinder, d->head, d->sector, d->page));
61	61	}
62	62
63	63	/**
r26072	r26073
205	205	return;
206	206
207	207	if (-1 == page \|\| !d->image) {
208		LOG((0,0," no sector for #%d: %d/%d/%d\n", d->unit, d->cylinder, d->head, d->sector));
	208	LOG((LOG_DRIVE,0," no sector for #%d: %d/%d/%d\n", d->unit, d->cylinder, d->head, d->sector));
209	209	return;
210	210	}
211	211
r26072	r26073
258	258	#endif
259	259	d->bits[page] = bits;
260	260
261		LOG((0,0," BITS #%d: %03d/%d/%02d #%-5d bits (@%03d.%02d)\n",
	261	LOG((LOG_DRIVE,0," BITS #%d: %03d/%d/%02d #%-5d bits (@%03d.%02d)\n",
262	262	d->unit, d->cylinder, d->head, d->sector,
263	263	dst, dst / 32, dst % 32));
264	264
r26072	r26073
268	268	void alto2_cpu_device::drive_dump_ascii(UINT8 *src, size_t size)
269	269	{
270	270	size_t offs;
271		LOG((0,0," ["));
	271	LOG((LOG_DRIVE,0," ["));
272	272	for (offs = 0; offs < size; offs++) {
273	273	char ch = (char)src[offs ^ 1];
274		LOG((0,0, "%c", ch < 32 \|\| ch > 126 ? '.' : ch));
	274	LOG((LOG_DRIVE,0, "%c", ch < 32 \|\| ch > 126 ? '.' : ch));
275	275	}
276		LOG((0,0,"]\n"));
	276	LOG((LOG_DRIVE,0,"]\n"));
277	277	}
278	278
279	279
r26072	r26073
287	287	size_t alto2_cpu_device::dump_record(UINT8 src, size_t addr, size_t size, const char name, int cr)
288	288	{
289	289	size_t offs;
290		LOG((0,0,"%s:", name));
	290	LOG((LOG_DRIVE,0,"%s:", name));
291	291	for (offs = 0; offs < size; offs += 2) {
292	292	int word = src[offs] + 256 * src[offs + 1];
293	293	if (offs % 16) {
294		LOG((0,0," %06o", word));
	294	LOG((LOG_DRIVE,0," %06o", word));
295	295	} else {
296	296	if (offs > 0)
297	297	drive_dump_ascii(&src[offs-16], 16);
298		LOG((0,0,"\t%05o: %06o", (addr + offs) / 2, word));
	298	LOG((LOG_DRIVE,0,"\t%05o: %06o", (addr + offs) / 2, word));
299	299	}
300	300	}
301	301	if (offs % 16) {
r26072	r26073
304	304	drive_dump_ascii(&src[offs-16], 16);
305	305	}
306	306	if (cr) {
307		LOG((0,0,"\n"));
	307	LOG((LOG_DRIVE,0,"\n"));
308	308	}
309	309	return size;
310	310	}
r26072	r26073
343	343	}
344	344	}
345	345	/* return if no sync found within size32 clock and data bits /
346		LOG((0,0," no sync within %d words\n", size));
	346	LOG((LOG_DRIVE,0," no sync within %d words\n", size));
347	347	return src;
348	348	}
349	349
r26072	r26073
380	380	}
381	381	}
382	382	/* return if no sync found within size32 clock and data bits /
383		LOG((0,0," no unsync within %d words\n", size));
	383	LOG((LOG_DRIVE,0," no unsync within %d words\n", size));
384	384	return src;
385	385	}
386	386
r26072	r26073
459	459	fatal(1, "invalid unit %d in call to squeeze_sector()\n", unit);
460	460
461	461	if (d->rdfirst >= 0) {
462		LOG((0,0,
	462	LOG((LOG_DRIVE,0,
463	463	" RD #%d %03d/%d/%02d bit#%-5d (@%03d.%02d) ... bit#%-5d (@%03d.%02d)\n",
464	464	d->unit, d->cylinder, d->head, d->sector,
465	465	d->rdfirst, d->rdfirst / 32, d->rdfirst % 32,
r26072	r26073
483	483	}
484	484
485	485	if (d->wrfirst >= 0) {
486		LOG((0,0,
	486	LOG((LOG_DRIVE,0,
487	487	" WR #%d %03d/%d/%02d bit#%-5d (@%03d.%02d) ... bit#%-5d (@%03d.%02d)\n",
488	488	d->unit, d->cylinder, d->head, d->sector,
489	489	d->wrfirst, d->wrfirst / 32, d->wrfirst % 32,
r26072	r26073
493	493	d->wrlast = -1;
494	494
495	495	if (d->page < 0 \|\| d->page >= DIABLO_DRIVE_PAGES) {
496		LOG((0,0," no sector for #%d: %d/%d/%d\n", d->unit, d->cylinder, d->head, d->sector));
	496	LOG((LOG_DRIVE,0," no sector for #%d: %d/%d/%d\n", d->unit, d->cylinder, d->head, d->sector));
497	497	return;
498	498	}
499	499
r26072	r26073
505	505
506	506	/* no bits to write? */
507	507	if (!bits) {
508		LOG((0,0," no sector for #%d: %d/%d/%d\n", d->unit, d->cylinder, d->head, d->sector));
	508	LOG((LOG_DRIVE,0," no sector for #%d: %d/%d/%d\n", d->unit, d->cylinder, d->head, d->sector));
509	509	return;
510	510	}
511	511
r26072	r26073
519	519	src = squeeze_unsync(bits, src, 40);
520	520	/* sync on header preamble */
521	521	src = squeeze_sync(bits, src, 40);
522		LOG((0,0," header sync bit #%d (@%03d.%02d)\n",
	522	LOG((LOG_DRIVE,0," header sync bit #%d (@%03d.%02d)\n",
523	523	src, src / 32, src % 32));
524	524	src = squeeze_record(bits, src, s->header, sizeof(s->header));
525	525	src = squeeze_cksum(bits, src, &cksum_header);
r26072	r26073
531	531	src = squeeze_unsync(bits, src, 40);
532	532	/* sync on label preamble */
533	533	src = squeeze_sync(bits, src, 40);
534		LOG((0,0," label sync bit #%d (@%03d.%02d)\n",
	534	LOG((LOG_DRIVE,0," label sync bit #%d (@%03d.%02d)\n",
535	535	src, src / 32, src % 32));
536	536	src = squeeze_record(bits, src, s->label, sizeof(s->label));
537	537	src = squeeze_cksum(bits, src, &cksum_label);
r26072	r26073
543	543	src = squeeze_unsync(bits, src, 40);
544	544	/* sync on data preamble */
545	545	src = squeeze_sync(bits, src, 40);
546		LOG((0,0," data sync bit #%d (@%03d.%02d)\n",
	546	LOG((LOG_DRIVE,0," data sync bit #%d (@%03d.%02d)\n",
547	547	src, src / 32, src % 32));
548	548	src = squeeze_record(bits, src, s->data, sizeof(s->data));
549	549	src = squeeze_cksum(bits, src, &cksum_data);
r26072	r26073
558	558
559	559	if (cksum_header \|\| cksum_label \|\| cksum_data) {
560	560	#if ALTO2_DEBUG
561		LOG((0,0," cksum check - header:%06o label:%06o data:%06o\n", cksum_header, cksum_label, cksum_data));
	561	LOG((LOG_DRIVE,0," cksum check - header:%06o label:%06o data:%06o\n", cksum_header, cksum_label, cksum_data));
562	562	#else
563	563	printf(" cksum check - header:%06o label:%06o data:%06o\n", cksum_header, cksum_label, cksum_data);
564	564	#endif
r26072	r26073
834	834	d->addx_acknowledge_0 = 0;
835	835	/* clear log address interlock (?) */
836	836	d->log_addx_interlock_0 = 1;
837		LOG((0,1," UNIT select %d ready\n", unit));
	837	LOG((LOG_DRIVE,1," UNIT select %d ready\n", unit));
838	838	} else {
839	839	/* it is not ready (?) */
840	840	d->ready_0 = 1;
r26072	r26073
842	842	d->s_r_w_0 = 1;
843	843	/* address acknowledge (?) */
844	844	d->addx_acknowledge_0 = 0;
845		LOG((0,1," UNIT select %d not ready (no image)\n", unit));
	845	LOG((LOG_DRIVE,1," UNIT select %d not ready (no image)\n", unit));
846	846	}
847	847
848	848	/* Note: head select input is active low (0: selects head 1, 1: selects head 0) */
849	849	head = head & DIABLO_DRIVE_HEAD_MASK;
850	850	if (head != d->head) {
851	851	d->head = head;
852		LOG((0,1," HEAD %d select on unit %d\n", head, unit));
	852	LOG((LOG_DRIVE,1," HEAD %d select on unit %d\n", head, unit));
853	853	}
854	854	drive_get_sector(unit);
855	855	}
r26072	r26073
873	873	fatal(1, "invalid unit %d in call to drive_strobe()\n", unit);
874	874
875	875	if (strobe == 1) {
876		LOG((0,1," STROBE end of interlock\n", seekto));
	876	LOG((LOG_DRIVE,1," STROBE end of interlock\n", seekto));
877	877	/* deassert the log address interlock */
878	878	d->log_addx_interlock_0 = 1;
879	879	return;
r26072	r26073
883	883	d->log_addx_interlock_0 = 0;
884	884
885	885	if (seekto == d->cylinder) {
886		LOG((0,1," STROBE to cylinder %d acknowledge\n", seekto));
	886	LOG((LOG_DRIVE,1," STROBE to cylinder %d acknowledge\n", seekto));
887	887	d->addx_acknowledge_0 = 0; /* address acknowledge, if cylinder is reached */
888	888	d->seek_incomplete_0 = 1; /* reset seek incomplete */
889	889	return;
r26072	r26073
899	899	d->log_addx_interlock_0 = 1; /* deassert the log address interlock */
900	900	d->seek_incomplete_0 = 1; /* deassert seek incomplete */
901	901	d->addx_acknowledge_0 = 0; /* assert address acknowledge */
902		LOG((0,1," STROBE to cylinder %d incomplete\n", seekto));
	902	LOG((LOG_DRIVE,1," STROBE to cylinder %d incomplete\n", seekto));
903	903	return;
904	904	}
905	905	} else {
r26072	r26073
910	910	d->log_addx_interlock_0 = 1; /* deassert the log address interlock */
911	911	d->seek_incomplete_0 = 1; /* deassert seek incomplete */
912	912	d->addx_acknowledge_0 = 0; /* assert address acknowledge */
913		LOG((0,1," STROBE to cylinder %d incomplete\n", seekto));
	913	LOG((LOG_DRIVE,1," STROBE to cylinder %d incomplete\n", seekto));
914	914	return;
915	915	}
916	916	}
917		LOG((0,1," STROBE to cylinder %d (now %d) - interlock\n", seekto, d->cylinder));
	917	LOG((LOG_DRIVE,1," STROBE to cylinder %d (now %d) - interlock\n", seekto, d->cylinder));
918	918
919	919	d->addx_acknowledge_0 = 1; /* deassert address acknowledge */
920	920	d->seek_incomplete_0 = 1; /* deassert seek incomplete */
r26072	r26073
1017	1017	if (-1 == d->wrfirst)
1018	1018	d->wrfirst = index;
1019	1019
1020		LOG((0,7," write #%d %d/%d/%d bit #%d bit:%d\n", unit, d->cylinder, d->head, d->sector, index, wrdata));
	1020	LOG((LOG_DRIVE,7," write #%d %d/%d/%d bit #%d bit:%d\n", unit, d->cylinder, d->head, d->sector, index, wrdata));
1021	1021
1022	1022	if (index < GUARD_ZONE_BITS) {
1023	1023	/* don't write in the guard zone (?) */
r26072	r26073
1074	1074	d->rdfirst = index;
1075	1075
1076	1076	bit = RDBIT(bits,index);
1077		LOG((0,7," read #%d %d/%d/%d bit #%d:%d\n", unit, d->cylinder, d->head, d->sector, index, bit));
	1077	LOG((LOG_DRIVE,7," read #%d %d/%d/%d bit #%d:%d\n", unit, d->cylinder, d->head, d->sector, index, bit));
1078	1078	d->rdlast = index;
1079	1079	return bit;
1080	1080	}
r26072	r26073
1126	1126	clk = RDBIT(bits,index);
1127	1127	}
1128	1128
1129		LOG((0,7, " read #%d %d/%d/%d clk #%d:%d\n", unit, d->cylinder, d->head, d->sector, index, clk));
	1129	LOG((LOG_DRIVE,7, " read #%d %d/%d/%d clk #%d:%d\n", unit, d->cylinder, d->head, d->sector, index, clk));
1130	1130
1131	1131	d->rdlast = index;
1132	1132	return clk ^ 1;
r26072	r26073
1233	1233	int unit = m_unit_selected;
1234	1234	diablo_drive_t *d = m_drive[unit];
1235	1235
1236		LOG((0,5, " next sector (unit #%d sector %d)\n", unit, d->sector));
	1236	LOG((LOG_DRIVE,5, " next sector (unit #%d sector %d)\n", unit, d->sector));
1237	1237	(void)d;
1238	1238
1239	1239	switch (arg) {
r26072	r26073
1265	1265	{
1266	1266	diablo_drive_t *d = m_drive[unit];
1267	1267
1268		LOG((0,5, " sector mark 1 (unit #%d sector %d)\n", unit, d->sector));
	1268	LOG((LOG_DRIVE,5, " sector mark 1 (unit #%d sector %d)\n", unit, d->sector));
1269	1269	/* set sector mark to 1 */
1270	1270	d->sector_mark_0 = 1;
1271	1271	}
r26072	r26073
1279	1279	{
1280	1280	diablo_drive_t *d = m_drive[unit];
1281	1281
1282		LOG((0,5," sector mark 0 (unit #%d sector %d)\n", unit, d->sector));
	1282	LOG((LOG_DRIVE,5," sector mark 0 (unit #%d sector %d)\n", unit, d->sector));
1283	1283
1284	1284	/* squeeze previous sector, if it was written to */
1285	1285	squeeze_sector(unit);
r26072	r26073
1340	1340	if (!strcmp(p, ".z") \|\| !strcmp(p, ".Z") \|\|
1341	1341	!strcmp(p, ".gz") \|\| !strcmp(p, ".GZ")) {
1342	1342	/* compress (LZW) or gzip compressed image */
1343		LOG((0,0,"loading compressed disk image %s\n", arg));
	1343	LOG((LOG_DRIVE,0,"loading compressed disk image %s\n", arg));
1344	1344	zcat = 1;
1345	1345	} else if (!strcmp(p, ".dsk") \|\| !strcmp(p, ".DSK")) {
1346	1346	/* uncompressed .dsk extension */
1347		LOG((0,0,"loading uncompressed disk image %s\n", arg));
	1347	LOG((LOG_DRIVE,0,"loading uncompressed disk image %s\n", arg));
1348	1348	zcat = 0;
1349	1349	} else {
1350	1350	return -1;
r26072	r26073
1378	1378	for (done = 0; done < size * sizeof(diablo_sector_t); /* */) {
1379	1379	int got = fread(ip + done, 1, size * sizeof(diablo_sector_t) - done, fp);
1380	1380	if (got < 0) {
1381		LOG((0,0,"fread() returned error (%s)\n",
	1381	LOG((LOG_DRIVE,0,"fread() returned error (%s)\n",
1382	1382	strerror(errno)));
1383	1383	break;
1384	1384	}
r26072	r26073
1388	1388	}
1389	1389	fclose(fp);
1390	1390
1391		LOG((0,0, "got %d (%#x) bytes\n", done, done));
	1391	LOG((LOG_DRIVE,0, "got %d (%#x) bytes\n", done, done));
1392	1392
1393	1393	cooked = (diablo_sector_t *)malloc(csize);
1394	1394	if (!cooked)
r26072	r26073
1422	1422	ip = NULL;
1423	1423
1424	1424	if (csize != size * sizeof(diablo_sector_t)) {
1425		LOG((0,0,"disk image %s size mismatch (%d bytes)\n", arg, csize));
	1425	LOG((LOG_DRIVE,0,"disk image %s size mismatch (%d bytes)\n", arg, csize));
1426	1426	free(cooked);
1427	1427	return -1;
1428	1428	}
r26072	r26073
1438	1438	hdr = cooked->header[2] + 256 * cooked->header[3];
1439	1439	chs = (s << 12) \| (c << 3) \| (h << 2) \| (unit << 1);
1440	1440	if (chs != hdr) {
1441		LOG((0,0,"WARNING: header mismatch C/H/S: %3d/%d/%2d chs:%06o hdr:%06o\n",
	1441	LOG((LOG_DRIVE,0,"WARNING: header mismatch C/H/S: %3d/%d/%2d chs:%06o hdr:%06o\n",
1442	1442	c, h, s, chs, hdr));
1443	1443	}
1444	1444	if (++s == DRIVE_SPT) {
r26072	r26073
1454	1454	/* set drive image */
1455	1455	d->image = (diablo_sector_t *)cp;
1456	1456
1457		LOG((0,0,"drive #%d successfully created image for %s\n", unit, arg));
	1457	LOG((LOG_DRIVE,0,"drive #%d successfully created image for %s\n", unit, arg));
1458	1458
1459	1459	drive_select(unit, 0);
1460	1460
r26072	r26073
1463	1463	/* drive address acknowledge is active now */
1464	1464	d->addx_acknowledge_0 = 0;
1465	1465
1466		LOG((0,0,"possible %s sector size is %#o (%d) words\n", d->description, SECTOR_WORDS, SECTOR_WORDS));
	1466	LOG((LOG_DRIVE,0,"possible %s sector size is %#o (%d) words\n", d->description, SECTOR_WORDS, SECTOR_WORDS));
1467	1467
1468		LOG((0,0,"sector mark pulse length is %lldns\n", SECTOR_MARK_PULSE_PRE + SECTOR_MARK_PULSE_POST));
	1468	LOG((LOG_DRIVE,0,"sector mark pulse length is %lldns\n", SECTOR_MARK_PULSE_PRE + SECTOR_MARK_PULSE_POST));
1469	1469
1470	1470	return 0;
1471	1471	}

branches/alto2/src/emu/cpu/alto2/a2curt.c
r26072	r26073
15	15	void alto2_cpu_device::f1_curt_block_0()
16	16	{
17	17	m_task_wakeup &= ~(1 << m_task);
18		LOG((0,2," BLOCK %s\n", task_name(m_task)));
	18	LOG((LOG_CURT,2," BLOCK %s\n", task_name(m_task)));
19	19	m_dsp.curt_blocks = 1;
20	20	}
21	21
r26072	r26073
25	25	void alto2_cpu_device::f2_load_xpreg_1()
26	26	{
27	27	m_dsp.xpreg = A2_GET32(m_bus,16,6,15);
28		LOG((0,2," XPREG<- BUS[6-15] (%#o)\n", m_dsp.xpreg));
	28	LOG((LOG_CURT,2," XPREG<- BUS[6-15] (%#o)\n", m_dsp.xpreg));
29	29	}
30	30
31	31	/**
r26072	r26073
48	48	void alto2_cpu_device::f2_load_csr_1()
49	49	{
50	50	m_dsp.csr = m_bus;
51		LOG((0,2," CSR<- BUS (%#o)\n", m_dsp.csr));
	51	LOG((LOG_CURT,2," CSR<- BUS (%#o)\n", m_dsp.csr));
52	52	int x = 1023 - m_dsp.xpreg; \
53	53	m_dsp.curdata = m_dsp.csr << (16 - (x & 15)); \
54	54	m_dsp.curword = x / 16; \

branches/alto2/src/emu/cpu/alto2/a2mem.c
r26072	r26073
448	448	PUT_MESR_BANK(m_mem.mesr, (dw_addr >> 15));
449	449	/* latch memory address register */
450	450	m_mem.mear = m_mem.mar & 0177777;
451		LOG((0,5," memory error at dword addr:%07o data:%011o check:%03o\n", dw_addr * 2, dw_data, hpb));
452		LOG((0,6," MEAR: %06o\n", m_mem.mear));
453		LOG((0,6," MESR: %06o\n", m_mem.mesr ^ 0177777));
454		LOG((0,6," Hamming code read : %#o\n", GET_MESR_HAMMING(m_mem.mesr)));
455		LOG((0,6," Parity error : %o\n", GET_MESR_PERR(m_mem.mesr)));
456		LOG((0,6," Memory parity bit : %o\n", GET_MESR_PARITY(m_mem.mesr)));
457		LOG((0,6," Hamming syndrome : %#o (bit #%d)\n", GET_MESR_SYNDROME(m_mem.mesr), hamming_lut[GET_MESR_SYNDROME(m_mem.mesr)]));
458		LOG((0,6," Memory bank : %#o\n", GET_MESR_BANK(m_mem.mesr)));
459		LOG((0,6," MECR: %06o\n", m_mem.mecr ^ 0177777));
460		LOG((0,6," Test Hamming code : %#o\n", GET_MECR_TEST_CODE(m_mem.mecr)));
461		LOG((0,6," Test mode : %s\n", GET_MECR_TEST_MODE(m_mem.mecr) ? "on" : "off"));
462		LOG((0,6," INT on single-bit err: %s\n", GET_MECR_INT_SBERR(m_mem.mecr) ? "on" : "off"));
463		LOG((0,6," INT on double-bit err: %s\n", GET_MECR_INT_DBERR(m_mem.mecr) ? "on" : "off"));
464		LOG((0,6," Error correction : %s\n", GET_MECR_ERRCORR(m_mem.mecr) ? "off" : "on"));
	451	LOG((LOG_MEM,5," memory error at dword addr:%07o data:%011o check:%03o\n", dw_addr * 2, dw_data, hpb));
	452	LOG((LOG_MEM,6," MEAR: %06o\n", m_mem.mear));
	453	LOG((LOG_MEM,6," MESR: %06o\n", m_mem.mesr ^ 0177777));
	454	LOG((LOG_MEM,6," Hamming code read : %#o\n", GET_MESR_HAMMING(m_mem.mesr)));
	455	LOG((LOG_MEM,6," Parity error : %o\n", GET_MESR_PERR(m_mem.mesr)));
	456	LOG((LOG_MEM,6," Memory parity bit : %o\n", GET_MESR_PARITY(m_mem.mesr)));
	457	LOG((LOG_MEM,6," Hamming syndrome : %#o (bit #%d)\n", GET_MESR_SYNDROME(m_mem.mesr), hamming_lut[GET_MESR_SYNDROME(m_mem.mesr)]));
	458	LOG((LOG_MEM,6," Memory bank : %#o\n", GET_MESR_BANK(m_mem.mesr)));
	459	LOG((LOG_MEM,6," MECR: %06o\n", m_mem.mecr ^ 0177777));
	460	LOG((LOG_MEM,6," Test Hamming code : %#o\n", GET_MECR_TEST_CODE(m_mem.mecr)));
	461	LOG((LOG_MEM,6," Test mode : %s\n", GET_MECR_TEST_MODE(m_mem.mecr) ? "on" : "off"));
	462	LOG((LOG_MEM,6," INT on single-bit err: %s\n", GET_MECR_INT_SBERR(m_mem.mecr) ? "on" : "off"));
	463	LOG((LOG_MEM,6," INT on double-bit err: %s\n", GET_MECR_INT_DBERR(m_mem.mecr) ? "on" : "off"));
	464	LOG((LOG_MEM,6," Error correction : %s\n", GET_MECR_ERRCORR(m_mem.mecr) ? "off" : "on"));
465	465	}
466	466	if (-1 == hamming_lut[syndrome]) {
467	467	/* double-bit error: wake task_part, if we're told so */
r26072	r26073
473	473	m_task_wakeup \|= 1 << task_part;
474	474	/* should we correct the single bit error ? */
475	475	if (0 == GET_MECR_ERRCORR(m_mem.mecr)) {
476		LOG((0,0," correct bit #%d addr:%07o data:%011o check:%03o\n", hamming_lut[syndrome], dw_addr * 2, dw_data, hpb));
	476	LOG((LOG_MEM,0," correct bit #%d addr:%07o data:%011o check:%03o\n", hamming_lut[syndrome], dw_addr * 2, dw_data, hpb));
477	477	dw_data ^= 1ul << hamming_lut[syndrome];
478	478	}
479	479	}
r26072	r26073
490	490	*/
491	491	UINT16 alto2_cpu_device::bad_mmio_read_fn(UINT32 address)
492	492	{
493		LOG((0,1," stray I/O read of address %#o\n", address));
	493	LOG((LOG_MEM,1," stray I/O read of address %#o\n", address));
494	494	(void)address;
495	495	return 0177777;
496	496	}
r26072	r26073
503	503	*/
504	504	void alto2_cpu_device::bad_mmio_write_fn(UINT32 address, UINT16 data)
505	505	{
506		LOG((0,1," stray I/O write of address %06o, data %#o\n", address, data));
	506	LOG((LOG_MEM,1," stray I/O write of address %06o, data %#o\n", address, data));
507	507	(void)address;
508	508	(void)data;
509	509	}
r26072	r26073
520	520	UINT16 alto2_cpu_device::mear_r(UINT32 address)
521	521	{
522	522	int data = m_mem.error ? m_mem.mear : m_mem.mar;
523		LOG((0,2," MEAR read %07o\n", data));
	523	LOG((LOG_MEM,2," MEAR read %07o\n", data));
524	524	return data;
525	525	}
526	526
r26072	r26073
544	544	{
545	545	UINT16 data = m_mem.mesr ^ 0177777;
546	546	(void)address;
547		LOG((0,2," MESR read %07o\n", data));
548		LOG((0,6," Hamming code read : %#o\n", GET_MESR_HAMMING(data)));
549		LOG((0,6," Parity error : %o\n", GET_MESR_PERR(data)));
550		LOG((0,6," Memory parity bit : %o\n", GET_MESR_PARITY(data)));
	547	LOG((LOG_MEM,2," MESR read %07o\n", data));
	548	LOG((LOG_MEM,6," Hamming code read : %#o\n", GET_MESR_HAMMING(data)));
	549	LOG((LOG_MEM,6," Parity error : %o\n", GET_MESR_PERR(data)));
	550	LOG((LOG_MEM,6," Memory parity bit : %o\n", GET_MESR_PARITY(data)));
551	551	#if ALTO2_HAMMING_CHECK
552		LOG((0,6," Hamming syndrome : %#o (bit #%d)\n", GET_MESR_SYNDROME(data), hamming_lut[GET_MESR_SYNDROME(data)]));
	552	LOG((LOG_MEM,6," Hamming syndrome : %#o (bit #%d)\n", GET_MESR_SYNDROME(data), hamming_lut[GET_MESR_SYNDROME(data)]));
553	553	#else
554		LOG((0,6," Hamming syndrome : %#o\n", GET_MESR_SYNDROME(data)));
	554	LOG((LOG_MEM,6," Hamming syndrome : %#o\n", GET_MESR_SYNDROME(data)));
555	555	#endif
556		LOG((0,6," Memory bank : %#o\n", GET_MESR_BANK(data)));
	556	LOG((LOG_MEM,6," Memory bank : %#o\n", GET_MESR_BANK(data)));
557	557	return data;
558	558	}
559	559
560	560	void alto2_cpu_device::mesr_w(UINT32 address, UINT16 data)
561	561	{
562		LOG((0,2," MESR write %07o (clear MESR; was %07o)\n", data, m_mem.mesr));
	562	LOG((LOG_MEM,2," MESR write %07o (clear MESR; was %07o)\n", data, m_mem.mesr));
563	563	m_mem.mesr = 0; // set all bits to 0
564	564	m_mem.error = 0; // reset the error flag
565	565	m_task_wakeup &= ~(1 << task_part); // clear the task wakeup for the parity error task
r26072	r26073
592	592	(void)address;
593	593	A2_PUT16(m_mem.mecr,16, 0, 3,0);
594	594	A2_PUT16(m_mem.mecr,16,15,15,0);
595		LOG((0,2," MECR write %07o\n", data));
596		LOG((0,6," Test Hamming code : %#o\n", GET_MECR_TEST_CODE(m_mem.mecr)));
597		LOG((0,6," Test mode : %s\n", GET_MECR_TEST_MODE(m_mem.mecr) ? "on" : "off"));
598		LOG((0,6," INT on single-bit err: %s\n", GET_MECR_INT_SBERR(m_mem.mecr) ? "on" : "off"));
599		LOG((0,6," INT on double-bit err: %s\n", GET_MECR_INT_DBERR(m_mem.mecr) ? "on" : "off"));
600		LOG((0,6," Error correction : %s\n", GET_MECR_ERRCORR(m_mem.mecr) ? "off" : "on"));
	595	LOG((LOG_MEM,2," MECR write %07o\n", data));
	596	LOG((LOG_MEM,6," Test Hamming code : %#o\n", GET_MECR_TEST_CODE(m_mem.mecr)));
	597	LOG((LOG_MEM,6," Test mode : %s\n", GET_MECR_TEST_MODE(m_mem.mecr) ? "on" : "off"));
	598	LOG((LOG_MEM,6," INT on single-bit err: %s\n", GET_MECR_INT_SBERR(m_mem.mecr) ? "on" : "off"));
	599	LOG((LOG_MEM,6," INT on double-bit err: %s\n", GET_MECR_INT_DBERR(m_mem.mecr) ? "on" : "off"));
	600	LOG((LOG_MEM,6," Error correction : %s\n", GET_MECR_ERRCORR(m_mem.mecr) ? "off" : "on"));
601	601	}
602	602
603	603	/**
r26072	r26073
607	607	{
608	608	UINT16 data = m_mem.mecr ^ 0177777;
609	609	/* set all spare bits */
610		LOG((0,2," MECR read %07o\n", data));
611		LOG((0,6," Test Hamming code : %#o\n", GET_MECR_TEST_CODE(data)));
612		LOG((0,6," Test mode : %s\n", GET_MECR_TEST_MODE(data) ? "on" : "off"));
613		LOG((0,6," INT on single-bit err: %s\n", GET_MECR_INT_SBERR(data) ? "on" : "off"));
614		LOG((0,6," INT on double-bit err: %s\n", GET_MECR_INT_DBERR(data) ? "on" : "off"));
615		LOG((0,6," Error correction : %s\n", GET_MECR_ERRCORR(data) ? "off" : "on"));
	610	LOG((LOG_MEM,2," MECR read %07o\n", data));
	611	LOG((LOG_MEM,6," Test Hamming code : %#o\n", GET_MECR_TEST_CODE(data)));
	612	LOG((LOG_MEM,6," Test mode : %s\n", GET_MECR_TEST_MODE(data) ? "on" : "off"));
	613	LOG((LOG_MEM,6," INT on single-bit err: %s\n", GET_MECR_INT_SBERR(data) ? "on" : "off"));
	614	LOG((LOG_MEM,6," INT on double-bit err: %s\n", GET_MECR_INT_DBERR(data) ? "on" : "off"));
	615	LOG((LOG_MEM,6," Error correction : %s\n", GET_MECR_ERRCORR(data) ? "off" : "on"));
616	616	return data;
617	617	}
618	618
r26072	r26073
629	629	* starting a memory refresh cycle
630	630	* currently we don't do anything special
631	631	*/
632		LOG((0,5, " MAR<-; refresh cycle @ %#o\n", addr));
	632	LOG((LOG_MEM,5, " MAR<-; refresh cycle @ %#o\n", addr));
633	633	} else if (addr < ALTO2_RAM_SIZE) {
634		LOG((0,2, " MAR<-; mar = %#o\n", addr));
	634	LOG((LOG_MEM,2, " MAR<-; mar = %#o\n", addr));
635	635	m_mem.access = ALTO2_MEM_RAM;
636	636	m_mem.mar = addr;
637	637	/* fetch memory double-word to read/write latches */
r26072	r26073
654	654	UINT32 base_addr;
655	655
656	656	if (ALTO2_MEM_NONE == m_mem.access) {
657		LOG((0,0," fatal: mem read with no preceding address\n"));
	657	LOG((LOG_MEM,0," fatal: mem read with no preceding address\n"));
658	658	return 0177777;
659	659	}
660	660
661	661	if (cycle() > m_mem.cycle + 4) {
662		LOG((0,0," fatal: mem read (MAR %#o) too late (+%lld cyc)\n", m_mem.mar, cycle() - m_mem.cycle));
	662	LOG((LOG_MEM,0," fatal: mem read (MAR %#o) too late (+%lld cyc)\n", m_mem.mar, cycle() - m_mem.cycle));
663	663	m_mem.access = ALTO2_MEM_NONE;
664	664	return 0177777;
665	665	}
r26072	r26073
667	667	base_addr = m_mem.mar & 0177777;
668	668	if (base_addr >= ALTO2_IO_PAGE_BASE) {
669	669	m_mem.md = ((this).mmio_read_fn[base_addr - ALTO2_IO_PAGE_BASE])(base_addr);
670		LOG((0,6," MD = MMIO[%#o] (%#o)\n", base_addr, m_mem.md));
	670	LOG((LOG_MEM,6," MD = MMIO[%#o] (%#o)\n", base_addr, m_mem.md));
671	671	m_mem.access = ALTO2_MEM_NONE;
672	672	#if ALTO2_DEBUG
673	673	watch_read(m_mem.mar, m_mem.md);
r26072	r26073
681	681	m_mem.rmdd = hamming_code(0, m_mem.mar/2, m_mem.rmdd);
682	682	#endif
683	683	m_mem.md = (m_mem.mar & ALTO2_MEM_ODD) ? GET_ODD(m_mem.rmdd) : GET_EVEN(m_mem.rmdd);
684		LOG((0,6," MD = RAM[%#o] (%#o)\n", m_mem.mar, m_mem.md));
	684	LOG((LOG_MEM,6," MD = RAM[%#o] (%#o)\n", m_mem.mar, m_mem.md));
685	685
686	686	#if ALTO2_DEBUG
687	687	watch_read(m_mem.mar, m_mem.md);
r26072	r26073
708	708
709	709	m_mem.md = data & 0177777;
710	710	if (ALTO2_MEM_NONE == m_mem.access) {
711		LOG((0,0," fatal: mem write with no preceding address\n"));
	711	LOG((LOG_MEM,0," fatal: mem write with no preceding address\n"));
712	712	return;
713	713	}
714	714
715	715	if (cycle() > m_mem.cycle + 4) {
716		LOG((0,0," fatal: mem write (MAR %#o, data %#o) too late (+%lld cyc)\n", m_mem.mar, data, cycle() - m_mem.cycle));
	716	LOG((LOG_MEM,0," fatal: mem write (MAR %#o, data %#o) too late (+%lld cyc)\n", m_mem.mar, data, cycle() - m_mem.cycle));
717	717	m_mem.access = ALTO2_MEM_NONE;
718	718	return;
719	719	}
720	720
721	721	base_addr = m_mem.mar & 0177777;
722	722	if (base_addr >= ALTO2_IO_PAGE_BASE) {
723		LOG((0,6, " MMIO[%#o] = MD (%#o)\n", base_addr, m_mem.md));
	723	LOG((LOG_MEM,6, " MMIO[%#o] = MD (%#o)\n", base_addr, m_mem.md));
724	724	((this).mmio_write_fn[base_addr - ALTO2_IO_PAGE_BASE])(base_addr, m_mem.md);
725	725	m_mem.access = ALTO2_MEM_NONE;
726	726	#if ALTO2_DEBUG
r26072	r26073
729	729	return;
730	730	}
731	731
732		LOG((0,6, " RAM[%#o] = MD (%#o)\n", m_mem.mar, m_mem.md));
	732	LOG((LOG_MEM,6, " RAM[%#o] = MD (%#o)\n", m_mem.mar, m_mem.md));
733	733	if (m_mem.mar & ALTO2_MEM_ODD)
734	734	PUT_ODD(m_mem.wmdd, m_mem.md);
735	735	else

branches/alto2/src/emu/cpu/alto2/a2dht.c
r26072	r26073
17	17	m_dsp.dht_blocks = 1;
18	18	/* clear the wakeup for the display horizontal task */
19	19	m_task_wakeup &= ~(1 << m_task);
20		LOG((0,2," BLOCK %s\n", task_name(m_task)));
	20	LOG((LOG_DHT,2," BLOCK %s\n", task_name(m_task)));
21	21	}
22	22
23	23	/**
r26072	r26073
32	32	{
33	33	UINT16 r = A2_GET32(m_bus,16,0,0);
34	34	m_dsp.setmode = m_bus;
35		LOG((0,2," SETMODE<- BUS (%#o), branch on BUS[0] (%#o \| %#o)\n", m_bus, m_next2, r));
	35	LOG((LOG_DHT,2," SETMODE<- BUS (%#o), branch on BUS[0] (%#o \| %#o)\n", m_bus, m_next2, r));
36	36	m_next2 \|= r;
37	37	}
38	38

branches/alto2/src/emu/cpu/alto2/a2ram.c
r26072	r26073
23	23	if (reg) {
24	24	UINT8 bank = m_s_reg_bank[m_task];
25	25	r = m_s[bank][reg];
26		LOG((0,2," <-S%02o; bus &= S[%o][%02o] (%#o)\n", reg, bank, reg, r));
	26	LOG((LOG_RAM,2," <-S%02o; bus &= S[%o][%02o] (%#o)\n", reg, bank, reg, r));
27	27	} else {
28	28	r = m_m;
29		LOG((0,2," <-S%02o; bus &= M (%#o)\n", reg, r));
	29	LOG((LOG_RAM,2," <-S%02o; bus &= M (%#o)\n", reg, r));
30	30	}
31	31	m_bus &= r;
32	32	}
r26072	r26073
37	37	void alto2_cpu_device::bs_load_sreg_0()
38	38	{
39	39	int r = 0; /* ??? */
40		LOG((0,2," S%02o<- BUS &= garbage (%#o)\n", MIR_RSEL(m_mir), r));
	40	LOG((LOG_RAM,2," S%02o<- BUS &= garbage (%#o)\n", MIR_RSEL(m_mir), r));
41	41	m_bus &= r;
42	42	}
43	43
r26072	r26073
49	49	UINT8 reg = MIR_RSEL(m_mir);
50	50	UINT8 bank = m_s_reg_bank[m_task];
51	51	m_s[bank][reg] = m_m;
52		LOG((0,2," S%02o<- S[%o][%02o] := %#o\n", reg, bank, reg, m_m));
	52	LOG((LOG_RAM,2," S%02o<- S[%o][%02o] := %#o\n", reg, bank, reg, m_m));
53	53	}
54	54
55	55	/**
r26072	r26073
59	59	{
60	60	(void)from;
61	61	m_next2 = (m_next2 & ALTO2_UCODE_PAGE_MASK) + page * ALTO2_UCODE_PAGE_SIZE;
62		LOG((0,2," SWMODE: branch from %s to ROM%d (%#o)\n", from, page, m_next2));
	62	LOG((LOG_RAM,2," SWMODE: branch from %s to ROM%d (%#o)\n", from, page, m_next2));
63	63	}
64	64
65	65	/**
r26072	r26073
69	69	{
70	70	(void)from;
71	71	m_next2 = (m_next2 & ALTO2_UCODE_PAGE_MASK) + ALTO2_UCODE_RAM_BASE + page * ALTO2_UCODE_PAGE_SIZE;
72		LOG((0,2," SWMODE: branch from %s to RAM%d\n", from, page, m_next2));
	72	LOG((LOG_RAM,2," SWMODE: branch from %s to RAM%d\n", from, page, m_next2));
73	73	}
74	74
75	75	/**
r26072	r26073
235	235	void alto2_cpu_device::f1_wrtram_1()
236	236	{
237	237	m_wrtram_flag = 1;
238		LOG((0,2," WRTRAM\n"));
	238	LOG((LOG_RAM,2," WRTRAM\n"));
239	239	}
240	240
241	241	/**
r26072	r26073
244	244	void alto2_cpu_device::f1_rdram_1()
245	245	{
246	246	m_rdram_flag = 1;
247		LOG((0,2," RDRAM\n"));
	247	LOG((LOG_RAM,2," RDRAM\n"));
248	248	}
249	249
250	250	#if (ALTO2_UCODE_RAM_PAGES == 3)
r26072	r26073
258	258	*/
259	259	void alto2_cpu_device::f1_load_rmr_1()
260	260	{
261		LOG((0,2," RMR<-; BUS (%#o)\n", m_bus));
	261	LOG((LOG_RAM,2," RMR<-; BUS (%#o)\n", m_bus));
262	262	m_reset_mode = m_bus;
263	263	}
264	264	#else // ALTO2_UCODE_RAM_PAGES != 3
r26072	r26073
268	268	void alto2_cpu_device::f1_load_srb_1()
269	269	{
270	270	m_s_reg_bank[m_task] = A2_GET16(m_bus,16,12,14) % ALTO2_SREG_BANKS;
271		LOG((0,2," SRB<-; srb[%d] := %#o\n", m_task, m_s_reg_bank[m_task]));
	271	LOG((LOG_RAM,2," SRB<-; srb[%d] := %#o\n", m_task, m_s_reg_bank[m_task]));
272	272	}
273	273	#endif
274	274

branches/alto2/src/emu/cpu/alto2/a2kwd.c
r26072	r26073
12	12	//! f1_kwd_block early: block the disk word task
13	13	void alto2_cpu_device::f1_kwd_block_0()
14	14	{
15		LOG((0,2," BLOCK %s\n", task_name(m_task)));
	15	LOG((LOG_KWD,2," BLOCK %s\n", task_name(m_task)));
16	16	disk_block(m_task);
17	17	}
18	18

branches/alto2/src/emu/cpu/alto2/a2ksec.c
r26072	r26073
12	12	/** @brief block the disk sector task */
13	13	void alto2_cpu_device::f1_ksec_block_0()
14	14	{
15		LOG((0,2," BLOCK %s\n", task_name(m_task)));
	15	LOG((LOG_KSEC,2," BLOCK %s\n", task_name(m_task)));
16	16	disk_block(m_task);
17	17	}
18	18

branches/alto2/src/emu/cpu/alto2/a2emu.c
r26072	r26073
268	268	if (IR_X(m_emu.ir)) {
269	269	r = ((signed char)r) & 0177777;
270	270	}
271		LOG((0,2, " <-DISP (%06o)\n", r));
	271	LOG((LOG_EMU,2, " <-DISP (%06o)\n", r));
272	272	m_bus &= r;
273	273	}
274	274
r26072	r26073
281	281	{
282	282	#if 0
283	283	CPU_CLR_TASK_WAKEUP(m_task);
284		LOG((0,2, " BLOCK %02o:%s\n", m_task, task_name(m_task)));
	284	LOG((LOG_EMU,2, " BLOCK %02o:%s\n", m_task, task_name(m_task)));
285	285	#elif 0
286	286	fatal(1, "Emulator task want's to BLOCK.\n" \
287	287	"%s-%04o: r:%02o af:%02o bs:%02o f1:%02o f2:%02o" \
r26072	r26073
302	302	*/
303	303	void alto2_cpu_device::f1_emu_load_rmr_1()
304	304	{
305		LOG((0,2," RMR<-; BUS (%#o)\n", m_bus));
	305	LOG((LOG_EMU,2," RMR<-; BUS (%#o)\n", m_bus));
306	306	m_reset_mode = m_bus;
307	307	}
308	308
r26072	r26073
311	311	*/
312	312	void alto2_cpu_device::f1_emu_load_esrb_1()
313	313	{
314		LOG((0,2," ESRB<-; BUS[12-14] (%#o)\n", m_bus));
	314	LOG((LOG_EMU,2," ESRB<-; BUS[12-14] (%#o)\n", m_bus));
315	315	m_s_reg_bank[m_task] = A2_GET32(m_bus,16,12,14);
316	316	}
317	317
r26072	r26073
324	324	void alto2_cpu_device::f1_rsnf_0()
325	325	{
326	326	UINT16 r = 0177400 \| m_ether_id;
327		LOG((0,2," <-RSNF; (%#o)\n", r));
	327	LOG((LOG_EMU,2," <-RSNF; (%#o)\n", r));
328	328	m_bus &= r;
329	329	}
330	330
r26072	r26073
357	357	*/
358	358	void alto2_cpu_device::f1_startf_0()
359	359	{
360		LOG((0,2," STARTF (BUS is %06o)\n", m_bus));
	360	LOG((LOG_EMU,2," STARTF (BUS is %06o)\n", m_bus));
361	361	/* TODO: what do we do here? reset the CPU on bit 0? */
362	362	if (A2_BIT32(m_bus,16,0)) {
363		LOG((0,2,"**** Software boot feature\n"));
	363	LOG((LOG_EMU,2,"**** Software boot feature\n"));
364	364	soft_reset();
365	365	} else {
366	366	eth_startf();
r26072	r26073
373	373	void alto2_cpu_device::f2_busodd_1()
374	374	{
375	375	UINT16 r = m_bus & 1;
376		LOG((0,2," BUSODD; %sbranch (%#o\|%#o)\n", r ? "" : "no ", m_next2, r));
	376	LOG((LOG_EMU,2," BUSODD; %sbranch (%#o\|%#o)\n", r ? "" : "no ", m_next2, r));
377	377	m_next2 \|= r;
378	378	}
379	379
r26072	r26073
389	389	XC = (m_t >> 15) & 1;
390	390	m_shifter = (m_l << 1) & 0177777;
391	391	m_shifter \|= XC;
392		LOG((0,2," <-L MLSH 1 (shifer:%06o XC:%o)", m_shifter, XC));
	392	LOG((LOG_EMU,2," <-L MLSH 1 (shifer:%06o XC:%o)", m_shifter, XC));
393	393	break;
394	394	case f1_l_rsh_1: // <-L MRSH 1
395	395	XC = m_t & 1;
396	396	m_shifter = m_l >> 1;
397	397	m_shifter \|= XC << 15;
398		LOG((0,2," <-L MRSH 1 (shifter:%06o XC:%o)", m_shifter, XC));
	398	LOG((LOG_EMU,2," <-L MRSH 1 (shifter:%06o XC:%o)", m_shifter, XC));
399	399	break;
400	400	case f1_l_lcy_8: // <-L LCY 8
401	401	default: // other
r26072	r26073
415	415	#else
416	416	A2_PUT8(m_rsel, 5, 3, 4, IR_DstAC(m_emu.ir) ^ 3);
417	417	#endif
418		LOG((0,2," DNS<-; rsel := DstAC (%#o %s)\n", m_rsel, r_name(m_rsel)));
	418	LOG((LOG_EMU,2," DNS<-; rsel := DstAC (%#o %s)\n", m_rsel, r_name(m_rsel)));
419	419	}
420	420
421	421	/**
r26072	r26073
469	469	case f1_l_rsh_1: // <-L RSH 1
470	470	NEWCARRY = m_l & 1;
471	471	m_shifter = ((m_l >> 1) \| (XC << 15)) & 0177777;
472		LOG((0,2," DNS; <-L RSH 1 (shifter:%06o XC:%o NEWCARRY:%o)", m_shifter, XC, NEWCARRY));
	472	LOG((LOG_EMU,2," DNS; <-L RSH 1 (shifter:%06o XC:%o NEWCARRY:%o)", m_shifter, XC, NEWCARRY));
473	473	break;
474	474	case f1_l_lsh_1: // <-L LSH 1
475	475	NEWCARRY = (m_l >> 15) & 1;
476	476	m_shifter = ((m_l << 1) \| XC) & 0177777;
477		LOG((0,2," DNS; <-L LSH 1 (shifter:%06o XC:%o NEWCARRY:%o)", m_shifter, XC, NEWCARRY));
	477	LOG((LOG_EMU,2," DNS; <-L LSH 1 (shifter:%06o XC:%o NEWCARRY:%o)", m_shifter, XC, NEWCARRY));
478	478	break;
479	479	case f1_l_lcy_8: // <-L LCY 8
480	480	default: /* other */
481	481	NEWCARRY = XC;
482		LOG((0,2," DNS; (shifter:%06o NEWCARRY:%o)", m_shifter, NEWCARRY));
	482	LOG((LOG_EMU,2," DNS; (shifter:%06o NEWCARRY:%o)", m_shifter, NEWCARRY));
483	483	break;
484	484	}
485	485	SHZERO = (m_shifter == 0);
r26072	r26073
506	506	#else
507	507	A2_PUT8(m_rsel, 5, 3, 4, IR_DstAC(m_emu.ir) ^ 3);
508	508	#endif
509		LOG((0,2," ACDEST<-; mux (rsel:%#o %s)\n", m_rsel, r_name(m_rsel)));
	509	LOG((LOG_EMU,2," ACDEST<-; mux (rsel:%#o %s)\n", m_rsel, r_name(m_rsel)));
510	510	}
511	511
512	512	#if ALTO2_DEBUG
r26072	r26073
517	517	int bbt = m_r[rsel_ac2];
518	518	int val = debug_read_mem(bbt);
519	519
520		LOG((0,3," BITBLT AC1:%06o AC2:%06o\n", m_r[rsel_ac1], m_r[rsel_ac2]));
521		LOG((0,3," function : %06o\n", val));
522		LOG((0,3," src extRAM: %o\n", A2_BIT16(val,16,10)));
523		LOG((0,3," dst extRAM: %o\n", A2_BIT16(val,16,11)));
524		LOG((0,3," src type : %o (%s)\n", A2_GET16(val,16,12,13), type_name[A2_GET16(val,16,12,13)]));
525		LOG((0,3," operation : %o (%s)\n", A2_GET16(val,16,14,15), oper_name[A2_GET16(val,16,14,15)]));
	520	LOG((LOG_EMU,3," BITBLT AC1:%06o AC2:%06o\n", m_r[rsel_ac1], m_r[rsel_ac2]));
	521	LOG((LOG_EMU,3," function : %06o\n", val));
	522	LOG((LOG_EMU,3," src extRAM: %o\n", A2_BIT16(val,16,10)));
	523	LOG((LOG_EMU,3," dst extRAM: %o\n", A2_BIT16(val,16,11)));
	524	LOG((LOG_EMU,3," src type : %o (%s)\n", A2_GET16(val,16,12,13), type_name[A2_GET16(val,16,12,13)]));
	525	LOG((LOG_EMU,3," operation : %o (%s)\n", A2_GET16(val,16,14,15), oper_name[A2_GET16(val,16,14,15)]));
526	526	val = debug_read_mem(bbt+1);
527		LOG((0,3," unused AC2: %06o (%d)\n", val, val));
	527	LOG((LOG_EMU,3," unused AC2: %06o (%d)\n", val, val));
528	528	val = debug_read_mem(bbt+2);
529		LOG((0,3," DBCA : %06o (%d)\n", val, val));
	529	LOG((LOG_EMU,3," DBCA : %06o (%d)\n", val, val));
530	530	val = debug_read_mem(bbt+3);
531		LOG((0,3," DBMR : %06o (%d words)\n", val, val));
	531	LOG((LOG_EMU,3," DBMR : %06o (%d words)\n", val, val));
532	532	val = debug_read_mem(bbt+4);
533		LOG((0,3," DLX : %06o (%d bits)\n", val, val));
	533	LOG((LOG_EMU,3," DLX : %06o (%d bits)\n", val, val));
534	534	val = debug_read_mem(bbt+5);
535		LOG((0,3," DTY : %06o (%d scanlines)\n", val, val));
	535	LOG((LOG_EMU,3," DTY : %06o (%d scanlines)\n", val, val));
536	536	val = debug_read_mem(bbt+6);
537		LOG((0,3," DW : %06o (%d bits)\n", val, val));
	537	LOG((LOG_EMU,3," DW : %06o (%d bits)\n", val, val));
538	538	val = debug_read_mem(bbt+7);
539		LOG((0,3," DH : %06o (%d scanlines)\n", val, val));
	539	LOG((LOG_EMU,3," DH : %06o (%d scanlines)\n", val, val));
540	540	val = debug_read_mem(bbt+8);
541		LOG((0,3," SBCA : %06o (%d)\n", val, val));
	541	LOG((LOG_EMU,3," SBCA : %06o (%d)\n", val, val));
542	542	val = debug_read_mem(bbt+9);
543		LOG((0,3," SBMR : %06o (%d words)\n", val, val));
	543	LOG((LOG_EMU,3," SBMR : %06o (%d words)\n", val, val));
544	544	val = debug_read_mem(bbt+10);
545		LOG((0,3," SLX : %06o (%d bits)\n", val, val));
	545	LOG((LOG_EMU,3," SLX : %06o (%d bits)\n", val, val));
546	546	val = debug_read_mem(bbt+11);
547		LOG((0,3," STY : %06o (%d scanlines)\n", val, val));
548		LOG((0,3," GRAY0-3 : %06o %06o %06o %06o\n",
	547	LOG((LOG_EMU,3," STY : %06o (%d scanlines)\n", val, val));
	548	LOG((LOG_EMU,3," GRAY0-3 : %06o %06o %06o %06o\n",
549	549	debug_read_mem(bbt+12), debug_read_mem(bbt+13),
550	550	debug_read_mem(bbt+14), debug_read_mem(bbt+15)));
551	551	}
r26072	r26073
563	563	/* special logging of some opcodes */
564	564	switch (m_bus) {
565	565	case op_CYCLE:
566		LOG((0,3," CYCLE AC0:#o\n", m_r[rsel_ac0]));
	566	LOG((LOG_EMU,3," CYCLE AC0:#o\n", m_r[rsel_ac0]));
567	567	break;
568	568	case op_CYCLE + 1: case op_CYCLE + 2: case op_CYCLE + 3: case op_CYCLE + 4:
569	569	case op_CYCLE + 5: case op_CYCLE + 6: case op_CYCLE + 7: case op_CYCLE + 8:
570	570	case op_CYCLE + 9: case op_CYCLE +10: case op_CYCLE +11: case op_CYCLE +12:
571	571	case op_CYCLE +13: case op_CYCLE +14: case op_CYCLE +15:
572		LOG((0,3," CYCLE %#o\n", m_bus - op_CYCLE));
	572	LOG((LOG_EMU,3," CYCLE %#o\n", m_bus - op_CYCLE));
573	573	break;
574	574	case op_BLT:
575		LOG((0,3," BLT dst:%#o src:%#o size:%#o\n",
	575	LOG((LOG_EMU,3," BLT dst:%#o src:%#o size:%#o\n",
576	576	(m_r[rsel_ac1] + m_r[rsel_ac3] + 1) & 0177777,
577	577	(m_r[rsel_ac0] + 1) & 017777, -m_r[rsel_ac3] & 0177777));
578	578	break;
579	579	case op_BLKS:
580		LOG((0,3," BLKS dst:%#o val:%#o size:%#o\n",
	580	LOG((LOG_EMU,3," BLKS dst:%#o val:%#o size:%#o\n",
581	581	(m_r[rsel_ac1] + m_r[rsel_ac3] + 1) & 0177777,
582	582	m_r[rsel_ac0], -m_r[rsel_ac3] & 0177777));
583	583	break;
584	584	case op_DIAGNOSE1:
585		LOG((0,3," DIAGNOSE1 AC0:%06o AC1:%06o AC2:%06o AC3:%06o\n",
	585	LOG((LOG_EMU,3," DIAGNOSE1 AC0:%06o AC1:%06o AC2:%06o AC3:%06o\n",
586	586	m_r[rsel_ac0], m_r[rsel_ac1],
587	587	m_r[rsel_ac2], m_r[rsel_ac3]));
588	588	break;
589	589	case op_DIAGNOSE2:
590		LOG((0,3," DIAGNOSE2 AC0:%06o AC1:%06o AC2:%06o AC3:%06o\n",
	590	LOG((LOG_EMU,3," DIAGNOSE2 AC0:%06o AC1:%06o AC2:%06o AC3:%06o\n",
591	591	m_r[rsel_ac0], m_r[rsel_ac1],
592	592	m_r[rsel_ac2], m_r[rsel_ac3]));
593	593	break;
r26072	r26073
597	597	#endif
598	598	break;
599	599	case op_RDRAM:
600		LOG((0,3," RDRAM addr:%#o\n", m_r[rsel_ac1]));
	600	LOG((LOG_EMU,3," RDRAM addr:%#o\n", m_r[rsel_ac1]));
601	601	break;
602	602	case op_WRTRAM:
603		LOG((0,3," WRTAM addr:%#o upper:%06o lower:%06o\n", m_r[rsel_ac1], m_r[rsel_ac0], m_r[rsel_ac3]));
	603	LOG((LOG_EMU,3," WRTAM addr:%#o upper:%06o lower:%06o\n", m_r[rsel_ac1], m_r[rsel_ac0], m_r[rsel_ac3]));
604	604	break;
605	605	case op_JMPRAM:
606		LOG((0,3," JMPRAM addr:%#o\n", m_r[rsel_ac1]));
	606	LOG((LOG_EMU,3," JMPRAM addr:%#o\n", m_r[rsel_ac1]));
607	607	break;
608	608	case op_XMLDA:
609		LOG((0,3," XMLDA AC0 = [bank:%o AC1:#o]\n", m_bank_reg[m_task] & 3, m_r[rsel_ac1]));
	609	LOG((LOG_EMU,3," XMLDA AC0 = [bank:%o AC1:#o]\n", m_bank_reg[m_task] & 3, m_r[rsel_ac1]));
610	610	break;
611	611	case op_XMSTA:
612		LOG((0,3," XMSTA [bank:%o AC1:#o] = AC0 (%#o)\n", m_bank_reg[m_task] & 3, m_r[rsel_ac1], m_r[rsel_ac0]));
	612	LOG((LOG_EMU,3," XMSTA [bank:%o AC1:#o] = AC0 (%#o)\n", m_bank_reg[m_task] & 3, m_r[rsel_ac1], m_r[rsel_ac0]));
613	613	break;
614	614	}
615	615	m_emu.ir = m_bus;
r26072	r26073
628	628	if (IR_ARITH(m_emu.ir)) {
629	629	/* 1xxxxxxxxxxxxxxx */
630	630	r = IR_SH(m_emu.ir) ^ 3; /* complement of SH */
631		LOG((0,2," IDISP<-; branch on SH^3 (%#o\|%#o)\n", m_next2, r));
	631	LOG((LOG_EMU,2," IDISP<-; branch on SH^3 (%#o\|%#o)\n", m_next2, r));
632	632	} else {
633	633	int addr = CTL2K_U3(f2_emu_idisp) + A2_GET32(m_emu.ir,16,1,7);
634	634	/* 0???????xxxxxxxx */
635	635	r = m_ctl2k_u3[addr];
636		LOG((0,2," IDISP<-; IR (%#o) branch on PROM ctl2k_u3[%03o] (%#o\|%#o)\n", m_emu.ir, addr, m_next2, r));
	636	LOG((LOG_EMU,2," IDISP<-; IR (%#o) branch on PROM ctl2k_u3[%03o] (%#o\|%#o)\n", m_emu.ir, addr, m_next2, r));
637	637	}
638	638	m_next2 \|= r;
639	639	}
r26072	r26073
649	649	#else
650	650	A2_PUT8(m_rsel, 5, 3, 4, IR_SrcAC(m_emu.ir) ^ 3);
651	651	#endif
652		LOG((0,2," <-ACSOURCE; rsel := SrcAC (%#o %s)\n", m_rsel, r_name(m_rsel)));
	652	LOG((LOG_EMU,2," <-ACSOURCE; rsel := SrcAC (%#o %s)\n", m_rsel, r_name(m_rsel)));
653	653	}
654	654
655	655	/**
r26072	r26073
662	662	if (IR_ARITH(m_emu.ir)) {
663	663	/* 1xxxxxxxxxxxxxxx */
664	664	r = IR_SH(m_emu.ir) ^ 3; /* complement of SH */
665		LOG((0,2," <-ACSOURCE; branch on SH^3 (%#o\|%#o)\n", m_next2, r));
	665	LOG((LOG_EMU,2," <-ACSOURCE; branch on SH^3 (%#o\|%#o)\n", m_next2, r));
666	666	} else {
667	667	int addr = CTL2K_U3(f2_emu_acsource) + A2_GET32(m_emu.ir,16,1,7);
668	668	/* 0???????xxxxxxxx */
669	669	r = m_ctl2k_u3[addr];
670		LOG((0,2," <-ACSOURCE; branch on PROM ctl2k_u3[%03o] (%#o\|%#o)\n", addr, m_next2, r));
	670	LOG((LOG_EMU,2," <-ACSOURCE; branch on PROM ctl2k_u3[%03o] (%#o\|%#o)\n", addr, m_next2, r));
671	671	}
672	672	m_next2 \|= r;
673	673	}

branches/alto2/src/emu/cpu/alto2/a2disk.c
r26072	r26073
176	176	/* both J and K' are 0: set Q to 0, Q' to 1 */
177	177	s1 = (s1 & ~JKFF_Q) \| JKFF_Q0;
178	178	if (s0 & JKFF_Q) {
179		LOG((0,5,"%s J:0 K':0 -> Q:0\n", jkff_name));
	179	LOG((LOG_DISK,5,"%s J:0 K':0 -> Q:0\n", jkff_name));
180	180	}
181	181	break;
182	182	case JKFF_J:
r26072	r26073
185	185	s1 = (s1 & ~JKFF_Q) \| JKFF_Q0;
186	186	else
187	187	s1 = (s1 \| JKFF_Q) & ~JKFF_Q0;
188		LOG((0,5,"%s J:0 K':1 flip-flop Q:%d\n",
	188	LOG((LOG_DISK,5,"%s J:0 K':1 flip-flop Q:%d\n",
189	189	jkff_name, (s1 & JKFF_Q) ? 1 : 0));
190	190	break;
191	191	case JKFF_K:
192	192	if ((s0 ^ s1) & JKFF_Q) {
193		LOG((0,5,"%s J:0 K':1 keep Q:%d\n",
	193	LOG((LOG_DISK,5,"%s J:0 K':1 keep Q:%d\n",
194	194	jkff_name, (s1 & JKFF_Q) ? 1 : 0));
195	195	}
196	196	/* J is 0, and K' is 1: keep Q as is */
r26072	r26073
203	203	/* both J and K' are 1: set Q to 1 */
204	204	s1 = (s1 \| JKFF_Q) & ~JKFF_Q0;
205	205	if (!(s0 & JKFF_Q)) {
206		LOG((0,5,"%s J:1 K':1 -> Q:1\n",
	206	LOG((LOG_DISK,5,"%s J:1 K':1 -> Q:1\n",
207	207	jkff_name));
208	208	}
209	209	break;
r26072	r26073
217	217	/* S' is 1, C' is 0: set Q to 0, Q' to 1 */
218	218	s1 = (s1 & ~JKFF_Q) \| JKFF_Q0;
219	219	if (s0 & JKFF_Q) {
220		LOG((0,5,"%s C':0 -> Q:0\n", jkff_name));
	220	LOG((LOG_DISK,5,"%s C':0 -> Q:0\n", jkff_name));
221	221	}
222	222	break;
223	223	case JKFF_C:
224	224	/* S' is 0, C' is 1: set Q to 1, Q' to 0 */
225	225	s1 = (s1 \| JKFF_Q) & ~JKFF_Q0;
226	226	if (!(s0 & JKFF_Q)) {
227		LOG((0,5,"%s S':0 -> Q:1\n", jkff_name));
	227	LOG((LOG_DISK,5,"%s S':0 -> Q:1\n", jkff_name));
228	228	}
229	229	break;
230	230	case 0:
231	231	default:
232	232	/* unstable state (what to do?) */
233	233	s1 = s1 \| JKFF_Q \| JKFF_Q0;
234		LOG((0,5,"%s C':0 S':0 -> Q:1 and Q':1 <unstable>\n", jkff_name));
	234	LOG((LOG_DISK,5,"%s C':0 S':0 -> Q:1 and Q':1 <unstable>\n", jkff_name));
235	235	break;
236	236	}
237	237	return s1;
r26072	r26073
1087	1087	int i;
1088	1088	UINT8 s0, s1;
1089	1089
1090		LOG((0,5," >>> KWD timing bitclk:%d datin:%d sect4:%d\n", bitclk, datin, drive_sector_mark_0(m_dsk.drive)));
	1090	LOG((LOG_DISK,5," >>> KWD timing bitclk:%d datin:%d sect4:%d\n", bitclk, datin, drive_sector_mark_0(m_dsk.drive)));
1091	1091
1092	1092	if (0 == m_dsk.seclate) {
1093	1093	/* If SECLATE is 0, WDDONE' never goes low (counter's clear has precedence). */
1094		LOG((0,3," SECLATE:0 clears bitcount:0\n"));
	1094	LOG((LOG_DISK,3," SECLATE:0 clears bitcount:0\n"));
1095	1095	m_dsk.bitcount = 0;
1096	1096	m_dsk.carry = 0;
1097	1097	} else if (m_dsk.bitclk && !bitclk) {
r26072	r26073
1105	1105	* counter. It has been loaded with 15, so it counts to 16 on
1106	1106	* the next rising edge and makes WDDONE' go to 0.
1107	1107	*/
1108		LOG((0,3," HIORDBIT:1 sets WFFO:1\n"));
	1108	LOG((LOG_DISK,3," HIORDBIT:1 sets WFFO:1\n"));
1109	1109	PUT_KCOM_WFFO(m_dsk.kcom, 1);
1110	1110	}
1111	1111	/*
r26072	r26073
1121	1121	*/
1122	1122	m_dsk.bitcount = (m_dsk.bitcount + 1) % 16;
1123	1123	m_dsk.carry = m_dsk.bitcount == 15;
1124		LOG((0,3," WFFO:1 count bitcount:%2d\n", m_dsk.bitcount));
	1124	LOG((LOG_DISK,3," WFFO:1 count bitcount:%2d\n", m_dsk.bitcount));
1125	1125	} else {
1126	1126	/*
1127	1127	* If BUS[4] (WFFO) was 0, both J and K' will be 0, and Q
r26072	r26073
1129	1129	*/
1130	1130	m_dsk.bitcount = 15;
1131	1131	m_dsk.carry = 1;
1132		LOG((0,3," WFFO:0 load bitcount:%2d\n", m_dsk.bitcount));
	1132	LOG((LOG_DISK,3," WFFO:0 load bitcount:%2d\n", m_dsk.bitcount));
1133	1133	}
1134	1134	} else if (!m_dsk.bitclk && bitclk) {
1135	1135	/* clock the shift register on the rising edge of bitclk */
r26072	r26073
1139	1139	}
1140	1140
1141	1141	if (wddone0 != wddone1) {
1142		LOG((0,2," WDDONE':%d->%d\n", wddone0, wddone1));
	1142	LOG((LOG_DISK,2," WDDONE':%d->%d\n", wddone0, wddone1));
1143	1143	}
1144	1144
1145	1145	if (m_dsk.carry) {
r26072	r26073
1156	1156	m_dsk.datain = m_dsk.shiftin & 0177777;
1157	1157	/* load the output shift register */
1158	1158	m_dsk.shiftout = m_dsk.dataout;
1159		LOG((0,6," LATCH in:%06o (0x%04x) out:%06o (0x%04x)\n", m_dsk.datain, m_dsk.datain, m_dsk.dataout, m_dsk.dataout));
	1159	LOG((LOG_DISK,6," LATCH in:%06o (0x%04x) out:%06o (0x%04x)\n", m_dsk.datain, m_dsk.datain, m_dsk.dataout, m_dsk.dataout));
1160	1160	}
1161	1161	} else {
1162	1162	/* CARRY = 0 -> WDDONE' = 1 */
r26072	r26073
1189	1189	for (i = 0; i < 4; i++) {
1190	1190
1191	1191	if (m_sysclka0[i] != m_sysclka1[i]) {
1192		LOG((0,7," SYSCLKA':%d->%d\n", m_sysclka0[i], m_sysclka1[i]));
	1192	LOG((LOG_DISK,7," SYSCLKA':%d->%d\n", m_sysclka0[i], m_sysclka1[i]));
1193	1193	}
1194	1194	if (m_sysclkb0[i] != m_sysclkb1[i]) {
1195		LOG((0,7," SYSCLKB':%d->%d\n", m_sysclkb0[i], m_sysclkb1[i]));
	1195	LOG((LOG_DISK,7," SYSCLKB':%d->%d\n", m_sysclkb0[i], m_sysclkb1[i]));
1196	1196	}
1197	1197
1198	1198	/**
r26072	r26073
1379	1379	/* rising edge immediately */
1380	1380	if ((m_dsk.wdinit = WDINIT) == 1)
1381	1381	m_dsk.wdinit0 = 1;
1382		LOG((0,2," WDINIT:%d\n", m_dsk.wdinit));
	1382	LOG((LOG_DISK,2," WDINIT:%d\n", m_dsk.wdinit));
1383	1383	}
1384	1384
1385	1385	/*
r26072	r26073
1388	1388	*/
1389	1389	if (m_dsk.ff_53a & m_dsk.ff_43a & JKFF_Q) {
1390	1390	if (m_dsk.wdtskena == 1) {
1391		LOG((0,2," WDTSKENA':0 and WAKEKWDT':0 wake KWD\n"));
	1391	LOG((LOG_DISK,2," WDTSKENA':0 and WAKEKWDT':0 wake KWD\n"));
1392	1392	m_dsk.wdtskena = 0;
1393	1393	m_task_wakeup \|= 1 << task_kwd;
1394	1394	}
r26072	r26073
1397	1397	* If Q (43a) is 1, the WDTSKENA' signal is deasserted.
1398	1398	*/
1399	1399	if (m_dsk.wdtskena == 0) {
1400		LOG((0,2," WDTSKENA':1\n"));
	1400	LOG((LOG_DISK,2," WDTSKENA':1\n"));
1401	1401	m_dsk.wdtskena = 1;
1402	1402	m_task_wakeup &= ~(1 << task_kwd);
1403	1403	}
r26072	r26073
1406	1406	if (m_dsk.kfer) {
1407	1407	/* no fatal error: ready and not seqerr and seekok */
1408	1408	if (!RDYLAT && !SEQERR && SEEKOK) {
1409		LOG((0,2," reset KFER\n"));
	1409	LOG((LOG_DISK,2," reset KFER\n"));
1410	1410	m_dsk.kfer = 0;
1411	1411	}
1412	1412	} else {
1413	1413	/* fatal error: not ready or seqerr or not seekok */
1414	1414	if (RDYLAT) {
1415		LOG((0,2," RDYLAT sets KFER\n"));
	1415	LOG((LOG_DISK,2," RDYLAT sets KFER\n"));
1416	1416	m_dsk.kfer = 1;
1417	1417	} else if (SEQERR) {
1418		LOG((0,2," SEQERR sets KFER\n"));
	1418	LOG((LOG_DISK,2," SEQERR sets KFER\n"));
1419	1419	m_dsk.kfer = 1;
1420	1420	} else if (!SEEKOK) {
1421		LOG((0,2," not SEEKOK sets KFER\n"));
	1421	LOG((LOG_DISK,2," not SEEKOK sets KFER\n"));
1422	1422	m_dsk.kfer = 1;
1423	1423	}
1424	1424	}
r26072	r26073
1429	1429	*/
1430	1430	if (m_dsk.ff_22b & JKFF_Q) {
1431	1431	if (!(m_task_wakeup & (1 << task_ksec))) {
1432		LOG((0,2," STSKENA:1; WAKEST':0 wake KSEC\n"));
	1432	LOG((LOG_DISK,2," STSKENA:1; WAKEST':0 wake KSEC\n"));
1433	1433	m_task_wakeup \|= 1 << task_kwd;
1434	1434	}
1435	1435	} else {
1436	1436	if (m_task_wakeup & (1 << task_ksec)) {
1437		LOG((0,2," STSKENA:0; WAKEST':1\n"));
	1437	LOG((LOG_DISK,2," STSKENA:0; WAKEST':1\n"));
1438	1438	m_task_wakeup &= ~(1 << task_kwd);
1439	1439	}
1440	1440	}
r26072	r26073
1472	1472	m_dsk.seclate_timer->adjust(attotime::from_nsec(TW_SECLATE), 1, attotime::never);
1473	1473	if (m_dsk.seclate) {
1474	1474	m_dsk.seclate = 0;
1475		LOG((0,4," SECLATE -> 0 pulse until %lldns\n", ntime() + TW_SECLATE));
	1475	LOG((LOG_DISK,4," SECLATE -> 0 pulse until %lldns\n", ntime() + TW_SECLATE));
1476	1476	}
1477	1477	}
1478	1478
r26072	r26073
1500	1500	m_dsk.ff_21a_old = m_dsk.ff_21a;
1501	1501	m_dsk.bitclk = bitclk;
1502	1502	m_dsk.datin = datin;
1503		LOG((0,5," <<< KWD timing\n"));
	1503	LOG((LOG_DISK,5," <<< KWD timing\n"));
1504	1504	}
1505	1505
1506	1506
r26072	r26073
1508	1508	void alto2_cpu_device::disk_seclate(void* ptr, INT32 arg)
1509	1509	{
1510	1510	(void)ptr;
1511		LOG((0,2," SECLATE -> %d\n", arg));
	1511	LOG((LOG_DISK,2," SECLATE -> %d\n", arg));
1512	1512	m_dsk.seclate = arg;
1513	1513	m_dsk.seclate_timer->enable(false);
1514	1514	}
r26072	r26073
1517	1517	void alto2_cpu_device::disk_ok_to_run(void* ptr, INT32 arg)
1518	1518	{
1519	1519	(void)ptr;
1520		LOG((0,2," OK TO RUN -> %d\n", arg));
	1520	LOG((LOG_DISK,2," OK TO RUN -> %d\n", arg));
1521	1521	m_dsk.ok_to_run = arg;
1522	1522	m_dsk.ok_to_run_timer->enable(false);
1523	1523	}
r26072	r26073
1552	1552	int lai;
1553	1553	int strobe;
1554	1554
1555		LOG((0,2," STROBE #%d restore:%d cylinder:%d\n", unit, restore, cylinder));
	1555	LOG((LOG_DISK,2," STROBE #%d restore:%d cylinder:%d\n", unit, restore, cylinder));
1556	1556
1557	1557	/* This is really monoflop 52a generating a very short 0 pulse */
1558	1558	for (strobe = 0; strobe < 2; strobe++) {
r26072	r26073
1561	1561	drive_strobe(unit, cylinder, restore, strobe);
1562	1562
1563	1563	lai = drive_log_addx_interlock_0(unit);
1564		LOG((0,6," LAI':%d\n", lai));
	1564	LOG((LOG_DISK,6," LAI':%d\n", lai));
1565	1565	/**
1566	1566	* JK flip-flop 44a (LAI' clocked)
1567	1567	* <PRE>
r26072	r26073
1593	1593
1594	1594	} else {
1595	1595	/* clear the monoflop 52b, i.e. no timer restart */
1596		LOG((0,2," STROBON:%d\n", m_dsk.strobe));
	1596	LOG((LOG_DISK,2," STROBON:%d\n", m_dsk.strobe));
1597	1597
1598	1598	/* update the seekok status: SKINC' && LAI' && Q' of FF 44a */
1599	1599	seekok = drive_seek_incomplete_0(unit);
1600	1600	if (seekok != m_dsk.seekok) {
1601	1601	m_dsk.seekok = seekok;
1602		LOG((0,2," SEEKOK:%d\n", m_dsk.seekok));
	1602	LOG((LOG_DISK,2," SEEKOK:%d\n", m_dsk.seekok));
1603	1603	}
1604	1604	}
1605	1605
1606		LOG((0,2," current cylinder:%d\n", drive_cylinder(unit) ^ DIABLO_DRIVE_CYLINDER_MASK));
	1606	LOG((LOG_DISK,2," current cylinder:%d\n", drive_cylinder(unit) ^ DIABLO_DRIVE_CYLINDER_MASK));
1607	1607
1608	1608	/* if the strobe is still set, restart the timer */
1609	1609	if (m_dsk.strobe) {
r26072	r26073
1619	1619	{
1620	1620	m_dsk.ready_mf31a = arg & drive_ready_0(m_dsk.drive);
1621	1621	/* log the not ready result with level 0, else 2 */
1622		LOG((0,m_dsk.ready_mf31a ? 0 : 2," ready mf31a:%d\n", m_dsk.ready_mf31a));
	1622	LOG((LOG_DISK,m_dsk.ready_mf31a ? 0 : 2," ready mf31a:%d\n", m_dsk.ready_mf31a));
1623	1623	}
1624	1624
1625	1625	/**
r26072	r26073
1671	1671
1672	1672	r = m_dsk.kstat;
1673	1673
1674		LOG((0,1," <-KSTAT; BUS &= %#o\n", r));
1675		LOG((0,2," sector: %d\n", GET_KSTAT_SECTOR(m_dsk.kstat)));
1676		LOG((0,2," done: %d\n", GET_KSTAT_DONE(m_dsk.kstat)));
1677		LOG((0,2," seekfail: %d\n", GET_KSTAT_SEEKFAIL(m_dsk.kstat)));
1678		LOG((0,2," seek: %d\n", GET_KSTAT_SEEK(m_dsk.kstat)));
1679		LOG((0,2," notrdy: %d\n", GET_KSTAT_NOTRDY(m_dsk.kstat)));
1680		LOG((0,2," datalate: %d\n", GET_KSTAT_DATALATE(m_dsk.kstat)));
1681		LOG((0,2," idle: %d\n", GET_KSTAT_IDLE(m_dsk.kstat)));
1682		LOG((0,2," cksum: %d\n", GET_KSTAT_CKSUM(m_dsk.kstat)));
1683		LOG((0,2," completion:%d\n", GET_KSTAT_COMPLETION(m_dsk.kstat)));
	1674	LOG((LOG_DISK,1," <-KSTAT; BUS &= %#o\n", r));
	1675	LOG((LOG_DISK,2," sector: %d\n", GET_KSTAT_SECTOR(m_dsk.kstat)));
	1676	LOG((LOG_DISK,2," done: %d\n", GET_KSTAT_DONE(m_dsk.kstat)));
	1677	LOG((LOG_DISK,2," seekfail: %d\n", GET_KSTAT_SEEKFAIL(m_dsk.kstat)));
	1678	LOG((LOG_DISK,2," seek: %d\n", GET_KSTAT_SEEK(m_dsk.kstat)));
	1679	LOG((LOG_DISK,2," notrdy: %d\n", GET_KSTAT_NOTRDY(m_dsk.kstat)));
	1680	LOG((LOG_DISK,2," datalate: %d\n", GET_KSTAT_DATALATE(m_dsk.kstat)));
	1681	LOG((LOG_DISK,2," idle: %d\n", GET_KSTAT_IDLE(m_dsk.kstat)));
	1682	LOG((LOG_DISK,2," cksum: %d\n", GET_KSTAT_CKSUM(m_dsk.kstat)));
	1683	LOG((LOG_DISK,2," completion:%d\n", GET_KSTAT_COMPLETION(m_dsk.kstat)));
1684	1684
1685	1685	m_bus &= r;
1686	1686	}
r26072	r26073
1698	1698	UINT16 r;
1699	1699	/* get the current word from the drive */
1700	1700	r = m_dsk.datain;
1701		LOG((0,1," <-KDATA (%#o)\n", r));
	1701	LOG((LOG_DISK,1," <-KDATA (%#o)\n", r));
1702	1702	m_bus &= r;
1703	1703	}
1704	1704
r26072	r26073
1712	1712	void alto2_cpu_device::f1_strobe_1()
1713	1713	{
1714	1714	if (GET_KCOM_SENDADR(m_dsk.kcom)) {
1715		LOG((0,1," STROBE (SENDADR:1)\n"));
	1715	LOG((LOG_DISK,1," STROBE (SENDADR:1)\n"));
1716	1716	/* Set the STROBON flag and start the STROBON monoflop */
1717	1717	m_dsk.strobe = 1;
1718	1718	disk_strobon(0,
r26072	r26073
1720	1720	2 * GET_KADDR_RESTORE(m_dsk.kaddr) +
1721	1721	m_dsk.drive);
1722	1722	} else {
1723		LOG((0,1," STROBE (w/o SENDADR)\n"));
	1723	LOG((LOG_DISK,1," STROBE (w/o SENDADR)\n"));
1724	1724	/* FIXME: what to do if SENDADR isn't set? */
1725	1725	}
1726	1726	}
r26072	r26073
1736	1736	void alto2_cpu_device::f1_load_kstat_1()
1737	1737	{
1738	1738	int i;
1739		LOG((0,1," KSTAT<-; BUS[12-15] %#o\n", m_bus));
1740		LOG((0,2," idle: %d\n", GET_KSTAT_IDLE(m_bus)));
1741		LOG((0,2," cksum: %d\n", GET_KSTAT_CKSUM(m_bus)));
1742		LOG((0,2," completion:%d\n", GET_KSTAT_COMPLETION(m_bus)));
	1739	LOG((LOG_DISK,1," KSTAT<-; BUS[12-15] %#o\n", m_bus));
	1740	LOG((LOG_DISK,2," idle: %d\n", GET_KSTAT_IDLE(m_bus)));
	1741	LOG((LOG_DISK,2," cksum: %d\n", GET_KSTAT_CKSUM(m_bus)));
	1742	LOG((LOG_DISK,2," completion:%d\n", GET_KSTAT_COMPLETION(m_bus)));
1743	1743
1744	1744	/* KSTAT[12] is just taken from BUS[12] */
1745	1745	PUT_KSTAT_IDLE(m_dsk.kstat, GET_KSTAT_IDLE(m_bus));
r26072	r26073
1787	1787	PUT_KADDR_DRIVE(m_dsk.kaddr, GET_KADDR_DRIVE(m_bus));
1788	1788	m_dsk.drive = GET_KADDR_DRIVE(m_dsk.kaddr);
1789	1789
1790		LOG((0,1," KDATA<-; BUS (%#o) (drive:%d restore:%d %d/%d/%02d page:%d)\n",
	1790	LOG((LOG_DISK,1," KDATA<-; BUS (%#o) (drive:%d restore:%d %d/%d/%02d page:%d)\n",
1791	1791	m_bus,
1792	1792	GET_KADDR_DRIVE(m_dsk.kaddr),
1793	1793	GET_KADDR_RESTORE(m_dsk.kaddr),
r26072	r26073
1813	1813	}
1814	1814	#endif
1815	1815	} else {
1816		LOG((0,1," KDATA<-; BUS %#o (%#x)\n", m_bus, m_bus));
	1816	LOG((LOG_DISK,1," KDATA<-; BUS %#o (%#x)\n", m_bus, m_bus));
1817	1817	}
1818	1818	}
1819	1819
r26072	r26073
1855	1855	case RECNO_HEADER:
1856	1856	m_dsk.krecno = RECNO_LABEL;
1857	1857	m_dsk.krwc = GET_KADR_LABEL(m_dsk.kadr);
1858		LOG((0,2," INCRECNO; HEADER -> LABEL (%o, rwc:%o)\n",
	1858	LOG((LOG_DISK,2," INCRECNO; HEADER -> LABEL (%o, rwc:%o)\n",
1859	1859	m_dsk.krecno, m_dsk.krwc));
1860	1860	break;
1861	1861	case RECNO_PAGENO:
1862	1862	m_dsk.krecno = RECNO_HEADER;
1863	1863	m_dsk.krwc = GET_KADR_HEADER(m_dsk.kadr);
1864		LOG((0,2," INCRECNO; PAGENO -> HEADER (%o, rwc:%o)\n",
	1864	LOG((LOG_DISK,2," INCRECNO; PAGENO -> HEADER (%o, rwc:%o)\n",
1865	1865	m_dsk.krecno, m_dsk.krwc));
1866	1866	break;
1867	1867	case RECNO_LABEL:
1868	1868	m_dsk.krecno = RECNO_DATA;
1869	1869	m_dsk.krwc = GET_KADR_DATA(m_dsk.kadr);
1870		LOG((0,2," INCRECNO; LABEL -> DATA (%o, rwc:%o)\n",
	1870	LOG((LOG_DISK,2," INCRECNO; LABEL -> DATA (%o, rwc:%o)\n",
1871	1871	m_dsk.krecno, m_dsk.krwc));
1872	1872	break;
1873	1873	case RECNO_DATA:
1874	1874	m_dsk.krecno = RECNO_PAGENO;
1875	1875	m_dsk.krwc = 0; /* read (?) */
1876		LOG((0,2," INCRECNO; DATA -> PAGENO (%o, rwc:%o)\n",
	1876	LOG((LOG_DISK,2," INCRECNO; DATA -> PAGENO (%o, rwc:%o)\n",
1877	1877	m_dsk.krecno, m_dsk.krwc));
1878	1878	break;
1879	1879	}
r26072	r26073
1890	1890	*/
1891	1891	void alto2_cpu_device::f1_clrstat_1()
1892	1892	{
1893		LOG((0,1," CLRSTAT\n"));
	1893	LOG((LOG_DISK,1," CLRSTAT\n"));
1894	1894
1895	1895	/* clears the LAI clocked flip-flop 44a
1896	1896	* JK flip-flop 44a (LAI' clocked)
r26072	r26073
1990	1990	{
1991	1991	if (m_dsk.kcom != m_bus) {
1992	1992	m_dsk.kcom = m_bus;
1993		LOG((0,2," KCOM<-; BUS %06o\n", m_dsk.kcom));
1994		LOG((0,2," xferoff: %d\n", GET_KCOM_XFEROFF(m_dsk.kcom)));
1995		LOG((0,2," wdinhib: %d\n", GET_KCOM_WDINHIB(m_dsk.kcom)));
1996		LOG((0,2," bclksrc: %d\n", GET_KCOM_BCLKSRC(m_dsk.kcom)));
1997		LOG((0,2," wffo: %d\n", GET_KCOM_WFFO(m_dsk.kcom)));
1998		LOG((0,2," sendadr: %d\n", GET_KCOM_SENDADR(m_dsk.kcom)));
	1993	LOG((LOG_DISK,2," KCOM<-; BUS %06o\n", m_dsk.kcom));
	1994	LOG((LOG_DISK,2," xferoff: %d\n", GET_KCOM_XFEROFF(m_dsk.kcom)));
	1995	LOG((LOG_DISK,2," wdinhib: %d\n", GET_KCOM_WDINHIB(m_dsk.kcom)));
	1996	LOG((LOG_DISK,2," bclksrc: %d\n", GET_KCOM_BCLKSRC(m_dsk.kcom)));
	1997	LOG((LOG_DISK,2," wffo: %d\n", GET_KCOM_WFFO(m_dsk.kcom)));
	1998	LOG((LOG_DISK,2," sendadr: %d\n", GET_KCOM_SENDADR(m_dsk.kcom)));
1999	1999
2000	2000	// TODO: show disk indicator
2001	2001	}
r26072	r26073
2036	2036	/* current read/write/check is that for the header */
2037	2037	m_dsk.krwc = GET_KADR_HEADER(m_dsk.kadr);
2038	2038
2039		LOG((0,1," KADR<-; BUS[8-14] #%o\n", m_dsk.kadr));
2040		LOG((0,2," seal: %#o\n", GET_KADR_SEAL(m_dsk.kadr)));
2041		LOG((0,2," header: %s\n", rwc_name[GET_KADR_HEADER(m_dsk.kadr)]));
2042		LOG((0,2," label: %s\n", rwc_name[GET_KADR_LABEL(m_dsk.kadr)]));
2043		LOG((0,2," data: %s\n", rwc_name[GET_KADR_DATA(m_dsk.kadr)]));
2044		LOG((0,2," noxfer: %d\n", GET_KADR_NOXFER(m_dsk.kadr)));
2045		LOG((0,2," unused: %d (drive?)\n", GET_KADR_UNUSED(m_dsk.kadr)));
	2039	LOG((LOG_DISK,1," KADR<-; BUS[8-14] #%o\n", m_dsk.kadr));
	2040	LOG((LOG_DISK,2," seal: %#o\n", GET_KADR_SEAL(m_dsk.kadr)));
	2041	LOG((LOG_DISK,2," header: %s\n", rwc_name[GET_KADR_HEADER(m_dsk.kadr)]));
	2042	LOG((LOG_DISK,2," label: %s\n", rwc_name[GET_KADR_LABEL(m_dsk.kadr)]));
	2043	LOG((LOG_DISK,2," data: %s\n", rwc_name[GET_KADR_DATA(m_dsk.kadr)]));
	2044	LOG((LOG_DISK,2," noxfer: %d\n", GET_KADR_NOXFER(m_dsk.kadr)));
	2045	LOG((LOG_DISK,2," unused: %d (drive?)\n", GET_KADR_UNUSED(m_dsk.kadr)));
2046	2046
2047	2047	// TODO: show disk indicator
2048	2048	}
r26072	r26073
2055	2055	void alto2_cpu_device::f2_init_1()
2056	2056	{
2057	2057	UINT16 r = INIT ? 037 : 0;
2058		LOG((0,1," INIT; %sbranch (%#o \| %#o)\n", r ? "" : "no ", m_next2, r));
	2058	LOG((LOG_DISK,1," INIT; %sbranch (%#o \| %#o)\n", r ? "" : "no ", m_next2, r));
2059	2059	m_next2 \|= r;
2060	2060	m_dsk.wdinit0 = 0;
2061	2061	}
r26072	r26073
2091	2091
2092	2092	switch (m_dsk.krecno) {
2093	2093	case RECNO_HEADER:
2094		LOG((0,1," RWC; %sbranch header(%d):%s (%#o\|%#o\|%#o)\n",
	2094	LOG((LOG_DISK,1," RWC; %sbranch header(%d):%s (%#o\|%#o\|%#o)\n",
2095	2095	(r \| init) ? "" : "no ", m_dsk.krecno,
2096	2096	rwc_name[m_dsk.krwc], m_next2, r, init));
2097	2097	break;
2098	2098	case RECNO_PAGENO:
2099		LOG((0,1," RWC; %sbranch pageno(%d):%s (%#o\|%#o\|%#o)\n",
	2099	LOG((LOG_DISK,1," RWC; %sbranch pageno(%d):%s (%#o\|%#o\|%#o)\n",
2100	2100	(r \| init) ? "" : "no ", m_dsk.krecno,
2101	2101	rwc_name[m_dsk.krwc], m_next2, r, init));
2102	2102	break;
2103	2103	case RECNO_LABEL:
2104		LOG((0,1," RWC; %sbranch label(%d):%s (%#o\|%#o\|%#o)\n",
	2104	LOG((LOG_DISK,1," RWC; %sbranch label(%d):%s (%#o\|%#o\|%#o)\n",
2105	2105	(r \| init) ? "" : "no ", m_dsk.krecno,
2106	2106	rwc_name[m_dsk.krwc], m_next2, r, init));
2107	2107	break;
2108	2108	case RECNO_DATA:
2109		LOG((0,1," RWC; %sbranch data(%d):%s (%#o\|%#o\|%#o)\n",
	2109	LOG((LOG_DISK,1," RWC; %sbranch data(%d):%s (%#o\|%#o\|%#o)\n",
2110	2110	(r \| init) ? "" : "no ", m_dsk.krecno,
2111	2111	rwc_name[m_dsk.krwc], m_next2, r, init));
2112	2112	break;
r26072	r26073
2130	2130	{
2131	2131	UINT16 r = m_dsk.krecno;
2132	2132	UINT16 init = INIT ? 037 : 0;
2133		LOG((0,1," RECNO; %sbranch recno:%d (%#o\|%#o\|%#o)\n", (r \| init) ? "" : "no ", m_dsk.krecno, m_next2, r, init));
	2133	LOG((LOG_DISK,1," RECNO; %sbranch recno:%d (%#o\|%#o\|%#o)\n", (r \| init) ? "" : "no ", m_dsk.krecno, m_next2, r, init));
2134	2134	m_next2 \|= r \| init;
2135	2135	m_dsk.wdinit0 = 0;
2136	2136	}
r26072	r26073
2144	2144	{
2145	2145	UINT16 r = GET_KADR_NOXFER(m_dsk.kadr) ? 0 : 1;
2146	2146	UINT16 init = INIT ? 037 : 0;
2147		LOG((0,1," XFRDAT; %sbranch (%#o\|%#o\|%#o)\n", (r \| init) ? "" : "no ", m_next2, r, init));
	2147	LOG((LOG_DISK,1," XFRDAT; %sbranch (%#o\|%#o\|%#o)\n", (r \| init) ? "" : "no ", m_next2, r, init));
2148	2148	m_next2 \|= r \| init;
2149	2149	m_dsk.wdinit0 = 0;
2150	2150	}
r26072	r26073
2159	2159	UINT16 r = drive_seek_read_write_0(m_dsk.drive);
2160	2160	UINT16 init = INIT ? 037 : 0;
2161	2161
2162		LOG((0,1," SWRNRDY; %sbranch (%#o\|%#o\|%#o)\n", (r \| init) ? "" : "no ", m_next2, r, init));
	2162	LOG((LOG_DISK,1," SWRNRDY; %sbranch (%#o\|%#o\|%#o)\n", (r \| init) ? "" : "no ", m_next2, r, init));
2163	2163	m_next2 \|= r \| init;
2164	2164	m_dsk.wdinit0 = 0;
2165	2165	}
r26072	r26073
2174	2174	UINT16 r = m_dsk.kfer ? 0 : 1;
2175	2175	UINT16 init = INIT ? 037 : 0;
2176	2176
2177		LOG((0,1," NFER; %sbranch (%#o\|%#o\|%#o)\n", (r \| init) ? "" : "no ", m_next2, r, init));
	2177	LOG((LOG_DISK,1," NFER; %sbranch (%#o\|%#o\|%#o)\n", (r \| init) ? "" : "no ", m_next2, r, init));
2178	2178	m_next2 \|= r \| init;
2179	2179	m_dsk.wdinit0 = 0;
2180	2180	}
r26072	r26073
2203	2203	UINT16 r = m_dsk.strobe;
2204	2204	UINT16 init = INIT ? 037 : 0;
2205	2205
2206		LOG((0,2," STROBON; %sbranch (%#o\|%#o\|%#o)\n", (r \| init) ? "" : "no ", m_next2, r, init));
	2206	LOG((LOG_DISK,2," STROBON; %sbranch (%#o\|%#o\|%#o)\n", (r \| init) ? "" : "no ", m_next2, r, init));
2207	2207	m_next2 \|= r \| init;
2208	2208	m_dsk.wdinit0 = 0;
2209	2209	}
r26072	r26073
2238	2238	if (GET_KCOM_XFEROFF(m_dsk.kcom)) {
2239	2239	/* do anything, if the transfer is off? */
2240	2240	} else {
2241		LOG((0,7," BITCLK#%d bit:%d (write) @%lldns\n", arg, bit, ntime()));
	2241	LOG((LOG_DISK,7," BITCLK#%d bit:%d (write) @%lldns\n", arg, bit, ntime()));
2242	2242	if (clk)
2243	2243	drive_wrdata(m_dsk.drive, arg, bit);
2244	2244	else
r26072	r26073
2247	2247	} else if (GET_KCOM_BCLKSRC(m_dsk.kcom)) {
2248	2248	/* always select the crystal clock */
2249	2249	bit = drive_rddata(m_dsk.drive, arg);
2250		LOG((0,7," BITCLK#%d bit:%d (read, crystal) @%lldns\n", arg, bit, ntime()));
	2250	LOG((LOG_DISK,7," BITCLK#%d bit:%d (read, crystal) @%lldns\n", arg, bit, ntime()));
2251	2251	kwd_timing(clk, bit, 0);
2252	2252	} else {
2253	2253	/* if XFEROFF is set, keep the bit at 1 (RDGATE' is high) */
r26072	r26073
2256	2256	} else {
2257	2257	clk = drive_rdclk(m_dsk.drive, arg);
2258	2258	bit = drive_rddata(m_dsk.drive, arg);
2259		LOG((0,7," BITCLK#%d bit:%d (read, driveclk) @%lldns\n", arg, bit, ntime()));
	2259	LOG((LOG_DISK,7," BITCLK#%d bit:%d (read, driveclk) @%lldns\n", arg, bit, ntime()));
2260	2260	}
2261	2261	kwd_timing(clk, bit, 0);
2262	2262	}
r26072	r26073
2276	2276	void alto2_cpu_device::disk_sector_start(int unit)
2277	2277	{
2278	2278	if (m_dsk.bitclk_timer) {
2279		LOG((0,0," unit #%d stop bitclk\n", m_dsk.bitclk));
	2279	LOG((LOG_DISK,0," unit #%d stop bitclk\n", m_dsk.bitclk));
2280	2280	m_dsk.bitclk_timer->enable(false);
2281	2281	}
2282	2282
r26072	r26073
2287	2287	m_dsk.shiftin = 0;
2288	2288	m_dsk.shiftout = 0;
2289	2289
2290		LOG((0,1," unit #%d sector %d start\n", unit, GET_KSTAT_SECTOR(m_dsk.kstat)));
	2290	LOG((LOG_DISK,1," unit #%d sector %d start\n", unit, GET_KSTAT_SECTOR(m_dsk.kstat)));
2291	2291
2292	2292	/* HACK: no command, no bit clock */
2293	2293	if (debug_read_mem(0521))

branches/alto2/src/emu/cpu/alto2/a2dvt.c
r26072	r26073
15	15	void alto2_cpu_device::f1_dvt_block_0()
16	16	{
17	17	m_task_wakeup &= ~(1 << m_task);
18		LOG((0,2," BLOCK %s\n", task_name(m_task)));
	18	LOG((LOG_DVT,2," BLOCK %s\n", task_name(m_task)));
19	19	}
20	20
21	21

branches/alto2/src/emu/cpu/alto2/a2dwt.c
r26072	r26073
18	18
19	19	/* clear the wakeup for the display word task */
20	20	m_task_wakeup &= ~(1 << m_task);
21		LOG((0,2," BLOCK %s\n", task_name(m_task)));
	21	LOG((LOG_DWT,2," BLOCK %s\n", task_name(m_task)));
22	22
23	23	/* wakeup the display horizontal task, if it didn't block itself */
24	24	if (!m_dsp.dht_blocks)
r26072	r26073
30	30	*/
31	31	void alto2_cpu_device::f2_dwt_load_ddr_1()
32	32	{
33		LOG((0,2," DDR<- BUS (%#o)\n", m_bus));
	33	LOG((LOG_DWT,2," DDR<- BUS (%#o)\n", m_bus));
34	34	m_dsp.fifo[m_dsp.fifo_wr] = m_bus;
35	35	m_dsp.fifo_wr = (m_dsp.fifo_wr + 1) % ALTO2_DISPLAY_FIFO;
36	36	if (FIFO_STOPWAKE_0() == 0)
37	37	m_task_wakeup &= ~(1 << task_dwt);
38		LOG((0,2, " DWT push %04x into FIFO[%02o]%s\n",
	38	LOG((LOG_DWT,2, " DWT push %04x into FIFO[%02o]%s\n",
39	39	m_bus, (m_dsp.fifo_wr - 1) & (ALTO2_DISPLAY_FIFO - 1),
40	40	FIFO_STOPWAKE_0() == 0 ? " STOPWAKE" : ""));
41	41	}

branches/alto2/src/emu/cpu/alto2/alto2.c
r26072	r26073
27	27
28	28	alto2_cpu_device::alto2_cpu_device(const machine_config& mconfig, const char* tag, device_t* owner, UINT32 clock) :
29	29	cpu_device(mconfig, ALTO2, "Xerox Alto-II", tag, owner, clock, "alto2", __FILE__),
	30	#if ALTO2_DEBUG
	31	m_log_types(LOG_ALL),
	32	m_log_level(9),
	33	#endif
30	34	m_ucode_config("program", ENDIANNESS_BIG, 32, 14, -2),
31	35	m_const_config("constants", ENDIANNESS_BIG, 16, 8, -1),
32	36	m_ram_config("memory", ENDIANNESS_BIG, 16, 17, -1),
r26072	r26073
716	720	// FIXME: use the level to suppress messages if logging is less verbose than level
717	721	void alto2_cpu_device::logprintf(int type, int level, const char* format, ...)
718	722	{
	723	static const char* type_name[] = {
	724	"[CPU]",
	725	"[EMU]",
	726	"[T01]",
	727	"[T02]",
	728	"[T03]",
	729	"[KSEC]",
	730	"[T05]",
	731	"[T06]",
	732	"[ETH]",
	733	"[MRT]",
	734	"[DWT]",
	735	"[CURT]",
	736	"[DHT]",
	737	"[DVT]",
	738	"[PART]",
	739	"[KWD]",
	740	"[T17]",
	741	"[MEM]",
	742	"[RAM]",
	743	"[DRIVE]",
	744	"[DISK]",
	745	"[DISPL]",
	746	"[MOUSE]"
	747	};
	748	if (!(m_log_types & type))
	749	return;
	750	if (level > m_log_level)
	751	return;
	752	for (int i = 0; i < sizeof(type_name)/sizeof(type_name[0]); i++)
	753	if (type & (1 << i))
	754	debug_console_printf(machine(), "%-7s ", type_name[i]);
719	755	va_list ap;
720	756	va_start(ap, format);
721		vprintf(format, ap);
	757	debug_console_vprintf(machine(), format, ap);
722	758	va_end(ap);
723	759	}
724	760	#endif
r26072	r26073
886	922
887	923	void alto2_cpu_device::watch_read(UINT32 addr, UINT32 data)
888	924	{
889		LOG((0,0,"mem: rd[%06o] = %06o\n", addr, data));
	925	LOG((LOG_MEM,0,"mem: rd[%06o] = %06o\n", addr, data));
890	926	}
891	927
892	928	void alto2_cpu_device::watch_write(UINT32 addr, UINT32 data)
893	929	{
894		LOG((0,0,"mem: wr[%06o] = %06o\n", addr, data));
	930	LOG((LOG_MEM,0,"mem: wr[%06o] = %06o\n", addr, data));
895	931	}
896	932
897	933	/** @brief fatal exit on unitialized dynamic phase BUS source */
r26072	r26073
957	993	{
958	994	int task = address & 017;
959	995	m_bank_reg[task] = data & 017;
960		LOG((0,0," write bank[%02o]=%#o normal:%o extended:%o (%s)\n",
	996	LOG((LOG_CPU,0," write bank[%02o]=%#o normal:%o extended:%o (%s)\n",
961	997	task, data,
962	998	GET_BANK_NORMAL(data),
963	999	GET_BANK_EXTENDED(data),
r26072	r26073
970	1006	void alto2_cpu_device::bs_read_r_0()
971	1007	{
972	1008	UINT16 r = m_r[m_rsel];
973		LOG((0,2," <-R%02o; %s (%#o)\n", m_rsel, r_name(m_rsel), r));
	1009	LOG((LOG_CPU,2," <-R%02o; %s (%#o)\n", m_rsel, r_name(m_rsel), r));
974	1010	m_bus &= r;
975	1011	}
976	1012
r26072	r26073
980	1016	void alto2_cpu_device::bs_load_r_0()
981	1017	{
982	1018	UINT16 r = 0;
983		LOG((0,2," R%02o<-; %s (BUS&=0)\n", m_rsel, r_name(m_rsel)));
	1019	LOG((LOG_CPU,2," R%02o<-; %s (BUS&=0)\n", m_rsel, r_name(m_rsel)));
984	1020	m_bus &= r;
985	1021	}
986	1022
r26072	r26073
991	1027	{
992	1028	if (MIR_F2(m_mir) != f2_emu_load_dns) {
993	1029	m_r[m_rsel] = m_shifter;
994		LOG((0,2," R%02o<-; %s = SHIFTER (%#o)\n", m_rsel, r_name(m_rsel), m_shifter));
	1030	LOG((LOG_CPU,2," R%02o<-; %s = SHIFTER (%#o)\n", m_rsel, r_name(m_rsel), m_shifter));
995	1031	/* HACK: programs writing r37 with xxx3 make the cursor
996	1032	* display go nuts. Until I found the real reason for this
997	1033	* obviously buggy display, I just clear the two
r26072	r26073
1013	1049	UINT32 mar = m_mem.mar;
1014	1050	#endif
1015	1051	UINT16 md = read_mem();
1016		LOG((0,2," <-MD; BUS&=MD (%#o=[%#o])\n", md, mar));
	1052	LOG((LOG_CPU,2," <-MD; BUS&=MD (%#o=[%#o])\n", md, mar));
1017	1053	m_bus &= md;
1018	1054	}
1019	1055
r26072	r26073
1023	1059	void alto2_cpu_device::bs_mouse_0()
1024	1060	{
1025	1061	UINT16 r = mouse_read();
1026		LOG((0,2," <-MOUSE; BUS&=MOUSE (%#o)\n", r));
	1062	LOG((LOG_CPU,2," <-MOUSE; BUS&=MOUSE (%#o)\n", r));
1027	1063	m_bus &= r;
1028	1064	}
1029	1065
r26072	r26073
1033	1069	void alto2_cpu_device::bs_disp_0()
1034	1070	{
1035	1071	UINT16 r = 0177777;
1036		LOG((0,0,"BS <-DISP not handled by task %s mpc:%04x\n", task_name(m_task), m_mpc));
1037		LOG((0,2," <-DISP; BUS&=DISP ?? (%#o)\n", r));
	1072	LOG((LOG_CPU,0,"BS <-DISP not handled by task %s mpc:%04x\n", task_name(m_task), m_mpc));
	1073	LOG((LOG_CPU,2," <-DISP; BUS&=DISP ?? (%#o)\n", r));
1038	1074	m_bus &= r;
1039	1075	}
1040	1076
r26072	r26073
1050	1086	UINT32 msb;
1051	1087	if (MIR_F2(m_mir) == f2_load_md) {
1052	1088	msb = GET_BANK_EXTENDED(bank) << 16;
1053		LOG((0,7, " XMAR %#o\n", msb \| m_alu));
	1089	LOG((LOG_CPU,7, " XMAR %#o\n", msb \| m_alu));
1054	1090	} else {
1055	1091	msb = GET_BANK_NORMAL(bank) << 16;
1056	1092
r26072	r26073
1126	1162
1127	1163	if (in & PRIO_IN_EI) {
1128	1164	out = PRIO_OUT_EO \| PRIO_OUT_GS \| PRIO_OUT_QZ;
1129		LOG((0,2," f9318 case (a) in:%#o out:%#o\n", in, out));
	1165	LOG((LOG_CPU,2," f9318 case (a) in:%#o out:%#o\n", in, out));
1130	1166	return out;
1131	1167	}
1132	1168
1133	1169	if (0 == (in & PRIO_I7)) {
1134	1170	out = PRIO_OUT_EO;
1135		LOG((0,2," f9318 case (c) in:%#o out:%#o\n", in, out));
	1171	LOG((LOG_CPU,2," f9318 case (c) in:%#o out:%#o\n", in, out));
1136	1172	return out;
1137	1173	}
1138	1174
1139	1175	if (PRIO_I7 == (in & PRIO_I6_I7)) {
1140	1176	out = PRIO_OUT_EO \| PRIO_OUT_Q0;
1141		LOG((0,2," f9318 case (d) in:%#o out:%#o\n", in, out));
	1177	LOG((LOG_CPU,2," f9318 case (d) in:%#o out:%#o\n", in, out));
1142	1178	return out;
1143	1179	}
1144	1180
1145	1181	if (PRIO_I6_I7 == (in & PRIO_I5_I7)) {
1146	1182	out = PRIO_OUT_EO \| PRIO_OUT_Q1;
1147		LOG((0,2," f9318 case (e) in:%#o out:%#o\n", in, out));
	1183	LOG((LOG_CPU,2," f9318 case (e) in:%#o out:%#o\n", in, out));
1148	1184	return out;
1149	1185	}
1150	1186
1151	1187	if (PRIO_I5_I7 == (in & PRIO_I4_I7)) {
1152	1188	out = PRIO_OUT_EO \| PRIO_OUT_Q0 \| PRIO_OUT_Q1;
1153		LOG((0,2," f9318 case (f) in:%#o out:%#o\n", in, out));
	1189	LOG((LOG_CPU,2," f9318 case (f) in:%#o out:%#o\n", in, out));
1154	1190	return out;
1155	1191	}
1156	1192
1157	1193	if (PRIO_I4_I7 == (in & PRIO_I3_I7)) {
1158	1194	out = PRIO_OUT_EO \| PRIO_OUT_Q2;
1159		LOG((0,2," f9318 case (g) in:%#o out:%#o\n", in, out));
	1195	LOG((LOG_CPU,2," f9318 case (g) in:%#o out:%#o\n", in, out));
1160	1196	return out;
1161	1197	}
1162	1198
1163	1199	if (PRIO_I3_I7 == (in & PRIO_I2_I7)) {
1164	1200	out = PRIO_OUT_EO \| PRIO_OUT_Q0 \| PRIO_OUT_Q2;
1165		LOG((0,2," f9318 case (h) in:%#o out:%#o\n", in, out));
	1201	LOG((LOG_CPU,2," f9318 case (h) in:%#o out:%#o\n", in, out));
1166	1202	return out;
1167	1203	}
1168	1204
1169	1205	if (PRIO_I2_I7 == (in & PRIO_I1_I7)) {
1170	1206	out = PRIO_OUT_EO \| PRIO_OUT_Q1 \| PRIO_OUT_Q2;
1171		LOG((0,2," f9318 case (i) in:%#o out:%#o\n", in, out));
	1207	LOG((LOG_CPU,2," f9318 case (i) in:%#o out:%#o\n", in, out));
1172	1208	return out;
1173	1209	}
1174	1210
1175	1211	if (PRIO_I1_I7 == (in & PRIO_I0_I7)) {
1176	1212	out = PRIO_OUT_EO \| PRIO_OUT_Q0 \| PRIO_OUT_Q1 \| PRIO_OUT_Q2;
1177		LOG((0,2," f9318 case (j) in:%#o out:%#o\n", in, out));
	1213	LOG((LOG_CPU,2," f9318 case (j) in:%#o out:%#o\n", in, out));
1178	1214	return out;
1179	1215	}
1180	1216
1181	1217	out = PRIO_OUT_QZ \| PRIO_OUT_GS;
1182		LOG((0,2," f9318 case (b) in:%#o out:%#o\n", in, out));
	1218	LOG((LOG_CPU,2," f9318 case (b) in:%#o out:%#o\n", in, out));
1183	1219	return out;
1184	1220	}
1185	1221	#endif
r26072	r26073
1267	1303	register int ct1, ct2, ct4, ct8;
1268	1304	register int wakeup, ct;
1269	1305
1270		LOG((0,2, " TASK %02o:%s\n", m_task, task_name(m_task)));
	1306	LOG((LOG_CPU,2, " TASK %02o:%s\n", m_task, task_name(m_task)));
1271	1307
1272	1308	if (m_task > task_emu && (m_task_wakeup & (1 << m_task)))
1273	1309	addr = m_task;
1274		LOG((0,2," ctl2k_u38[%02o] = %04o\n", addr, ctl2k_u38[addr] & 017));
	1310	LOG((LOG_CPU,2," ctl2k_u38[%02o] = %04o\n", addr, ctl2k_u38[addr] & 017));
1275	1311
1276	1312	rdct1 = (ctl2k_u38[addr] >> U38_RDCT1) & 1;
1277	1313	rdct2 = (ctl2k_u38[addr] >> U38_RDCT2) & 1;
r26072	r26073
1299	1335
1300	1336	/* CT1 = (U1.Q0' & U2.Q0' & RDCT1')' */
1301	1337	ct1 = !((u1 & PRIO_OUT_Q0) && (u2 & PRIO_OUT_Q0) && rdct1);
1302		LOG((0,2," CT1:%o U1.Q0':%o U2.Q0':%o RDCT1':%o\n",
	1338	LOG((LOG_CPU,2," CT1:%o U1.Q0':%o U2.Q0':%o RDCT1':%o\n",
1303	1339	ct1, (u1 & PRIO_OUT_Q0)?1:0, (u2 & PRIO_OUT_Q0)?1:0, rdct1));
1304	1340	/* CT2 = (U1.Q1' & U2.Q1' & RDCT2')' */
1305	1341	ct2 = !((u1 & PRIO_OUT_Q1) && (u2 & PRIO_OUT_Q1) && rdct2);
1306		LOG((0,2," CT2:%o U1.Q1':%o U2.Q1':%o RDCT2':%o\n",
	1342	LOG((LOG_CPU,2," CT2:%o U1.Q1':%o U2.Q1':%o RDCT2':%o\n",
1307	1343	ct2, (u1 & PRIO_OUT_Q1)?1:0, (u2 & PRIO_OUT_Q1)?1:0, rdct2));
1308	1344	/* CT4 = (U1.Q2' & U2.Q2' & RDCT4')' */
1309	1345	ct4 = !((u1 & PRIO_OUT_Q2) && (u2 & PRIO_OUT_Q2) && rdct4);
1310		LOG((0,2," CT4:%o U1.Q2':%o U2.Q2':%o RDCT4':%o\n",
	1346	LOG((LOG_CPU,2," CT4:%o U1.Q2':%o U2.Q2':%o RDCT4':%o\n",
1311	1347	ct4, (u1 & PRIO_OUT_Q2)?1:0, (u2 & PRIO_OUT_Q2)?1:0, rdct4));
1312	1348	/* CT8 */
1313	1349	ct8 = !((u1 & PRIO_OUT_GS) && rdct8);
1314		LOG((0,2," CT8:%o U1.GS':%o RDCT8':%o\n",
	1350	LOG((LOG_CPU,2," CT8:%o U1.GS':%o RDCT8':%o\n",
1315	1351	ct8, (u1 & PRIO_OUT_GS)?1:0, rdct8));
1316	1352
1317	1353	ct = 8ct8 + 4ct4 + 2*ct2 + ct1;
1318	1354
1319	1355	if (ct != m_next_task) {
1320		LOG((0,2, " switch to %02o\n", ct));
	1356	LOG((LOG_CPU,2, " switch to %02o\n", ct));
1321	1357	m_next2_task = ct;
1322	1358	} else {
1323		LOG((0,2, " no switch\n"));
	1359	LOG((LOG_CPU,2, " no switch\n"));
1324	1360	}
1325	1361	#else /* USE_PRIO_F9318 */
1326	1362	int i;
1327	1363
1328		LOG((0,2, " TASK %02o:%s", m_task, task_name(m_task)));
	1364	LOG((LOG_CPU,2, " TASK %02o:%s", m_task, task_name(m_task)));
1329	1365	for (i = 15; i >= 0; i--) {
1330	1366	if (m_task_wakeup & (1 << i)) {
1331	1367	m_next2_task = i;
1332	1368	if (m_next2_task != m_next_task) {
1333		LOG((0,2, " switch to %02o:%s\n", m_next2_task, task_name(m_next2_task)));
	1369	LOG((LOG_CPU,2, " switch to %02o:%s\n", m_next2_task, task_name(m_next2_task)));
1334	1370	} else {
1335		LOG((0,2, " no switch\n"));
	1371	LOG((LOG_CPU,2, " no switch\n"));
1336	1372	}
1337	1373	return;
1338	1374	}
r26072	r26073
1350	1386	void alto2_cpu_device::f1_block_0()
1351	1387	{
1352	1388	CPU_CLR_TASK_WAKEUP(m_task);
1353		LOG((0,2, " BLOCK %02o:%s\n", m_task, task_name(m_task)));
	1389	LOG((LOG_CPU,2, " BLOCK %02o:%s\n", m_task, task_name(m_task)));
1354	1390	}
1355	1391	#endif
1356	1392
r26072	r26073
1360	1396	void alto2_cpu_device::f2_bus_eq_zero_1()
1361	1397	{
1362	1398	UINT16 r = m_bus == 0 ? 1 : 0;
1363		LOG((0,2, " BUS=0; %sbranch (%#o\|%#o)\n", r ? "" : "no ", m_next2, r));
	1399	LOG((LOG_CPU,2, " BUS=0; %sbranch (%#o\|%#o)\n", r ? "" : "no ", m_next2, r));
1364	1400	m_next2 \|= r;
1365	1401	}
1366	1402
r26072	r26073
1370	1406	void alto2_cpu_device::f2_shifter_lt_zero_1()
1371	1407	{
1372	1408	UINT16 r = (m_shifter & 0100000) ? 1 : 0;
1373		LOG((0,2, " SH<0; %sbranch (%#o\|%#o)\n", r ? "" : "no ", m_next2, r));
	1409	LOG((LOG_CPU,2, " SH<0; %sbranch (%#o\|%#o)\n", r ? "" : "no ", m_next2, r));
1374	1410	m_next2 \|= r;
1375	1411	}
1376	1412
r26072	r26073
1380	1416	void alto2_cpu_device::f2_shifter_eq_zero_1()
1381	1417	{
1382	1418	UINT16 r = m_shifter == 0 ? 1 : 0;
1383		LOG((0,2, " SH=0; %sbranch (%#o\|%#o)\n", r ? "" : "no ", m_next2, r));
	1419	LOG((LOG_CPU,2, " SH=0; %sbranch (%#o\|%#o)\n", r ? "" : "no ", m_next2, r));
1384	1420	m_next2 \|= r;
1385	1421	}
1386	1422
r26072	r26073
1390	1426	void alto2_cpu_device::f2_bus_1()
1391	1427	{
1392	1428	UINT16 r = A2_GET32(m_bus,16,6,15);
1393		LOG((0,2, " BUS; %sbranch (%#o\|%#o)\n", r ? "" : "no ", m_next2, r));
	1429	LOG((LOG_CPU,2, " BUS; %sbranch (%#o\|%#o)\n", r ? "" : "no ", m_next2, r));
1394	1430	m_next2 \|= r;
1395	1431	}
1396	1432
r26072	r26073
1400	1436	void alto2_cpu_device::f2_alucy_1()
1401	1437	{
1402	1438	UINT16 r = m_laluc0;
1403		LOG((0,2, " ALUCY; %sbranch (%#o\|%#o)\n", r ? "" : "no ", m_next2, r));
	1439	LOG((LOG_CPU,2, " ALUCY; %sbranch (%#o\|%#o)\n", r ? "" : "no ", m_next2, r));
1404	1440	m_next2 \|= r;
1405	1441	}
1406	1442
r26072	r26073
1416	1452	#endif
1417	1453	if (MIR_F1(m_mir) == f1_load_mar) {
1418	1454	/* part of an XMAR */
1419		LOG((0,2, " XMAR %#o (%#o)\n", mar, m_bus));
	1455	LOG((LOG_CPU,2, " XMAR %#o (%#o)\n", mar, m_bus));
1420	1456	} else {
1421	1457	write_mem(m_bus);
1422		LOG((0,2, " MD<- BUS ([%#o]=%#o)\n", mar, m_bus));
	1458	LOG((LOG_CPU,2, " MD<- BUS ([%#o]=%#o)\n", mar, m_bus));
1423	1459	}
1424	1460	}
1425	1461
r26072	r26073
1487	1523	if (GET_CRAM_RAMROM(m_cram_addr)) {
1488	1524	/* read ROM 0 at current mpc */
1489	1525	addr = m_mpc & 01777;
1490		LOG((0,0," rdram: ROM [%05o] ", addr));
	1526	LOG((LOG_CPU,0," rdram: ROM [%05o] ", addr));
1491	1527	} else {
1492	1528	/* read RAM 0,1,2 */
1493	1529	addr = ALTO2_UCODE_RAM_BASE + bank * ALTO2_UCODE_PAGE_SIZE + wordaddr;
1494		LOG((0,0," rdram: RAM%d [%04o] ", bank, wordaddr));
	1530	LOG((LOG_CPU,0," rdram: RAM%d [%04o] ", bank, wordaddr));
1495	1531	}
1496	1532
1497	1533	if (addr >= ALTO2_UCODE_SIZE) {
1498	1534	val = 0177777; /* ??? */
1499		LOG((0,0,"invalid address (%06o)\n", val));
	1535	LOG((LOG_CPU,0,"invalid address (%06o)\n", val));
1500	1536	return;
1501	1537	}
1502	1538	val = m_ucode->read_dword(addr) ^ ALTO2_UCODE_INVERTED;
1503	1539	if (GET_CRAM_HALFSEL(m_cram_addr)) {
1504	1540	val = val >> 16;
1505		LOG((0,0,"upper:%06o\n", val));
	1541	LOG((LOG_CPU,0,"upper:%06o\n", val));
1506	1542	} else {
1507	1543	val = val & 0177777;
1508		LOG((0,0,"lower:%06o\n", val));
	1544	LOG((LOG_CPU,0,"lower:%06o\n", val));
1509	1545	}
1510	1546	m_bus &= val;
1511	1547	}
r26072	r26073
1530	1566
1531	1567	/* write RAM 0,1,2 */
1532	1568	addr = ALTO2_UCODE_RAM_BASE + bank * ALTO2_UCODE_PAGE_SIZE + wordaddr;
1533		LOG((0,0," wrtram: RAM%d [%04o] upper:%06o lower:%06o", bank, wordaddr, m_m, m_alu));
	1569	LOG((LOG_CPU,0," wrtram: RAM%d [%04o] upper:%06o lower:%06o", bank, wordaddr, m_m, m_alu));
1534	1570	if (addr >= ALTO2_UCODE_SIZE) {
1535		LOG((0,0," invalid address\n"));
	1571	LOG((LOG_CPU,0," invalid address\n"));
1536	1572	return;
1537	1573	}
1538		LOG((0,0,"\n"));
	1574	LOG((LOG_CPU,0,"\n"));
1539	1575	m_ucode->write_dword(addr, ((m_m << 16) \| m_alu) ^ ALTO2_UCODE_INVERTED);
1540	1576	}
1541	1577
r26072	r26073
1956	1992	bs = MIR_BS(m_mir);
1957	1993	f1 = MIR_F1(m_mir);
1958	1994	f2 = MIR_F2(m_mir);
1959		LOG((0,2,"\n%s-%04o: r:%02o af:%02o bs:%02o f1:%02o f2:%02o t:%o l:%o next:%05o next2:%05o cycle:%lld\n",
	1995	LOG((LOG_CPU,2,"\n%s-%04o: r:%02o af:%02o bs:%02o f1:%02o f2:%02o t:%o l:%o next:%05o next2:%05o cycle:%lld\n",
1960	1996	task_name(m_task), m_mpc, m_rsel, aluf, bs, f1, f2, MIR_T(m_mir), MIR_L(m_mir), m_next, m_next2, cycle()));
1961	1997
1962	1998	/*
r26072	r26073
1968	2004
1969	2005	if (f1 == f1_load_mar) {
1970	2006	if (check_mem_load_mar_stall(m_rsel)) {
1971		LOG((0,3, " MAR<- stall\n"));
	2007	LOG((LOG_CPU,3, " MAR<- stall\n"));
1972	2008	m_next2 = m_next;
1973	2009	m_next = m_mpc;
1974	2010	continue;
1975	2011	}
1976	2012	} else if (f2 == f2_load_md) {
1977	2013	if (check_mem_write_stall()) {
1978		LOG((0,3, " MD<- stall\n"));
	2014	LOG((LOG_CPU,3, " MD<- stall\n"));
1979	2015	m_next2 = m_next;
1980	2016	m_next = m_mpc;
1981	2017	continue;
r26072	r26073
1983	2019	}
1984	2020	if (do_bs && bs == bs_read_md) {
1985	2021	if (check_mem_read_stall()) {
1986		LOG((0,3, " <-MD stall\n"));
	2022	LOG((LOG_CPU,3, " <-MD stall\n"));
1987	2023	m_next2 = m_next;
1988	2024	m_next = m_mpc;
1989	2025	continue;
r26072	r26073
2001	2037	if (!do_bs \|\| bs >= 4) {
2002	2038	int addr = 8 * m_rsel + bs;
2003	2039	UINT16 data = m_const->read_word(addr);
2004		LOG((0,2," %#o; BUS &= CONST[%03o]\n", data, addr));
	2040	LOG((LOG_CPU,2," %#o; BUS &= CONST[%03o]\n", data, addr));
2005	2041	m_bus &= data;
2006	2042	}
2007	2043
r26072	r26073
2041	2077	m_aluc0 = 1;
2042	2078	#endif
2043	2079	flags = TSELECT;
2044		LOG((0,2," ALU<- BUS (%#o := %#o)\n", alu, m_bus));
	2080	LOG((LOG_CPU,2," ALU<- BUS (%#o := %#o)\n", alu, m_bus));
2045	2081	break;
2046	2082
2047	2083	/**
r26072	r26073
2058	2094	m_aluc0 = 1;
2059	2095	#endif
2060	2096	flags = 0;
2061		LOG((0,2," ALU<- T (%#o := %#o)\n", alu, m_t));
	2097	LOG((LOG_CPU,2," ALU<- T (%#o := %#o)\n", alu, m_t));
2062	2098	break;
2063	2099
2064	2100	/**
r26072	r26073
2075	2111	m_aluc0 = 1;
2076	2112	#endif
2077	2113	flags = TSELECT;
2078		LOG((0,2," ALU<- BUS OR T (%#o := %#o \| %#o)\n", alu, m_bus, m_t));
	2114	LOG((LOG_CPU,2," ALU<- BUS OR T (%#o := %#o \| %#o)\n", alu, m_bus, m_t));
2079	2115	break;
2080	2116
2081	2117	/**
r26072	r26073
2092	2128	m_aluc0 = 1;
2093	2129	#endif
2094	2130	flags = 0;
2095		LOG((0,2," ALU<- BUS AND T (%#o := %#o & %#o)\n", alu, m_bus, m_t));
	2131	LOG((LOG_CPU,2," ALU<- BUS AND T (%#o := %#o & %#o)\n", alu, m_bus, m_t));
2096	2132	break;
2097	2133
2098	2134	/**
r26072	r26073
2109	2145	m_aluc0 = 1;
2110	2146	#endif
2111	2147	flags = 0;
2112		LOG((0,2," ALU<- BUS XOR T (%#o := %#o ^ %#o)\n", alu, m_bus, m_t));
	2148	LOG((LOG_CPU,2," ALU<- BUS XOR T (%#o := %#o ^ %#o)\n", alu, m_bus, m_t));
2113	2149	break;
2114	2150
2115	2151	/**
r26072	r26073
2126	2162	m_aluc0 = (alu >> 16) & 1;
2127	2163	#endif
2128	2164	flags = ALUM2 \| TSELECT;
2129		LOG((0,2," ALU<- BUS + 1 (%#o := %#o + 1)\n", alu, m_bus));
	2165	LOG((LOG_CPU,2," ALU<- BUS + 1 (%#o := %#o + 1)\n", alu, m_bus));
2130	2166	break;
2131	2167
2132	2168	/**
r26072	r26073
2143	2179	m_aluc0 = (~m_alu >> 16) & 1;
2144	2180	#endif
2145	2181	flags = ALUM2 \| TSELECT;
2146		LOG((0,2," ALU<- BUS - 1 (%#o := %#o - 1)\n", alu, m_bus));
	2182	LOG((LOG_CPU,2," ALU<- BUS - 1 (%#o := %#o - 1)\n", alu, m_bus));
2147	2183	break;
2148	2184
2149	2185	/**
r26072	r26073
2160	2196	m_aluc0 = (m_alu >> 16) & 1;
2161	2197	#endif
2162	2198	flags = ALUM2;
2163		LOG((0,2," ALU<- BUS + T (%#o := %#o + %#o)\n", alu, m_bus, m_t));
	2199	LOG((LOG_CPU,2," ALU<- BUS + T (%#o := %#o + %#o)\n", alu, m_bus, m_t));
2164	2200	break;
2165	2201
2166	2202	/**
r26072	r26073
2177	2213	m_aluc0 = (~m_alu >> 16) & 1;
2178	2214	#endif
2179	2215	flags = ALUM2;
2180		LOG((0,2," ALU<- BUS - T (%#o := %#o - %#o)\n", alu, m_bus, m_t));
	2216	LOG((LOG_CPU,2," ALU<- BUS - T (%#o := %#o - %#o)\n", alu, m_bus, m_t));
2181	2217	break;
2182	2218
2183	2219	/**
r26072	r26073
2194	2230	m_aluc0 = (~m_alu >> 16) & 1;
2195	2231	#endif
2196	2232	flags = ALUM2;
2197		LOG((0,2," ALU<- BUS - T - 1 (%#o := %#o - %#o - 1)\n", alu, m_bus, m_t));
	2233	LOG((LOG_CPU,2," ALU<- BUS - T - 1 (%#o := %#o - %#o - 1)\n", alu, m_bus, m_t));
2198	2234	break;
2199	2235
2200	2236	/**
r26072	r26073
2211	2247	m_aluc0 = (m_alu >> 16) & 1;
2212	2248	#endif
2213	2249	flags = ALUM2 \| TSELECT;
2214		LOG((0,2," ALU<- BUS + T + 1 (%#o := %#o + %#o + 1)\n", alu, m_bus, m_t));
	2250	LOG((LOG_CPU,2," ALU<- BUS + T + 1 (%#o := %#o + %#o + 1)\n", alu, m_bus, m_t));
2215	2251	break;
2216	2252
2217	2253	/**
r26072	r26073
2228	2264	m_aluc0 = (m_alu >> 16) & 1;
2229	2265	#endif
2230	2266	flags = ALUM2 \| TSELECT;
2231		LOG((0,2," ALU<- BUS + SKIP (%#o := %#o + %#o)\n", alu, m_bus, m_emu.skip));
	2267	LOG((LOG_CPU,2," ALU<- BUS + SKIP (%#o := %#o + %#o)\n", alu, m_bus, m_emu.skip));
2232	2268	break;
2233	2269
2234	2270	/**
r26072	r26073
2245	2281	m_aluc0 = 1;
2246	2282	#endif
2247	2283	flags = TSELECT;
2248		LOG((0,2," ALU<- BUS,T (%#o := %#o & %#o)\n", alu, m_bus, m_t));
	2284	LOG((LOG_CPU,2," ALU<- BUS,T (%#o := %#o & %#o)\n", alu, m_bus, m_t));
2249	2285	break;
2250	2286
2251	2287	/**
r26072	r26073
2262	2298	m_aluc0 = 1;
2263	2299	#endif
2264	2300	flags = 0;
2265		LOG((0,2," ALU<- BUS AND NOT T (%#o := %#o & ~%#o)\n", alu, m_bus, m_t));
	2301	LOG((LOG_CPU,2," ALU<- BUS AND NOT T (%#o := %#o & ~%#o)\n", alu, m_bus, m_t));
2266	2302	break;
2267	2303
2268	2304	/**
r26072	r26073
2279	2315	m_aluc0 = 1;
2280	2316	#endif
2281	2317	flags = ALUM2;
2282		LOG((0,0," ALU<- 0 (illegal aluf in task %s, mpc:%05o aluf:%02o)\n", task_name(m_task), m_mpc, aluf));
	2318	LOG((LOG_CPU,0," ALU<- 0 (illegal aluf in task %s, mpc:%05o aluf:%02o)\n", task_name(m_task), m_mpc, aluf));
2283	2319	break;
2284	2320
2285	2321	/**
r26072	r26073
2297	2333	m_aluc0 = 1;
2298	2334	#endif
2299	2335	flags = ALUM2;
2300		LOG((0,0," ALU<- 0 (illegal aluf in task %s, mpc:%05o aluf:%02o)\n", task_name(m_task), m_mpc, aluf));
	2336	LOG((LOG_CPU,0," ALU<- 0 (illegal aluf in task %s, mpc:%05o aluf:%02o)\n", task_name(m_task), m_mpc, aluf));
2301	2337	}
2302	2338	m_alu = static_cast<UINT16>(alu);
2303	2339
r26072	r26073
2310	2346	if (m_task == task_emu) {
2311	2347	if (f2 == f2_emu_magic) {
2312	2348	m_shifter = ((m_l << 1) \| (m_t >> 15)) & 0177777;
2313		LOG((0,2," SHIFTER <-L MLSH 1 (%#o := %#o<<1\|%#o)\n", m_shifter, m_l, m_t >> 15));
	2349	LOG((LOG_CPU,2," SHIFTER <-L MLSH 1 (%#o := %#o<<1\|%#o)\n", m_shifter, m_l, m_t >> 15));
2314	2350	break;
2315	2351	}
2316	2352	if (f2 == f2_emu_load_dns) {
r26072	r26073
2319	2355	}
2320	2356	}
2321	2357	m_shifter = (m_l << 1) & 0177777;
2322		LOG((0,2," SHIFTER <-L LSH 1 (%#o := %#o<<1)\n", m_shifter, m_l));
	2358	LOG((LOG_CPU,2," SHIFTER <-L LSH 1 (%#o := %#o<<1)\n", m_shifter, m_l));
2323	2359	break;
2324	2360
2325	2361	case f1_l_rsh_1:
2326	2362	if (m_task == task_emu) {
2327	2363	if (f2 == f2_emu_magic) {
2328	2364	m_shifter = ((m_l >> 1) \| (m_t << 15)) & 0177777;
2329		LOG((0,2," SHIFTER <-L MRSH 1 (%#o := %#o>>1\|%#o)\n", m_shifter, m_l, (m_t << 15) & 0100000));
	2365	LOG((LOG_CPU,2," SHIFTER <-L MRSH 1 (%#o := %#o>>1\|%#o)\n", m_shifter, m_l, (m_t << 15) & 0100000));
2330	2366	break;
2331	2367	}
2332	2368	if (f2 == f2_emu_load_dns) {
r26072	r26073
2335	2371	}
2336	2372	}
2337	2373	m_shifter = m_l >> 1;
2338		LOG((0,2," SHIFTER <-L RSH 1 (%#o := %#o>>1)\n", m_shifter, m_l));
	2374	LOG((LOG_CPU,2," SHIFTER <-L RSH 1 (%#o := %#o>>1)\n", m_shifter, m_l));
2339	2375	break;
2340	2376
2341	2377	case f1_l_lcy_8:
2342	2378	m_shifter = ((m_l >> 8) \| (m_l << 8)) & 0177777;
2343		LOG((0,2," SHIFTER <-L LCY 8 (%#o := bswap %#o)\n", m_shifter, m_l));
	2379	LOG((LOG_CPU,2," SHIFTER <-L LCY 8 (%#o := bswap %#o)\n", m_shifter, m_l));
2344	2380	break;
2345	2381
2346	2382	default:
r26072	r26073
2370	2406	m_l = m_alu;
2371	2407	if (flags & ALUM2) {
2372	2408	m_laluc0 = m_aluc0;
2373		LOG((0,2, " L<- ALU (%#o); LALUC0<- ALUC0 (%o)\n", m_alu, m_laluc0));
	2409	LOG((LOG_CPU,2, " L<- ALU (%#o); LALUC0<- ALUC0 (%o)\n", m_alu, m_laluc0));
2374	2410	} else {
2375	2411	m_laluc0 = 0;
2376		LOG((0,2, " L<- ALU (%#o); LALUC0<- %o\n", m_alu, m_laluc0));
	2412	LOG((LOG_CPU,2, " L<- ALU (%#o); LALUC0<- %o\n", m_alu, m_laluc0));
2377	2413	}
2378	2414	if (m_ram_related[m_task]) {
2379	2415	/* load M from ALU, if 'GOODTASK' */
2380	2416	m_m = m_alu;
2381	2417	/* also writes to S[bank][0], which can't be read */
2382	2418	m_s[m_s_reg_bank[m_task]][0] = m_alu;
2383		LOG((0,2, " M<- ALU (%#o)\n", m_alu));
	2419	LOG((LOG_CPU,2, " M<- ALU (%#o)\n", m_alu));
2384	2420	}
2385	2421	}
2386	2422
r26072	r26073
2388	2424	if (MIR_T(m_mir)) {
2389	2425	m_cram_addr = m_alu;
2390	2426	if (flags & TSELECT) {
2391		LOG((0,2, " T<- ALU (%#o)\n", m_alu));
	2427	LOG((LOG_CPU,2, " T<- ALU (%#o)\n", m_alu));
2392	2428	m_t = m_alu;
2393	2429	} else {
2394		LOG((0,2, " T<- BUS (%#o)\n", m_bus));
	2430	LOG((LOG_CPU,2, " T<- BUS (%#o)\n", m_bus));
2395	2431	m_t = m_bus;
2396	2432	}
2397	2433	}
r26072	r26073
2406	2442	m_task_mpc[m_task] = m_next;
2407	2443	m_task_next2[m_task] = m_next2;
2408	2444	m_task = m_next_task;
2409		LOG((0,1, "task switch to %02o:%s (cycle %lld)\n", m_task, task_name(m_task), cycle()));
	2445	LOG((LOG_CPU,1, "task switch to %02o:%s (cycle %lld)\n", m_task, task_name(m_task), cycle()));
2410	2446	/* get new task's mpc */
2411	2447	m_next = m_task_mpc[m_task];
2412	2448	/* get address modifier after task switch (?) */

branches/alto2/src/emu/cpu/alto2/a2disp.c
r26072	r26073
199	199
200	200	word = m_dsp.inverse;
201	201	if (FIFO_MBEMPTY_0() == 0) {
202		LOG((0,1, " DSP FIFO underrun y:%d x:%d\n", y, x));
	202	LOG((LOG_DISPL,1, " DSP FIFO underrun y:%d x:%d\n", y, x));
203	203	} else {
204	204	word ^= m_dsp.fifo[m_dsp.fifo_rd];
205	205	m_dsp.fifo_rd = (m_dsp.fifo_rd + 1) % ALTO2_DISPLAY_FIFO;
206		LOG((0,3, " DSP pull %04x from FIFO[%02o] y:%d x:%d\n",
	206	LOG((LOG_DISPL,3, " DSP pull %04x from FIFO[%02o] y:%d x:%d\n",
207	207	word, (m_dsp.fifo_rd - 1) & (ALTO2_DISPLAY_FIFO - 1), y, x));
208	208	}
209	209
r26072	r26073
269	269	{
270	270	int next, a63, a66;
271	271
272		LOG((0,5,"DSP%03o:", arg));
	272	LOG((LOG_DISPL,5,"DSP%03o:", arg));
273	273	if (020 == arg) {
274		LOG((0,2," HLC=%d", m_dsp.hlc));
	274	LOG((LOG_DISPL,2," HLC=%d", m_dsp.hlc));
275	275	}
276	276
277	277	a63 = m_disp_a63[arg];
r26072	r26073
304	304	/* VBLANK: remember hlc */
305	305	m_dsp.vblank = m_dsp.hlc \| 1;
306	306
307		LOG((0,1, " VBLANK"));
	307	LOG((LOG_DISPL,1, " VBLANK"));
308	308
309	309	/* VSYNC is always within VBLANK */
310	310	if (A2_VSYNC_HI(a66)) {
311	311	if (A2_VSYNC_LO(m_dsp.a66)) {
312		LOG((0,1, " VSYNC/ (wake DVT)"));
	312	LOG((LOG_DISPL,1, " VSYNC/ (wake DVT)"));
313	313	/*
314	314	* The display vertical task DVT is awakened once per field,
315	315	* at the beginning of vertical retrace.
r26072	r26073
317	317	m_task_wakeup \|= 1 << task_dvt;
318	318	// sdl_update(HLC1024()); // FIXME: upade odd or even field
319	319	} else {
320		LOG((0,1, " VSYNC"));
	320	LOG((LOG_DISPL,1, " VSYNC"));
321	321	}
322	322	}
323	323	} else {
r26072	r26073
331	331	* the word task can be awakened until the start of the
332	332	* next field.
333	333	*/
334		LOG((0,1, " VBLANKPULSE (wake DHT)"));
	334	LOG((LOG_DISPL,1, " VBLANKPULSE (wake DHT)"));
335	335	m_dsp.dht_blocks = 0;
336	336	m_dsp.dwt_blocks = 0;
337	337	m_task_wakeup \|= 1 << task_dht;
r26072	r26073
343	343	}
344	344	if (A2_HBLANK_LO(a63) && A2_HBLANK_HI(m_dsp.a63)) {
345	345	/* falling edge of a63 HBLANK starts unload */
346		LOG((0,1, " HBLANK\\ UNLOAD"));
	346	LOG((LOG_DISPL,1, " HBLANK\\ UNLOAD"));
347	347	m_unload_time = ALTO2_DISPLAY_BITTIME(m_dsp.halfclock ? 32 : 16);
348	348	m_unload_word = 0;
349	349	#if DEBUG_DISPLAY_TIMING
r26072	r26073
363	363	if (!m_dsp.dwt_blocks && !m_dsp.dht_blocks && FIFO_STOPWAKE_0() != 0) {
364	364	if (!(m_task_wakeup & (1 << task_dwt))) {
365	365	m_task_wakeup \|= 1 << task_dwt;
366		LOG((0,1, " (wake DWT)"));
	366	LOG((LOG_DISPL,1, " (wake DWT)"));
367	367	}
368	368	}
369	369
370	370	if (A2_SCANEND_HI(a63)) {
371		LOG((0,1, " SCANEND"));
	371	LOG((LOG_DISPL,1, " SCANEND"));
372	372	m_task_wakeup &= ~(1 << task_dwt);
373	373	}
374	374
375		LOG((0,1, "%s", (a63 & A63_HBLANK) ? " HBLANK": ""));
	375	LOG((LOG_DISPL,1, "%s", (a63 & A63_HBLANK) ? " HBLANK": ""));
376	376
377	377	if (A2_HSYNC_HI(a63)) {
378	378	if (A2_HSYNC_LO(m_dsp.a63)) {
379		LOG((0,1, " HSYNC/ (CLRBUF)"));
	379	LOG((LOG_DISPL,1, " HSYNC/ (CLRBUF)"));
380	380	/*
381	381	* The hardware sets the buffer empty and clears the DWT block
382	382	* flip-flop at the beginning of horizontal retrace for
r26072	r26073
391	391	/* stop the CPU from calling unload_word() */
392	392	m_unload_time = -1;
393	393	} else {
394		LOG((0,1, " HSYNC"));
	394	LOG((LOG_DISPL,1, " HSYNC"));
395	395	}
396	396	} else if (A2_HSYNC_HI(m_dsp.a63)) {
397	397	/*
r26072	r26073
408	408	}
409	409
410	410
411		LOG((0,1, " NEXT:%03o\n", next));
	411	LOG((LOG_DISPL,1, " NEXT:%03o\n", next));
412	412
413	413	m_dsp.a63 = a63;
414	414	m_dsp.a66 = a66;
r26072	r26073
424	424	void alto2_cpu_device::f2_evenfield_1()
425	425	{
426	426	UINT16 r = HLC1024() ^ 1;
427		LOG((0,2," evenfield branch on HLC1024 (%#o \| %#o)\n", m_next2, r));
	427	LOG((LOG_DISPL,2," evenfield branch on HLC1024 (%#o \| %#o)\n", m_next2, r));
428	428	m_next2 \|= r;
429	429	}
430	430

branches/alto2/src/emu/cpu/alto2/a2mrt.c
r26072	r26073
14	14	{
15	15	/* clear the wakeup for the memory refresh task */
16	16	m_task_wakeup &= ~(1 << m_task);
17		LOG((0,2," BLOCK %s\n", task_name(m_task)));
	17	LOG((LOG_MRT,2," BLOCK %s\n", task_name(m_task)));
18	18	}
19	19
20	20	//! called by the CPU when MRT becomes active

branches/alto2/src/emu/cpu/alto2/alto2.h
r26072	r26073
20	20	#ifndef ALTO2_DEBUG
21	21	#define ALTO2_DEBUG 1
22	22	#endif
	23	#if ALTO2_DEBUG
	24	#include "debug/debugcon.h"
	25	#endif
23	26
24	27	#define USE_PRIO_F9318 0 //!< define to 1 to use the F9318 priority encoder code
25	28	#define USE_ALU_74181 1 //!< define to 1 to use the SN74181 ALU code
r26072	r26073
188	191	* </PRE>
189	192	*/
190	193	typedef enum {
191		JKFF_0 = 0000, //!< no inputs or outputs
192		JKFF_CLK = 0001, //!< clock signal
193		JKFF_J = 0002, //!< J input
194		JKFF_K = 0004, //!< K' input
195		JKFF_S = 0010, //!< S' input
196		JKFF_C = 0020, //!< C' input
197		JKFF_Q = 0040, //!< Q output
198		JKFF_Q0 = 0100 //!< Q' output
	194	JKFF_0, //!< no inputs or outputs
	195	JKFF_CLK = (1 << 0), //!< clock signal
	196	JKFF_J = (1 << 1), //!< J input
	197	JKFF_K = (1 << 2), //!< K' input
	198	JKFF_S = (1 << 3), //!< S' input
	199	JKFF_C = (1 << 4), //!< C' input
	200	JKFF_Q = (1 << 5), //!< Q output
	201	JKFF_Q0 = (1 << 6) //!< Q' output
199	202	} jkff_t;
200	203
201	204	class alto2_cpu_device : public cpu_device
r26072	r26073
242	245
243	246	private:
244	247	#if ALTO2_DEBUG
	248	enum {
	249	LOG_0,
	250	LOG_CPU = (1 << 0),
	251	LOG_EMU = (1 << 1),
	252	LOG_T01 = (1 << 2),
	253	LOG_T02 = (1 << 3),
	254	LOG_T03 = (1 << 4),
	255	LOG_KSEC = (1 << 5),
	256	LOG_T05 = (1 << 6),
	257	LOG_T06 = (1 << 7),
	258	LOG_ETH = (1 << 8),
	259	LOG_MRT = (1 << 9),
	260	LOG_DWT = (1 << 10),
	261	LOG_CURT = (1 << 11),
	262	LOG_DHT = (1 << 12),
	263	LOG_DVT = (1 << 13),
	264	LOG_PART = (1 << 14),
	265	LOG_KWD = (1 << 15),
	266	LOG_T17 = (1 << 16),
	267	LOG_MEM = (1 << 17),
	268	LOG_RAM = (1 << 18),
	269	LOG_DRIVE = (1 << 19),
	270	LOG_DISK = (1 << 20),
	271	LOG_DISPL = (1 << 21),
	272	LOG_MOUSE = (1 << 22),
	273	LOG_ALL = ((1 << 23) - 1)
	274	};
	275	int m_log_types;
	276	int m_log_level;
245	277	void logprintf(int type, int level, const char* format, ...);
246	278	# define LOG(x) logprintf x
247	279	#else

branches/alto2/src/mess/includes/alto2.h
r26072	r26073
9	9
10	10	#include "emu.h"
11	11	#include "cpu/alto2/alto2.h"
12		#include "machine/ram.h"
	12	//#include "machine/ram.h"
13	13
14	14	class alto2_state : public driver_device
15	15	{

199869 Revisions