Context Navigation

bios.s@ 109c83b

Last change on this file since 109c83b was 109c83b, checked in by Thomas Lopatic <thomas@…>, 7 years ago
Compiled full ROM in Hatari.
Property mode set to `100644`
File size: 108.9 KB

Line
1	********************************************************************************
2	* *
3	* bios.s -- BIOS for the Buchla 700 and NASA 3D Helmet Display *
4	* ------ -------------------------------------------------- *
5	* *
6	* See VM1,VM2 and VDATE for version and date *
7	* Written by D.N. Lynx Crowe *
8	* *
9	* Very loosely based on ideas from: *
10	* *
11	* "Atari ST Internals", by Abacus Software, *
12	* "A Hitchhiker's Guide to the BIOS", by Atari, *
13	* "DOS Technical Reference", by IBM, *
14	* "DOS/360", by IBM,
15	* "CP/M" , by Digital Research, and, of course, *
16	* "Unix (tm)", by AT&T, et al. *
17	* *
18	* After all, Why re-invent the wheel? *
19	* *
20	* Some of the functions are the same as Ataris, but quite a few are different, *
21	* and our I/O configuration is much different, so BEWARE! Make no *
22	* assumptions, and read the documentation and comments very carefully. *
23	* *
24	* Especially watch out for the extended BIOS functions. Most of them *
25	* are nothing at all like the Atari / GEMDOS extended bios functions, *
26	* and even the ones that are similar have different numbers. *
27	********************************************************************************
28	*
29	.text
30	*
31	* Version and date
32	* ----------------
33	VM1 .equ 18 * First part of version number
34	VM2 .equ 0 * Second part of version number
35	VDATE .equ $19880620 * Version date
36	*
37	BUCHLA .equ 1 * Non-Zero for Buchla 700, 0 for NASA
38	NASASIO .equ 0 * Non-zero for NASA, 0 for Buchla addr.
39	*
40	FL_SKR .equ $00 * Seek rate (WD1772, 6Ms/step)
41	*************************************************************************
42	*
43	.page
44	*
45	.xref start_ * Where ROMP starts
46	.xref _errno * Start of ROMP bss space
47	*
48	.xdef basepage * Pseudo base page for romp
49	.xdef _rsflag * Register save area overflow flag
50	*
51	.ifne BUCHLA
52	*
53	.xdef _hdvini * Disk init
54	*
55	.endc
56	*
57	.xdef _wzcrsh * ROMP crash flag
58	.xdef _crshvc * Crash vector
59	.xdef _crshsr * Crash SR
60	.xdef _crshpc * Crash PC
61	.xdef _crshsp * Crash SP
62	.xdef _crshus * Crash USP
63	.xdef _crshrg * Crash SP registers
64	.xdef _crshst * Crash top of stack
65	*
66	.page
67	*
68	.ifne BUCHLA
69	*
70	.xdef _hz_1k
71	.xdef _hz_200
72	.xdef frclock
73	.xdef t1count
74	.xdef t2count
75	.xdef t3count
76	*
77	.xdef nflops
78	.xdef disknum
79	.xdef booted
80	.xdef seekrate
81	.xdef flock
82	.xdef fverify
83	*
84	.xdef retrycnt
85	.xdef wpstatus
86	.xdef wplatch
87	.xdef bootdev
88	*
89	.xdef cdev
90	.xdef ctrack
91	.xdef csect
92	.xdef cside
93	.xdef ccount
94	*
95	.xdef cdma
96	.xdef edma
97	.xdef tmpdma
98	.xdef rseed
99	*
100	.xdef savptr
101	*
102	.xdef flpsrsv
103	.xdef flpregs
104	*
105	.xdef dsb0
106	.xdef dsb1
107	*
108	.xdef dskmode
109	.xdef dskerrs
110	.xdef drvbpbs
111	*
112	.endc
113	*
114	.xdef biostop
115	*
116	.page
117	*
118	* Some critical equates:
119	* ----------------------
120	* Interrupt masks
121	* ---------------
122	IPL3 .equ $0300 * IPL 3 value for sr
123	IPL4 .equ $0400 * IPL 4 value for sr
124	IPL7 .equ $0700 * IPL 7 value for sr (4 for debug)
125	*
126	.ifne BUCHLA
127	*
128	INITIPL .equ IPL3+$2000 * Initial Internal Priority Level
129	*
130	.endc
131	*
132	.ifeq BUCHLA
133	*
134	INITIPL .equ IPL4+$2000 * Initial Internal Priority Level
135	*
136	.endc
137	*
138	* Memory allocation
139	* -----------------
140	.ifeq BUCHLA
141	*
142	TPA .equ $008000 * Put TPA 32K up from the bottom
143	*
144	.endc
145	*
146	.ifne BUCHLA
147	*
148	TPA .equ $010000 * Put TPA 64K up from the bottom
149	*
150	.endc
151	*
152	SSTACK .equ TPA * Put system stack just below TPA
153	*
154	p_bbase .equ $0018 * Basepage offset to bss base
155	p_blen .equ $001C * Basepage offset to bss length
156	*
157	* It's magic ...
158	* --------------
159	FMAGIC .equ $87654321 * Magic for formatting
160	RETRYIT .equ $10000 * Magic for re-try from criter
161	RSMAGIC .equ $78563412 * Magic for register save area OK
162	*
163	* Miscellaneous constants
164	* -----------------------
165	FCMAX .equ $00FFFFFF * Maximum frame counter value (24 bits)
166	*
167	.page
168	*
169	* CFR0 Baud Rates:
170	* ----------------
171	BR_300 .equ $04
172	BR_600 .equ $05
173	BR_1200 .equ $06
174	BR_1800 .equ $07
175	BR_2400 .equ $08
176	BR_3600 .equ $09
177	BR_4800 .equ $0A
178	BR_7200 .equ $0B
179	BR_9600 .equ $0C
180	BR_19K2 .equ $0D
181	BR_EXT .equ $0F
182	*
183	* CFR0 Stop bits (includes TBR select bit):
184	* -----------------------------------------
185	NSB_1 .equ $40
186	NSB_2 .equ $60
187	*
188	* CFR1 Number of Data Bits (includes MSB):
189	* ----------------------------------------
190	NDB_5 .equ $80
191	NDB_6 .equ $A0
192	NDB_7 .equ $C0
193	NDB_8 .equ $E0
194	*
195	* CFR1 Parity Selection:
196	* ----------------------
197	P_ODD .equ $04
198	P_EVEN .equ $0C
199	P_MARK .equ $14
200	P_SPACE .equ $1C
201	*
202	P_NONE .equ $00
203	*
204	* Line Discipline:
205	* ----------------
206	L_NUL .equ $00 * No protocol
207	L_XON .equ $01 * XON/XOFF
208	L_RTS .equ $02 * RTS/CTS
209	*
210	.page
211	*
212	* I/O Buffer Sizes:
213	* -----------------
214	SR1IBS .equ 256
215	SR1OBS .equ 256
216	SR2IBS .equ 256
217	SR2OBS .equ 256
218	*
219	.ifne BUCHLA
220	*
221	MC1IBS .equ 512
222	MC1OBS .equ 256
223	MC2IBS .equ 512
224	MC2OBS .equ 256
225	*
226	.endc
227	*
228	* Line Disciplines:
229	* -----------------
230	SR1DISC .equ L_XON
231	SR2DISC .equ L_XON
232	*
233	.ifne BUCHLA
234	*
235	MC1DISC .equ L_NUL
236	MC2DISC .equ L_NUL
237	*
238	.endc
239	*
240	* CFR Setings:
241	* ------------
242	SR1CFR0 .equ BR_9600+NSB_1
243	SR1CFR1 .equ NDB_8+P_NONE
244	SR2CFR0 .equ BR_9600+NSB_1
245	SR2CFR1 .equ NDB_8+P_NONE
246	*
247	.ifne BUCHLA
248	*
249	MC1CFR0 .equ BR_EXT+NSB_1
250	MC1CFR1 .equ NDB_8+P_NONE
251	MC2CFR0 .equ BR_EXT+NSB_1
252	MC2CFR1 .equ NDB_8+P_NONE
253	*
254	.endc
255	*
256	.page
257	*
258	* I/O Addresses:
259	* --------------
260	VSDDINIT .equ $200400 * VSDD initial register base address
261	VSDDDATA .equ $200000 * VSDD data segment base address
262	*
263	.ifeq BUCHLA
264	*
265	.ifeq NASASIO
266	*
267	SR1ACIA .equ $3A8001 * Serial-1 ACIA base address (BUCHLA)
268	SR2ACIA .equ $3A8009 * Serial-2 ACIA base address
269	*
270	.endc
271	*
272	.ifne NASASIO
273	*
274	SR1ACIA .equ $398001 * Serial-1 ACIA base address (NASA)
275	SR2ACIA .equ $398009 * Serial-2 ACIA base address
276	*
277	.endc
278	*
279	.endc
280	*
281	.ifne BUCHLA
282	*
283	FPUBASE .equ $180000 * FPU base address
284	TIMER .equ $3A0001 * Timer base address
285	LCD .equ $3A4001 * LCD driver base address
286	SR1ACIA .equ $3A8001 * Serial-1 ACIA base address (BUCHLA)
287	SR2ACIA .equ $3A8009 * Serial-2 ACIA base address
288	MC1ACIA .equ $3AC001 * MIDI-1 ACIA base address
289	MC2ACIA .equ $3AC009 * MIDI-2 ACIA base address
290	FLOPPY .equ $3B0001 * Floppy controller base address
291	PSG .equ $3B4001 * Sound chip base address
292	LEDS .equ $3B8001 * LED driver base address
293	ANALOG .equ $3BC001 * Analog processor base address
294	*
295	* FPU address offsets and misc. values
296	*
297	FPU_CTL .equ $4000 * FPU control
298	*
299	FPU_IN .equ $4000 * FPU input address
300	FPU_CLR .equ $6000 * FPU interrupt reset address
301	*
302	FPU_RST .equ $0015 * FPU reset value
303	*
304	* PSG address offsets
305	*
306	PSG_RD .equ PSG * Read PSG data
307	PSG_WL .equ PSG * Write PSG address latch
308	PSG_WD .equ PSG+2 * Write PSG data
309	*
310	.endc
311	*
312	* VSDD data structure offsets
313	*
314	VSDD_REG .equ VSDDDATA * Registers
315	VSDD_AT .equ VSDDDATA+$0100 * Access Table
316	*
317	.ifne BUCHLA
318	*
319	* Timer registers
320	*
321	TIME_CRX .equ TIMER * Control register 1 or 3
322	TIME_CR2 .equ TIMER+2 * Control register 2
323	TIME_T1H .equ TIMER+4 * Timer 1 high byte
324	TIME_T1L .equ TIMER+6 * Timer 1 low byte
325	TIME_T2H .equ TIMER+8 * Tiemr 2 high byte
326	TIME_T2L .equ TIMER+10 * Timer 2 low byte
327	TIME_T3H .equ TIMER+12 * Timer 3 high byte
328	TIME_T3L .equ TIMER+14 * Timer 3 low byte
329	*
330	.endc
331	*
332	* ACIA Register offsets:
333	* ----------------------
334	ACIA_IER .equ 0 * ACIA IER offset
335	ACIA_ISR .equ 0 * ACIA ISR offset
336	ACIA_CSR .equ 2 * ACIA CSR offset
337	ACIA_CFR .equ 2 * ACIA CFR offset
338	ACIA_TBR .equ 4 * ACIA TBR offset
339	ACIA_TDR .equ 6 * ACIA TDR offset
340	ACIA_RDR .equ 6 * ACIA RDR offset
341	*
342	.page
343	*
344	.ifne BUCHLA
345	*
346	* Floppy register offsets:
347	* ------------------------
348	DSKCMD .equ 0 * Command / status
349	DSKTRK .equ 2 * Track
350	DSKSEC .equ 4 * Sector
351	DSKDAT .equ 6 * Data
352	*
353	* Miscellaneous equates:
354	* ----------------------
355	FL_NC .equ $02 * Non-compensated R/W/F bit
356	*
357	APISIZE .equ 256 * Analog processor buffer size
358	*
359	* Floppy commands:
360	* ----------------
361	FL_RS .equ $80 * Read sector
362	FL_RM .equ $90 * Read multiple
363	FL_WS .equ $A0 * Write sector
364	FL_WT .equ $F0 * Write track (format)
365	FL_FR .equ $D0 * Force reset
366	FL_SK .equ $10 * Seek
367	FL_SV .equ $14 * Seek w/verify
368	*
369	.endc
370	*
371	.page
372	*
373	* iorec structure definitions:
374	* ----------------------------
375	IORECLN .equ 40 * Length of an iorec structure
376	*
377	ibuf .equ 0 * Input buffer base address
378	ibufsize .equ 4 * Input buffer size (bytes)
379	ibufhd .equ 6 * Input buffer head index
380	ibuftl .equ 8 * Input buffer tail index
381	ibuflow .equ 10 * Input buffer low water mark
382	ibufhi .equ 12 * Input buffer high water mark
383	obuf .equ 14 * Output buffer base address
384	obufsize .equ 18 * Output buffer size (bytes)
385	obufhd .equ 20 * Output buffer head index
386	obuftl .equ 22 * Output buffer tail index
387	obuflow .equ 24 * Output buffer low water mark
388	obufhi .equ 26 * Output buffer high water mark
389	cfr0 .equ 28 * ACIA CFR, MS bit = 0
390	cfr1 .equ 29 * ACIA CFR, MS bit = 1
391	flagxon .equ 30 * XON flag (non-zero = XOFF sent)
392	flagxoff .equ 31 * XOFF flag (non-zero = active)
393	linedisc .equ 32 * Line discipline flags
394	erbyte .equ 33 * Last error byte
395	isr .equ 34 * ACIA ISR on interrupt
396	csr .equ 35 * ACIA CSR on interrupt
397	errct .equ 36 * Error count (FRM/OVR/BRK)
398	ibfct .equ 38 * Input buffer full count
399	*
400	.page
401	*
402	* Error codes:
403	* ------------
404	ERR01 .equ -1 * All purpose error
405	ERR02 .equ -2 * Drive not ready
406	ERR03 .equ -3 * Unknown command
407	ERR04 .equ -4 * CRC Error
408	ERR05 .equ -5 * Invalid request
409	ERR06 .equ -6 * Seek error
410	ERR07 .equ -7 * Unknown media
411	ERR08 .equ -8 * Sector not found
412	ERR09 .equ -9 * End of media (out of paper)
413	ERR10 .equ -10 * Write fault
414	ERR11 .equ -11 * Read fault
415	ERR12 .equ -12 * General mishap
416	ERR13 .equ -13 * Write protected
417	ERR14 .equ -14 * Media changed
418	ERR15 .equ -15 * Unknown device
419	ERR16 .equ -16 * Bad sectors
420	ERR17 .equ -17 * Insert disk
421	*
422	.page
423	*
424	* In the Beginning...
425	* -------------------
426	*
427	* Low PROM -- Contains the initial sp (unused), and the initial pc,
428	* as well as some version and creation date stuff and a copyright message,
429	* just to be thorough about it.
430	*
431	begin: bra.s biosinit * Jump to bios init
432	*
433	vermsg: dc.b VM1,VM2 * Version number
434	*
435	dc.l biosinit * Reset address (bios init)
436	*
437	created: dc.l VDATE * Creation date
438	*
439	copyrite: dc.b '{Copyright 1988 by ' * Copyright message
440	dc.b 'D.N. Lynx Crowe}',0
441	*
442	dc.l 0 * Some padding
443	*
444	.page
445	.even
446	*
447	* biosinit -- Setup the defaults for the BIOS
448	* -------- -------------------------------
449	biosinit: move.w #$2700,sr * Set sup mode, no interrupts
450	move.l #SSTACK,a7 * Setup supervisor stack pointer
451	*
452	lea badtrap,a1 * Set default trap vector
453	adda.l #$02000000,a1 * ... with trap # in 31..24
454	lea 8,a0 * ... for traps 2..255
455	move.l #253,d1
456	*
457	binit1: move.l a1,(a0)+ * Store trap vector
458	adda.l #$01000000,a1 * Increment trap #
459	dbf d1,binit1 * Loop until done
460	*
461	lea biosram,a0 * Clear BIOS ram ...
462	lea SSTACK-2,a1 * ... from biosram to SSTACK-1
463	*
464	binit2: move.w #0,(a0)+ * Zero a word
465	cmpa.l a0,a1 * Last one ?
466	bne binit2 * Loop if not
467	*
468	move.l #rsarea,savptr * Setup pointer to register area
469	move.l #RSMAGIC,_rsflag * Set magic in _rsflag
470	*
471	move.l #nullrts,timevec * Set timer interrupt vector
472	move.l #nullrts,critvec * Set critical error vector
473	move.l #nullrts,termvec * Set process terminate vector
474	move.l #nullrts,resvec3 * Set software vector 3
475	move.l #nullrts,resvec4 * Set software vector 4
476	move.l #nullrts,resvec5 * Set software vector 5
477	move.l #nullrts,resvec6 * Set software vector 6
478	move.l #nullrts,resvec7 * Set software vector 7
479	*
480	move.l #hardhlt,$0008 * Set bus error vector
481	move.l #nullrte,$0014 * Set divide error vector
482	move.l #nullrte,$0018 * Set CHK vector
483	move.l #nullrte,$001C * Set TRAPV vector
484	move.l #nullrte,$0024 * Set trace vector
485	*
486	move.l #nullrte,$0030 * Set reserved vector 12
487	move.l #nullrte,$0034 * Set reserved vector 13
488	move.l #nullrte,$0038 * Set reserved vector 14
489	*
490	move.l #nullrte,$003C * Set uninitialized int. vector
491	*
492	move.l #nullrte,$0040 * Set reserved vector 16
493	move.l #nullrte,$0044 * Set reserved vector 17
494	move.l #nullrte,$0048 * Set reserved vector 18
495	move.l #nullrte,$004C * Set reserved vector 19
496	move.l #nullrte,$0050 * Set reserved vector 20
497	move.l #nullrte,$0054 * Set reserved vector 21
498	move.l #nullrte,$0058 * Set reserved vector 22
499	move.l #nullrte,$005C * Set reserved vector 23
500	*
501	move.l #nullrte,$0060 * Set spurious int. vector
502	*
503	move.l #serintr,$0074 * Set ACIA interrupt vector
504	move.l #nullrte,$0078 * Set level 6 vector
505	move.l #nullrte,$007C * Set level 7 vector
506	*
507	move.l #trap13,$00B4 * Set trap13 vector
508	move.l #trap14,$00B8 * Set trap14 vector
509	*
510	.page
511	*
512	.ifne BUCHLA
513	*
514	move.l #nullfpu,$0068 * Set FPU interrupt vector
515	move.l #api_int,$006C * Set analog trap vector
516	move.l #timeint,$0070 * Set timer trap vector
517	*
518	move.l #_hdvini,hdv_init * Set disk init vector
519	move.l #getbpb,hdv_bpb * Set get BPB vector
520	move.l #rwabs,hdv_rw * Set disk I/O vector
521	move.l #bootload,hdv_boot * Setup boot load vector
522	move.l #mediach,hdv_mchg * Setup media change vector
523	*
524	move.w #$FFFF,fverify * Set read after write flag
525	move.w #FL_SKR,seekrate * Set default seek rate
526	move.w #$FFFF,booted * Say we're not booted yet
527	move.l #buffer,dskbufp * Setup default disk buffer
528	*
529	.page
530	*
531	move.b #7,PSG_WL * Select PSG R7
532	move.b #$80,PSG_WD * Write $80 (port B = output)
533	move.b #15,PSG_WL * Select PSG R15
534	move.b #$00,PSG_WD * Write $00 (sync enable)
535	*
536	move.b #$00,TIME_T1H * Setup timer 1 (PLL)
537	move.b #$1F,TIME_T1L * ... for divide by 64
538	move.b #$0C,TIME_T2H * Setup timer 2 (FC)
539	move.b #$7F,TIME_T2L * ... for divide by 3200
540	move.b #$03,TIME_T3H * Setup timer 3 (RTC)
541	move.b #$20,TIME_T3L * ... for 1Ms interval
542	move.b #$42,TIME_CRX * Setup CR3
543	move.b #$41,TIME_CR2 * Setup CR2
544	move.b #$81,TIME_CRX * Setup CR1
545	move.b #$80,TIME_CRX * Start the timers
546	*
547	.endc
548	*
549	lea sr1iorec,a0 * Serial-1 iorec address to a0
550	lea SR1ACIA,a1 * Serial-1 ACIA address to a1
551	lea sr1dflt,a2 * Serial-1 dflt table addr to a2
552	bsr.w aciainit * Go initialize the port
553	*
554	lea sr2iorec,a0 * Serial-2 iorec address to a0
555	lea SR2ACIA,a1 * Serial-2 ACIA address to a1
556	lea sr2dflt,a2 * Serial-2 dflt table addr to a2
557	bsr.w aciainit * Go initialize the port
558	*
559	.ifne BUCHLA
560	*
561	lea mc1iorec,a0 * MIDI-1 iorec address to a0
562	lea MC1ACIA,a1 * MIDI-1 ACIA address to a1
563	lea mc1dflt,a2 * MIDI-1 dflt table addr to a2
564	bsr.w aciainit * Go initialize the port
565	*
566	lea mc2iorec,a0 * MIDI-2 iorec address to a0
567	lea MC2ACIA,a1 * MIDI-2 ACIA address to a1
568	lea mc2dflt,a2 * MIDI-2 dflt table addr to a2
569	bsr.w aciainit * Go initialize the port
570	*
571	.page
572	*
573	lea VSDDINIT,a1 * Setup to load VSDD regs
574	lea vsddtab,a0 * ... from vsddtab
575	move.w #15,d0 * ... all 16 registers
576	*
577	vsddinit: move.w (a0)+,(a1)+ * Load the VSDD registers
578	btst.l #0,d0
579	btst.l #0,d0
580	btst.l #0,d0
581	dbf d0,vsddinit
582	*
583	move.w vsddit02,VSDDINIT * Enable the video
584	*
585	move.l #api_fum,api_fi * Clear analog processor fifo
586	move.l #api_fum,api_fo * ...
587	*
588	move.w #23,d0 * Setup to clear key LEDs
589	move.b #$80,d1 * ...
590	*
591	ledclear: move.b d1,LEDS * Clear a LED
592	addq.b #1,d1 * Increment LED number
593	dbra d0,ledclear * Loop until all are done
594	*
595	move.w #7,d0 * Setup to clear pot LEDs
596	move.b #$18,d1 * ...
597	*
598	ledclr2: move.b d1,LEDS * Clear a LED
599	addq.b #1,d1 * Increment LED number
600	dbra d0,ledclr2 * Loop until all are done
601	*
602	clr.w fc_sw * Stop the frame clock
603	clr.l fc_val * ... and reset it
604	*
605	.page
606	*
607	lea FPUBASE+FPU_CTL,a0 * Point at FPU master level
608	move.w #$0000,$08(a0) * Set CV1 to 0
609	addq.w #1,d0 * Delay
610	addq.w #1,d0 * ...
611	move.w #$0000,$0A(a0) * Set SF1 to 0
612	addq.w #1,d0 * Delay
613	addq.w #1,d0 * ...
614	move.w #$0000,$0C(a0) * Set CV2 to 0
615	addq.w #1,d0 * Delay
616	addq.w #1,d0 * ...
617	move.w #$0000,$0E(a0) * Set SF2 to 0
618	addq.w #1,d0 * Delay
619	addq.w #1,d0 * ...
620	move.w #$0000,$10(a0) * Set CV3 to 0
621	addq.w #1,d0 * Delay
622	addq.w #1,d0 * ...
623	move.w #$0000,$12(a0) * Set SF3 to 0
624	addq.w #1,d0 * Delay
625	addq.w #1,d0 * ...
626	move.w #$8300,$02(a0) * Set new value '10' to -10.00
627	addq.w #1,d0 * Delay
628	addq.w #1,d0 * ...
629	move.w #$8300,$1C(a0) * Set new value '01' to -10.00
630	addq.w #1,d0 * Delay
631	addq.w #1,d0 * ...
632	move.w #$0001,$16(a0) * Set exponent for shortest time
633	addq.w #1,d0 * Delay
634	addq.w #1,d0 * ...
635	move.w #$FFF0,$14(a0) * Set mantissa for shortest time
636	addq.w #1,d0 * Delay
637	addq.w #1,d0 * ...
638	move.w #$0005,$00(a0) * Send control word to FPU
639	*
640	.endc
641	*
642	.page
643	*
644	move.w #INITIPL,sr * Enable interrupts
645	lea basepage,a1 * Pass start_ a pseudo base page
646	move.l #_errno,p_bbase(a1) * ...
647	clr.l p_blen(a1) * ...
648	move.l a1,-(a7) * ...
649	jsr start_ * Go start ROMP (we assume ...)
650	*
651	jmp biosinit * Just in case we return ...
652	*
653	.page
654	*
655	.ifne BUCHLA
656	*
657	* nullfpu -- Null FPU trap handler
658	* ------- ---------------------
659	nullfpu: movem.l d0-d0/a0-a0,-(a7) * Save registers
660	movea.l #FPUBASE,a0 * Setup FPU base address in a0
661	move.w FPU_IN(a0),d0 * Read FPU interrupt port
662	andi.l #$000000FF,d0 * Mask for voice & parameter
663	lsl.l #5,d0 * Shift for word offset
664	addi.l #FPU_CTL,d0 * Add FPU control offset
665	move.w #FPU_RST,0(a0,d0.L) * Reset the function
666	clr.w FPU_CLR(a0) * Clear the interrupt
667	movem.l (a7)+,d0-d0/a0-a0 * Restore registers
668	rte * Return to interrupted code
669	*
670	.endc
671	*
672	.page
673	*
674	* hardhlt -- Bus error trap handler
675	* ------- ----------------------
676	hardhlt: stop #$2700 * stop dead -- system is AFU
677	bra hardhlt * ...
678	*
679	* badtrap -- Bad trap handler
680	* ------- ----------------
681	badtrap: move.w (a7)+,_crshsr * Get crash SR
682	move.l (a7)+,_crshpc * Get crash PC
683	move.l a7,_crshsp * Get crash SP
684	bsr badtr1 * Get TRAP PC with vector number
685	nop
686	*
687	badtr1: move.l (a7)+,_crshvc * Save for analysis of vector #
688	movem.l d0-d7/a0-a7,_crshrg * Save crash registers
689	move.l usp,a0 * Preserve crash USP
690	move.l a0,_crshus * ...
691	move.l a7,d0 * Get SP
692	andi.l #$FFFFFFFE,d0 * ... make sure it's even
693	movea.l d0,a1 * ...
694	move.w #15,d0 * Save top 16 words
695	lea _crshst,a0 * ... of crash stack in _crshst
696	*
697	badtr2: move.w (a1)+,(a0)+ * Save a stack value
698	dbf d0,badtr2 * Loop until all are saved
699	*
700	clr.l d0 * Get TRAP number
701	move.b _crshvc,d0 * ... as LS byte of d0
702	move.l _crshpc,a0 * Save crash PC in a0
703	move.w #$FFFF,_wzcrsh * Indicate we crashed
704	move.l #rsarea,savptr * Restore system save pointer
705	move.l #SSTACK,a7 * Reset the stack pointer
706	move.l #RSMAGIC,_rsflag * ... and the stack sentinel
707	trap #15 * TRAP to ROMP
708	*
709	jmp biosinit * Recover with a cold start
710	*
711	.page
712	*
713	.ifne BUCHLA
714	*
715	* timeint -- Timer interrupt handler
716	* ------- -----------------------
717	timeint: movem.l d0-d7/a0-a6,-(a7) * Save registers
718	move.b TIME_CR2,d0 * Get timer interrupt status
719	btst.l #2,d0 * Check timer 3 status
720	beq tmi02 * Jump if not active
721	*
722	move.b TIME_T3H,d1 * Read timer 1 count
723	lsl.l #8,d1 * ...
724	move.b TIME_T3L,d1 * ...
725	move.w d1,t3count * ... and save it
726	*
727	addq.l #1,_hz_1k * Update 1ms clock (1 KHz)
728	*
729	move.w tdiv1,d1 * Update divider
730	addq.w #1,d1 * ...
731	move.w d1,tdiv1 * ...
732	*
733	cmpi.w #5,d1 * Do we need to update _hz_200 ?
734	blt tmi02 * Jump if not
735	*
736	addq.l #1,_hz_200 * Update 5ms clock (200 Hz)
737	*
738	move.w tdiv2,d1 * Update divider
739	addq.w #1,d1 * ...
740	move.w d1,tdiv2 * ...
741	*
742	cmpi.w #4,d1 * Do we need to update frclock ?
743	blt tmi01 * Jump if not
744	*
745	addq.l #1,frclock * Update 20 Ms clock (50 Hz)
746	tst.w flock * See if floppy is active
747	bne tmi00 * Don't call flopvbl if so
748	*
749	bsr flopvbl * Check on the floppy
750	*
751	tmi00: move.w #0,tdiv2 * Reset tdiv2
752	*
753	tmi01: move.w #0,tdiv1 * Reset tdiv1
754	*
755	.page
756	*
757	tmi02: btst.l #0,d0 * Check timer 1 int
758	beq tmi03 * Jump if not set
759	*
760	move.b TIME_T1H,d1 * Read timer 1 to clear int.
761	lsl.l #8,d1 * ...
762	move.b TIME_T1L,d1 * ...
763	move.w d1,t1count * ... and save the count
764	*
765	tmi03: btst.l #1,d0 * Check for timer 2 int.
766	beq tmi04 * Jump if not set
767	*
768	move.b TIME_T2H,d1 * Read timer 2 to clear int.
769	lsl.l #8,d1 * ...
770	move.b TIME_T2L,d1 * ...
771	move.w d1,t2count * ... and save the count
772	*
773	tst.w fc_sw * Should we update the frame ?
774	beq tmi04 * Jump if not
775	*
776	bmi tmi05 * Jump if we count down
777	*
778	move.l fc_val,d0 * Get the frame count
779	cmp.l #FCMAX,d0 * See it we've topped out
780	bge tmi06 * Jump if limit was hit
781	*
782	addq.l #1,d0 * Count up 1 frame
783	move.l d0,fc_val * Store updated frame count
784	bra tmi04 * Done
785	*
786	tmi06: move.l #FCMAX,fc_val * Force hard limit, just in case
787	bra tmi04 * Done
788	*
789	tmi05: move.l fc_val,d0 * Get the frame count
790	beq tmi04 * Done if already zero
791	*
792	subq.l #1,d0 * Count down 1 frame
793	move.l d0,fc_val * Store udpated frame count
794	*
795	movea.l timevec,a0 * Do RTC vector
796	move.w #1,-(a7) * ... pass 1 msec on stack
797	jsr (a0) * ...
798	addq.l #4,a7 * ...
799	*
800	tmi04: movem.l (a7)+,d0-d7/a0-a6 * Restore registers
801	rte * Return to interrupted code
802	*
803	.endc
804	*
805	.page
806	*
807	* trap14 -- Extended BIOS entry point
808	* ------ -------------------------
809	trap14: lea t14tab,a0 * Setup trap 14 table address
810	bra trapent * Go process trap
811	*
812	* trap13 -- Main BIOS entry point
813	* ------ ---------------------
814	trap13: lea t13tab,a0 * Setup trap 13 table address
815	*
816	trapent: move.l savptr,a1 * Get save area pointer
817	move.w (a7)+,d0 * Status register to D0
818	move.w d0,-(a1) * Save in save area
819	move.l (a7)+,-(a1) * Stash PC in save area
820	movem.l d3-d7/a3-a7,-(a1) * Save parameter register
821	move.l a1,savptr * Update save pointer
822	btst #13,d0 * Were we in sup. mode ?
823	bne trwzsup * Jump if so
824	*
825	move.l usp,a7 * Move user sp to stack ptr.
826	*
827	trwzsup: move.w (a7)+,d0 * Get function number from stack
828	cmp.w (a0)+,d0 * Check against limit
829	bge trpexit * Jump if it's invalid
830	*
831	lsl.w #2,d0 * Multiply by 4 for use as index
832	move.l 0(a0,d0),d0 * Get routine address
833	move.l d0,a0 * ... into a0
834	bpl trpnind * Jump if it's indirect
835	*
836	move.l (a0),a0 * Use indirect value
837	*
838	trpnind: sub.l a5,a5 * Clear a5
839	jsr (a0) * Execute the routine
840	*
841	trpexit: move.l savptr,a1 * Get SAVPTR into a1
842	movem.l (a1)+,d3-d7/a3-a7 * Restore registers
843	move.l (a1)+,-(a7) * Push return onto stack
844	move.w (a1)+,-(a7) * Push status onto stack
845	move.l a1,savptr * Update SAVPTR
846	*
847	* nullrte -- null rte
848	* ------- --------
849	nullrte: rte * Return to interrupted code
850	*
851	* nullrts -- null return
852	* ------- -----------
853	nullrts: rts * Just return to the caller
854	*
855	.page
856	*
857	* bconstat -- Get character device input status
858	* -------- ---------------------------------
859	bconstat: lea cdt01,a0 * Point at status table
860	bra condisp * Jump to dispatcher
861	*
862	* bconin -- Get input from character device
863	* ------ -------------------------------
864	bconin: lea cdt02,a0 * Point at input table
865	bra condisp * Jump to dispatcher
866	*
867	* bconout -- Output to character device
868	* ------- --------------------------
869	bconout: lea cdt03,a0 * Point at output table
870	bra condisp * Jump to dispatcher
871	*
872	* bcostat -- Get character device output status
873	* ------- ----------------------------------
874	bcostat: lea cdt04,a0 * Point at status table
875	*
876	* condisp -- Character device function dispatcher
877	* ------- ------------------------------------
878	condisp: move.w 4(a7),d0 * Get device number
879	lsl.w #2,d0 * ... times 4 for pointer
880	move.l 0(a0,d0),a0 * Get routine address
881	jmp (a0) * Jump to it
882	*
883	.page
884	*
885	* sr1ist -- Check CON (Serial-1) input buffer status
886	* ------ ----------------------------------------
887	sr1ist: lea sr1iorec,a0 * Address of iorec to a0
888	lea SR1ACIA,a1 * Address of ACIA to a1
889	bra chkist * Go check buffer status
890	*
891	* sr2ist -- Check AUX (Serial-2) input buffer status
892	* ------ ----------------------------------------
893	sr2ist: lea sr2iorec,a0 * Address of iorec to a0
894	lea SR2ACIA,a1 * Address of ACIA to a1
895	*
896	.ifne BUCHLA
897	*
898	bra chkist * Go check buffer status
899	*
900	* mc1ist -- Check MC1 (MIDI-1) input buffer status
901	* ------ --------------------------------------
902	mc1ist: lea mc1iorec,a0 * Address of iorec to a0
903	lea MC1ACIA,a1 * Address of ACIA to a1
904	bra chkist * Go check buffer status
905	*
906	* mc2ist -- Check MC2 (MIDI-2) input buffer status
907	* ------ --------------------------------------
908	mc2ist: lea mc2iorec,a0 * Address of iorec to a0
909	lea MC2ACIA,a1 * Address of ACIA to a1
910	*
911	.endc
912	*
913	* chkist -- Check input buffer status
914	* ------ -------------------------
915	chkist: moveq.l #-1,d0 * Default to "Input available"
916	lea ibufhd(a0),a2 * Head index to a2
917	lea ibuftl(a0),a3 * Tail index to a3
918	cmpm.w (a3)+,(a2)+ * Buffer clear ?
919	bne chkist1 * Jump if not
920	*
921	moveq.l #0,d0 * Set to "Buffer empty"
922	*
923	chkist1: rts * Return to caller
924	*
925	.page
926	*
927	* sr1ost -- Check CON (Serial-1) output buffer status
928	* ------ -----------------------------------------
929	sr1ost: lea sr1iorec,a0 * Address of iorec to a0
930	bra chkost * Go check buffer status
931	*
932	* sr2ost -- Check AUX (Serial-2) output buffer status
933	* ------ -----------------------------------------
934	sr2ost: lea sr2iorec,a0 * Address of iorec to a0
935	*
936	.ifne BUCHLA
937	*
938	bra chkost * Go check buffer status
939	*
940	* mc1ost -- Check MC1 (MIDI-1) output buffer status
941	* ------ ---------------------------------------
942	mc1ost: lea mc1iorec,a0 * Address of iorec to a0
943	bra chkost * Go check buffer status
944	*
945	* mc2ost -- Check MC2 (MIDI-2) output buffer status
946	* ------ ---------------------------------------
947	mc2ost: lea mc2iorec,a0 * Address of iorec to a0
948	*
949	.endc
950	*
951	* chkost -- Check output buffer status
952	* ------ --------------------------
953	chkost: moveq.l #-1,d0 * Default to "Output OK"
954	move.w obuftl(a0),d2 * Tail index to d2
955	bsr wrapout * Test for pointer wraparound
956	cmp.w obufhd(a0),d2 * Compare with head index
957	bne chkost1 * Jump if not equal
958	*
959	moveq.l #0,d0 * Set to "Buffer full"
960	*
961	chkost1: rts * Return to caller
962	*
963	.page
964	*
965	* wrapin -- Check input pointer for wraparound
966	* ------ ----------------------------------
967	wrapin: add.w #1,d1 * Head index +1
968	cmp.w ibufsize(a0),d1 * = buffer size ?
969	bcs wrapin1 * Jump if not
970	*
971	moveq.l #0,d1 * Wraparound
972	*
973	wrapin1: rts * Return to caller
974	*
975	* wrapout -- Check output pointer for wraparound
976	* ------- -----------------------------------
977	wrapout: addq.w #1,d2 * Tail index +1
978	cmp.w obufsize(a0),d2 * = buffer size ?
979	bcs wrapout1 * Jump if not
980	*
981	moveq.l #0,d2 * Wrap around if so
982	*
983	wrapout1: rts * Return to caller
984	*
985	.page
986	*
987	* sr1inp -- Get input from Serial-1 (wait on busy)
988	* ------ ---------------------------------------
989	sr1inp: lea sr1iorec,a0 * Serial-1 iorec address
990	lea SR1ACIA,a1 * Serial-1 ACIA base
991	bra serinp * Go get a byte
992	*
993	* sr2inp -- Get input from Serial-2 (wait on busy)
994	* ------ ---------------------------------------
995	sr2inp: lea sr2iorec,a0 * Serial-2 iorec address
996	lea SR2ACIA,a1 * Serial-2 ACIA base
997	*
998	* serinp -- Get a byte from a serial port (with handshaking)
999	* ------ -------------------------------------------------
1000	serinp: bsr chkist * Check input status
1001	tst.w d0 * Character ready ?
1002	beq serinp * Loop until one is ...
1003	*
1004	bsr getser * Get a byte from the buffer
1005	and.w #$FFFF,d0 * Isolate LS bits 7..0
1006	rts * Return to caller
1007	*
1008	.page
1009	*
1010	.ifne BUCHLA
1011	*
1012	* mc1inp -- Get input from MIDI-1 (wait on busy)
1013	* ------ -------------------------------------
1014	mc1inp: lea mc1iorec,a0 * MIDI-1 iorec address
1015	lea MC1ACIA,a1 * MIDI-1 ACIA base
1016	bra midinp * Go get a byte
1017	*
1018	* mc2inp -- Get input from MIDI-2 (wait on busy)
1019	* ------ -------------------------------------
1020	mc2inp: lea mc2iorec,a0 * MIDI-2 iorec address
1021	lea MC2ACIA,a1 * MIDI-2 ACIA base
1022	*
1023	* midinp -- Get input from a MIDI port (no handshaking)
1024	* ------ --------------------------------------------
1025	midinp: bsr chkist * Check input status
1026	tst.w d0 * Character ready ?
1027	beq midinp * Loop until one is ...
1028	*
1029	move.w sr,-(a7) * Save status register
1030	ori.w #IPL7,sr * Set IPL = 7 (disable ints)
1031	move.w ibufhd(a0),d1 * Head index to d1
1032	cmp.w ibuftl(a0),d1 * Compare to tail index
1033	beq midin_1 * Jump if (somehow) empty
1034	*
1035	addq.w #1,d1 * Increment head index
1036	cmp.w ibufsize(a0),d1 * Did pointer wrap around ?
1037	bcs midin_2 * Jump if not
1038	*
1039	moveq.l #0,d1 * Wraparound
1040	*
1041	midin_2: move.l ibuf(a0),a2 * Get buffer base address in a2
1042	moveq.l #0,d0 * Clear MS bits of d0
1043	move.b 0(a2,d1),d0 * Get character from buffer
1044	move.w d1,ibufhd(a0) * Update buffer head index
1045	*
1046	midin_1: move.w (a7)+,sr * Restore status
1047	rts * Return to caller
1048	*
1049	.endc
1050	*
1051	.page
1052	*
1053	* getser -- Get a byte from a serial port buffer (with handshaking)
1054	* ------ --------------------------------------------------------
1055	getser: move.w sr,-(a7) * Save status register
1056	ori.w #IPL7,sr * Set IPL = 7 (disable ints)
1057	move.w ibufhd(a0),d1 * Get input buffer head index
1058	cmp.w ibuftl(a0),d1 * Compare tail index
1059	beq rs_mt * Jump if buffer empty
1060	*
1061	bsr wrapin * Adjust pointer for wraparound
1062	move.l ibuf(a0),a2 * Get buffer address
1063	moveq.l #0,d0 * Clear out MS bits of d0
1064	move.b 0(a2,d1),d0 * Get character from buffer
1065	move.w d1,ibufhd(a0) * Update head index
1066	move.w (a7)+,sr * Restore status
1067	andi #$FFFE,sr * Clear carry = OK
1068	bra rs_xnf * Go do XON/XOFF check
1069	*
1070	rs_mt: move.w (a7)+,sr * Restore status
1071	ori #$0001,sr * Set carry = no character there
1072	*
1073	rs_xnf: btst #0,linedisc(a0) * Check for XON/XOFF mode
1074	beq rs_exit * Jump if not enabled
1075	*
1076	tst.b flagxon(a0) * XON active ?
1077	beq rs_exit * Jump if not
1078	*
1079	bsr rsilen * Get length of buffer used
1080	cmp.w ibuflow(a0),d2 * At low water mark ?
1081	bne rs_exit * Jump if not
1082	*
1083	move.b #$11,d1 * Send an XON
1084	bsr serput * ...
1085	clr.b flagxon(a0) * Clear XON flag
1086	*
1087	rs_exit: rts * Return to caller
1088	*
1089	.page
1090	*
1091	* sr1out -- Output to serial-1
1092	* ------ ------------------
1093	sr1out: lea sr1iorec,a0 * Serial-1 iorec address to a0
1094	lea SR1ACIA,a1 * Serial-1 ACIA address to a1
1095	move.w 6(a7),d1 * Get data byte from stack
1096	bsr serput * Attempt to output
1097	bcs sr1out * Try until it works ...
1098	*
1099	rts * Return to caller
1100	*
1101	* sr2out -- Output to Serial-2
1102	* ------ ------------------
1103	sr2out: lea sr2iorec,a0 * Serial-2 iorec address to a0
1104	lea SR2ACIA,a1 * Serial-2 ACIA address to a1
1105	move.w 6(a7),d1 * Get data byte from stack
1106	bsr serput * Attempt to output
1107	bcs sr2out * Try until it works ...
1108	*
1109	rts * Return to caller
1110	*
1111	.ifne BUCHLA
1112	*
1113	* mc1out -- Output to MIDI-1
1114	* ------ ----------------
1115	mc1out: lea mc1iorec,a0 * MIDI-1 iorec address to a0
1116	lea MC1ACIA,a1 * MIDI-1 ACIA address to a1
1117	move.w 6(a7),d1 * Get data byte from stack
1118	bsr midput * Attempt to output
1119	bcs mc1out * Try until it works ...
1120	*
1121	rts * Return to caller
1122	*
1123	* mc2out -- Output to MIDI-2
1124	* ------ ----------------
1125	mc2out: lea mc2iorec,a0 * MIDI-2 iorec address to a0
1126	lea MC2ACIA,a1 * MIDI-2 ACIA address to a1
1127	move.w 6(a7),d1 * Get data byte from stack
1128	bsr midput * Attempt to output
1129	bcs mc2out * Try until it works ...
1130	*
1131	rts * Return to caller
1132	*
1133	.endc
1134	*
1135	.page
1136	*
1137	* serput -- Output a character to a serial port
1138	* ------ -----------------------------------
1139	serput: move.w sr,-(a7) * Save status register
1140	ori.w #IPL7,sr * Set IPL = 7 (disable ints)
1141	move.b ACIA_ISR(a1),isr(a0) * Get ACIA isr
1142	move.b ACIA_CSR(a1),csr(a0) * Get ACIA csr
1143	btst #0,linedisc(a0) * XON/XOFF mode ?
1144	beq serpt_1 * Jump if not
1145	*
1146	tst.b flagxoff(a0) * XON active ?
1147	bne serpt_2 * Jump if so
1148	*
1149	serpt_1: btst.b #6,isr(a0) * Is ACIA still sending ?
1150	beq serpt_2 * Jump if so
1151	*
1152	move.w obufhd(a0),d2 * Head index to d2
1153	cmp.w obuftl(a0),d2 * Compare to tail index
1154	bne serpt_2 * Jump if buffer not empty
1155	*
1156	move.b d1,ACIA_TDR(a1) * Give byte to ACIA to send
1157	bra serpt_3 * Go deal with RTS/CTS if needed
1158	*
1159	serpt_2: move.w obuftl(a0),d2 * Tail index to d2
1160	bsr wrapout * Adjust for wraparound
1161	cmp.w obufhd(a0),d2 * Compare to head index
1162	beq serpt_4 * Jump if buffer full
1163	*
1164	move.l obuf(a0),a2 * Get buffer base address in a2
1165	move.b d1,0(a2,d2) * Put character in buffer
1166	move.w d2,obuftl(a0) * Update buffer tail index
1167	*
1168	serpt_3: bsr serchk * Check status on our way out
1169	bsr rtschk * Handle RTS protocol
1170	move.w (a7)+,sr * Restore status register
1171	andi #$FFFE,sr * Clear carry flag = OK
1172	rts * Return to caller
1173	*
1174	serpt_4: bsr serchk * Check status on our way out
1175	bsr rtschk * Handle RTS protocol
1176	move.w (a7)+,sr * Restore status register
1177	ori #$0001,sr * Set carry flag = buffer full
1178	rts * Return to caller
1179	*
1180	.page
1181	*
1182	.ifne BUCHLA
1183	*
1184	* midput -- Output to MIDI
1185	* ------ --------------
1186	midput: move.w sr,-(a7) * Save status register
1187	ori.w #IPL7,sr * Set IPL = 7 (diable ints)
1188	move.b ACIA_ISR(a1),isr(a0) * Get ACIA isr
1189	move.b ACIA_CSR(a1),csr(a0) * Get ACIA csr
1190	btst.b #6,isr(a0) * Is ACIA still sending ?
1191	beq midpt_2 * Jump if so
1192	*
1193	move.w obufhd(a0),d2 * Head index to d2
1194	cmp.w obuftl(a0),d2 * Compare to tail index
1195	bne midpt_2 * Jump if buffer not empty
1196	*
1197	move.b d1,ACIA_TDR(a1) * Give byte to ACIA to send
1198	bra midpt_3 * Go set final status and exit
1199	*
1200	midpt_2: move.w obuftl(a0),d2 * Tail index to d2
1201	bsr wrapout * Adjust for wraparound
1202	cmp.w obufhd(a0),d2 * Compare to head index
1203	beq midpt_4 * Jump if buffer full
1204	*
1205	move.l obuf(a0),a2 * Get buffer base address in a2
1206	move.b d1,0(a2,d2) * Put character in buffer
1207	move.w d2,obuftl(a0) * Update buffer tail index
1208	*
1209	midpt_3: bsr midchk * Check status on our way out
1210	move.w (a7)+,sr * Restore status register
1211	andi #$FFFE,sr * Clear carry flag = OK
1212	rts * Return to caller
1213	*
1214	midpt_4: bsr midchk * Check status on our way out
1215	move.w (a7)+,sr * Restore status register
1216	ori #$0001,sr * Set carry flag = buffer full
1217	rts * Return to caller
1218	*
1219	.endc
1220	*
1221	.page
1222	*
1223	* rtschk -- Check RTS mode and turn on RTS if it's enabled
1224	* ------ ----------------------------------------------
1225	rtschk: btst #1,linedisc(a0) * RTS/CTS mode set ?
1226	beq rts_1 * Jump if not
1227	*
1228	bsr rtson * Turn on RTS
1229	*
1230	rts_1: rts * Return to caller
1231	*
1232	* rsilen -- Get length of portion of input buffer that's been used so far
1233	* ------ -------------------------------------------------------------
1234	rsilen: move.w ibuftl(a0),d2 * Tail index to d2
1235	move.w ibufhd(a0),d3 * Head index to d3
1236	cmp.w d3,d2 * Head > Tail ?
1237	bhi rsi_1 * Jump if not
1238	*
1239	add.w ibufsize(a0),d2 * Add buffer size to tail index
1240	*
1241	rsi_1: sub.w d3,d2 * Length = (adjusted)Tail - Head
1242	rts * Return to caller
1243	*
1244	* rtson -- Turn on RTS line
1245	* ----- ----------------
1246	rtson: move.b cfr1(a0),d0 * Pick up CFR1 image
1247	bclr #0,d0 * Turn on RTS line (active low)
1248	bset #7,d0 * Make sure MS bit is set
1249	move.b d0,cfr1(a0) * Update CFR1 image
1250	move.b d0,ACIA_CFR(a1) * Send CFR to hardware
1251	rts * Return to caller
1252	*
1253	* rtsoff -- Turn off RTS line
1254	* ------ -----------------
1255	rtsoff: move.b cfr1(a0),d0 * Pick up CFR1 image
1256	bset #0,d0 * Turn off RTS line (active low)
1257	bset #7,d0 * Make sure MS bit is set
1258	move.b d0,cfr1(a0) * Update CFR1 image
1259	move.b d0,ACIA_CFR(a1) * Send CFR to hardware
1260	rts
1261	*
1262	.page
1263	*
1264	* serintr -- Serial (Serial-1, Serial-2, MIDI-1, MIDI-2) interrupt handler
1265	* ------- -------------------------------------------------------------
1266	serintr: movem.l d0-d3/a0-a2,-(a7) * Save registers
1267	lea sr1iorec,a0 * Point at Serial-1 iorec
1268	lea SR1ACIA,a1 * Point at Serial-1 ACIA
1269	bsr serint * Go process (possible) int.
1270	*
1271	lea sr2iorec,a0 * Point at Serial-2 iorec
1272	lea SR2ACIA,a1 * Point at Serial-2 ACIA
1273	bsr serint * Go process (possible) int.
1274	*
1275	.ifne BUCHLA
1276	*
1277	lea mc1iorec,a0 * Point at MIDI-1 iorec
1278	lea MC1ACIA,a1 * Point at MIDI-1 ACIA
1279	bsr midint * Go process (possible) int.
1280	*
1281	lea mc2iorec,a0 * Point at MIDI-2 iorec
1282	lea MC2ACIA,a1 * Point at MIDI-2 ACIA
1283	bsr midint * Go process (possible) int.
1284	*
1285	.endc
1286	*
1287	movem.l (a7)+,d0-d3/a0-a2 * Restore registers
1288	rte * Return from exception
1289	*
1290	.page
1291	*
1292	* serint -- Process an interrupt from Serial-1 or Serial-2
1293	* ------ ----------------------------------------------
1294	serint: move.b ACIA_ISR(a1),isr(a0) * Get and save ISR
1295	move.b ACIA_CSR(a1),csr(a0) * Get and save CSR
1296	*
1297	btst.b #7,isr(a0) * Was int for this device ?
1298	beq serintx * Jump if not
1299	*
1300	serchk: btst.b #1,isr(a0) * FRM/OVR/BRK error ?
1301	bne sererr * Jump if so
1302	*
1303	btst.b #0,isr(a0) * Receiver interrupt ?
1304	bne serrx * Jump if so
1305	*
1306	sertxq: btst.b #6,isr(a0) * Transmitter interrupt ?
1307	bne sertx * Jump if so
1308	*
1309	serctq: btst.b #5,isr(a0) * CTS interrupt ?
1310	bne sercts * Jump if so
1311	*
1312	serintx: rts * Return to caller
1313	*
1314	sererr: addq.w #1,errct(a0) * Update error count
1315	move.b ACIA_RDR(a1),erbyte(a0) * Get error byte
1316	rts
1317	*
1318	* Handle CTS interupt
1319	*
1320	sercts: btst.b #1,linedisc(a0) * RTS/CTS mode ?
1321	beq serintx * Ignore if not
1322	*
1323	btst.b #5,csr(a0) * CTS set ?
1324	beq serintx * Ignore if not
1325	*
1326	sercts1: btst.b #6,isr(a0) * TDRE set ?
1327	beq sercts1 * Loop until it is (!)
1328	*
1329	move.w obufhd(a0),d2 * Head index to d2
1330	cmp.w obuftl(a0),d2 * Compare to tail index
1331	beq serintx * Done if buffer empty
1332	*
1333	bsr.w wrapout * Adjust pointer for wraparound
1334	move.l obuf(a0),a2 * Get buffer base in a2
1335	move.b 0(a2,d2),ACIA_TDR(a1) * Send byte on its way
1336	move.w d2,obufhd(a0) * Save updated head index
1337	rts
1338	*
1339	.page
1340	*
1341	* Handle receiver interrupt
1342	*
1343	serrx: btst.b #1,linedisc(a0) * RTS/CTS mode set ?
1344	beq serrx1 * Jump if not
1345	*
1346	bsr.w rtsoff * Turn off RTS
1347	*
1348	serrx1: move.b ACIA_RDR(a1),d0 * Read data from ACIA
1349	btst.b #1,linedisc(a0) * RTS/CTS mode set ?
1350	bne serrx3 * Jump if so
1351	*
1352	btst.b #0,linedisc(a0) * XON/XOFF mode set ?
1353	beq serrx3 * Jump if not
1354	*
1355	cmpi.b #$11,d0 * Is this an XON ?
1356	bne serrx2 * Jump if not
1357	*
1358	move.b #$00,flagxoff(a0) * Clear flagxoff
1359	bra sertxq * Done
1360	*
1361	serrx2: cmpi.b #$13,d0 * Is this an XOFF ?
1362	bne serrx3 * Jump if not
1363	*
1364	move.b #$FF,flagxoff(a0) * Set flagxoff
1365	bra sertxq * Done
1366	*
1367	serrx3: move.w ibuftl(a0),d1 * Get tail index in d1
1368	bsr.w wrapin * Adjust for wraparound
1369	cmp.w ibufhd(a0),d1 * Head = tail ?
1370	beq seribf * If so, we drop the character
1371	*
1372	move.l ibuf(a0),a2 * Get buffer address
1373	move.b d0,0(a2,d1) * Stash byte in buffer
1374	move.w d1,ibuftl(a0) * Save updated tail index
1375	bsr rsilen * Get length of buffer used
1376	cmp.w ibufhi(a0),d2 * Hit high water mark ?
1377	bne serrx4 * Jump if not
1378	*
1379	btst.b #1,linedisc(a0) * RTS/CTS mode set ?
1380	bne sertxq * Done if so
1381	*
1382	btst.b #0,linedisc(a0) * XON/XOFF mode set ?
1383	beq serrx4 * Jump if not
1384	*
1385	tst.b flagxon(a0) * XOFF already sent ?
1386	bne serrx4 * Jump if so
1387	*
1388	move.b #$FF,flagxon(a0) * Set the flag
1389	move.b #$13,d1 * Send an XOFF
1390	bsr.w serput * ...
1391	*
1392	.page
1393	*
1394	serrx4: btst #1,linedisc(a0) * RTS/CTS mode set ?
1395	beq sertxq * Done if not
1396	*
1397	bsr rtson * Turn on RTS
1398	bra sertxq
1399	*
1400	* Handle transmitter interrupt
1401	*
1402	sertx: btst.b #1,linedisc(a0) * RTS/CTS mode set ?
1403	bne sertx2 * If so, go check CTS
1404	*
1405	btst.b #0,linedisc(a0) * XON/XOFF mode set ?
1406	beq sertx1 * Jump if not
1407	*
1408	tst.b flagxoff(a0) * Check flagxoff
1409	bne serctq * Done if set
1410	*
1411	sertx1: move.w obufhd(a0),d2 * Head index to d2
1412	cmp.w obuftl(a0),d2 * Compare to tail index
1413	beq serctq * Done if buffer empty
1414	*
1415	bsr wrapout * Adjust pointer for wraparound
1416	move.l obuf(a0),a2 * Get buffer base address
1417	move.b 0(a2,d2),ACIA_TDR(a1) * Send byte on its way
1418	move.w d2,obufhd(a0) * Save updated head index
1419	bra serctq * Done
1420	*
1421	sertx2: btst.b #5,csr(a0) * CTS set in csr ?
1422	beq serctq * If not, go check for CTS int
1423	*
1424	bra sertx1 * CTS was set, go transmit
1425	*
1426	seribf: move.b d0,erbyte(a0) * Log dropped character
1427	addq.w #1,ibfct(a0) * ...
1428	bra sertxq * Go check Tx interrupt
1429	*
1430	.page
1431	*
1432	.ifne BUCHLA
1433	*
1434	* midint -- Process an interrupt from MIDI-1 or MIDI-2
1435	* ------ ------------------------------------------
1436	midint: move.b ACIA_ISR(a1),isr(a0) * Get and save ISR
1437	move.b ACIA_CSR(a1),csr(a0) * Get and save CSR
1438	*
1439	btst.b #7,isr(a0) * Was int for this device ?
1440	beq midintx * Jump if not
1441	*
1442	midchk: btst.b #1,isr(a0) * FRM/OVR/BRK error ?
1443	bne miderr * Jump if so
1444	*
1445	btst.b #0,isr(a0) * Receiver interrupt ?
1446	bne midrx * Jump if so
1447	*
1448	midtxq: btst.b #6,isr(a0) * Transmitter interrupt ?
1449	bne midtx * Jump if so
1450	*
1451	midintx: rts * Return to caller
1452	*
1453	miderr: addq.w #1,errct(a0) * Update error count
1454	move.b ACIA_RDR(a1),erbyte(a0) * Get error byte
1455	rts
1456	*
1457	* Handle receiver interrupt
1458	*
1459	midrx: move.b ACIA_RDR(a1),d0 * Read data from ACIA
1460	move.w ibuftl(a0),d1 * Get tail index in d1
1461	bsr.w wrapin * Adjust for wraparound
1462	cmp.w ibufhd(a0),d1 * Head = tail ?
1463	beq midibf * If so, we drop the character
1464	*
1465	move.l ibuf(a0),a2 * Get buffer address
1466	move.b d0,0(a2,d1) * Stash byte in buffer
1467	move.w d1,ibuftl(a0) * Save updated tail index
1468	bra midtxq * Done (go check tx int)
1469	*
1470	.page
1471	*
1472	* Handle transmitter interrupt
1473	*
1474	midtx: move.w obufhd(a0),d2 * Head index to d2
1475	cmp.w obuftl(a0),d2 * Compare to tail index
1476	beq midintx * Done if buffer empty
1477	*
1478	bsr wrapout * Adjust pointer for wraparound
1479	move.l obuf(a0),a2 * Get buffer base address
1480	move.b 0(a2,d2),ACIA_TDR(a1) * Send byte on its way
1481	move.w d2,obufhd(a0) * Save updated head index
1482	bra midintx * Done
1483	*
1484	midibf: move.b d0,erbyte(a0) * Log dropped character
1485	addq.w #1,ibfct(a0) * ...
1486	bra midtxq * Go check Tx interrupt
1487	*
1488	.endc
1489	*
1490	.page
1491	*
1492	* setexec -- Set an exception vector
1493	* ------- -----------------------
1494	setexec: move.w 4(a7),d0 * Get vector number
1495	lsl.w #2,d0 * .. times 4
1496	sub.l a0,a0 * Clear a0
1497	lea 0(a0,d0),a0 * Get address of old vector
1498	move.l (a0),d0 * Move old vector to d0
1499	move.l 6(a7),d1 * Pick up new vector
1500	bmi setexec1 * Don't set if = -1
1501	*
1502	move.l d1,(a0) * Set new vector
1503	*
1504	setexec1: rts * Return to caller
1505	*
1506	* piorec -- Get pointer to iorec structure
1507	* ------ ------------------------------
1508	piorec: moveq.l #0,d1 * Clear out d1
1509	move.w 4(a7),d1 * Get device number
1510	move.w sr,-(a7) * Save status register
1511	ori.w #IPL7,sr * Set IPL = 7 (no ints)
1512	lea iortab,a2 * Get base address of table
1513	asl.l #2,d1 * Device # times 4 for index
1514	move.l 0(a2,d1),d0 * Get iorec address from table
1515	move.w (a7)+,sr * Restore status register
1516	rts * Return to caller
1517	*
1518	.page
1519	*
1520	* setport -- Set ACIA parameters (unit, mode, baud, CFR0, CFR1)
1521	* ------- ---------------------------------------------------
1522	setport: moveq.l #0,d1 * Clear out d1
1523	move.w 4(a7),d1 * Get device number
1524	asl.l #3,d1 * Times 8 for index
1525	ori.w #IPL7,sr * Set IPL = 7 (no ints)
1526	lea aciatab,a2 * Get base of table
1527	move.l 0(a2,d1),d0 * Get iorec address
1528	move.l 4(a2,d1),d2 * Get ACIA address
1529	movea.l d0,a0 * Setup a0 = iorec address
1530	movea.l d2,a1 * Setup a1 = ACIA address
1531	tst.w 6(a7) * Change mode ?
1532	bmi setpt1 * Jump if not
1533	*
1534	move.b 7(a7),linedisc(a0) * Set line discipline (mode)
1535	*
1536	setpt1: tst.w 8(a7) * Change baud rate ?
1537	bmi setpt2 * Jump if not
1538	*
1539	moveq.l #0,d1 * Clear out d1
1540	move.w 8(a7),d1 * Get baud rate index
1541	lea brtable,a2 * Get base of baud rate table
1542	move.b 0(a2,d1),d2 * Get baud rate code from table
1543	move.b cfr0(a0),d0 * Get current CFR0
1544	andi.w #$0070,d0 * Mask off old baud rate code
1545	or.w d2,d0 * OR in new baud rate code
1546	move.b d0,cfr0(a0) * Update CFR0 in table
1547	move.b d0,ACIA_CFR(a1) * Update hardware
1548	*
1549	setpt2: tst.w 10(a7) * Change CFR0 ?
1550	bmi setpt3 * Jump if not
1551	*
1552	move.b 11(a7),cfr0(a0) * Update CFR0 in table
1553	move.b cfr0(a0),ACIA_CFR(a1) * Update CFR0 in hardware
1554	*
1555	setpt3: tst.w 12(a7) * Change CFR1 ?
1556	bmi setpt4 * Jump if not
1557	*
1558	bset.b #7,13(a7) * Force D7 = 1 in argument
1559	move.b 13(a7),cfr1(a0) * Update CFR1 in table
1560	move.b cfr1(a0),ACIA_CFR(a1) * Update CFR1 in hardware
1561	*
1562	setpt4: rts * Return to caller
1563	*
1564	.page
1565	*
1566	* aciainit -- Initialize an ACIA port
1567	* -------- -----------------------
1568	aciainit: move.w #IORECLN,d0 * Setup byte count for move
1569	move.l a0,-(a7) * Save iorec base
1570	*
1571	aciai_1: move.b (a2)+,(a0)+ * Move the default to the iorec
1572	dbf d0,aciai_1 * ...
1573	*
1574	move.l (a7)+,a0 * Restore iorec base
1575	move.b cfr0(a0),ACIA_CFR(a1) * Setup CFR0
1576	move.b cfr1(a0),ACIA_CFR(a1) * Setup CFR1
1577	move.b ACIA_RDR(a1),d0 * Clear RDR
1578	move.b #$7F,ACIA_IER(a1) * Disable all interrupts
1579	btst.b #1,linedisc(a0) * Are we in RTS/CTS mode ?
1580	bne aciai_2 * Jump if so
1581	*
1582	move.b #$C3,ACIA_IER(a1) * Enable TDRE, RDRF
1583	bra aciai_3 * Go return
1584	*
1585	aciai_2: move.b #$E3,ACIA_IER(a1) * Enable interrupts we want
1586	*
1587	aciai_3: rts * Return to caller
1588	*
1589	.page
1590	*
1591	.ifne BUCHLA
1592	*
1593	* fastcopy -- Copy disk sector quickly
1594	* -------- ------------------------
1595	fastcopy: move.l 4(a7),a0 * Get source pointer
1596	move.l 8(a7),a1 * Get destination pointer
1597	move.w $3F,d0 * 512 bytes (63+1)*8
1598	*
1599	fastcpy1: move.b (a0)+,(a1)+ * Move 8 bytes
1600	move.b (a0)+,(a1)+ * ...
1601	move.b (a0)+,(a1)+ * ...
1602	move.b (a0)+,(a1)+ * ...
1603	move.b (a0)+,(a1)+ * ...
1604	move.b (a0)+,(a1)+ * ...
1605	move.b (a0)+,(a1)+ * ...
1606	move.b (a0)+,(a1)+ * ...
1607	dbra d0,fastcpy1 * Loop until all bytes are moved
1608	*
1609	rts * Return to caller
1610	*
1611	.page
1612	*
1613	* _hdvini -- Drive initialization
1614	* ------- --------------------
1615	_hdvini: link a6,#-18 * Reserve space on stack
1616	movem.l d3-d7/a3-a5,-(a7) * Preserve registers
1617	move.l #300,maxactim * maxactim = 300 * 20ms
1618	clr.w d0 * Put zeros in ...
1619	move.w d0,nflops * ... nflops
1620	move.w d0,dskmode * ... dskmode
1621	move.w d0,-2(a6) * Start with drive A
1622	bra hdvilp * ...
1623	*
1624	hdvilp1: movea.l #dskmode,a0 * Get dskmode address in a0
1625	movea.w -2(a6),a1 * Drive number in a1
1626	adda.l a1,a0 * Point at dskmode for drive
1627	clr.b (a0) * Clear flag in dskmode
1628	clr.w -(a7) * Push arguments onto stack
1629	clr.w -(a7) * ...
1630	clr.w -(a7) * ...
1631	move.w -2(a6),-(a7) * Push drive number onto stack
1632	clr.l -(a7) * ... filler
1633	clr.l -(a7) * ... filler
1634	jsr flopini * Initialize drive
1635	adda.l #16,a7 * Cleanup stack
1636	move.w d0,-(a7) * Save error code on stack
1637	movea.w -2(a6),a0 * Get drive number
1638	adda.l a0,a0 * ... times 2
1639	adda.l #dskerrs,a0 * Add base of dskerrs
1640	move.w (a7)+,(a0) * Move error code off of stack
1641	bne hdvind * Jump if drive not present
1642	*
1643	addq.w #1,nflops * Update number of drives
1644	or.l #3,drvbits * Setup drive bits
1645	*
1646	hdvind: addq.w #1,-2(a6) * Increment drive number
1647	*
1648	hdvilp: cmp.w #2,-2(a6) * See if it's 2 yet
1649	blt hdvilp1 * Loop until it is
1650	*
1651	movem.l (a7)+,d3-d7/a3-a5 * Restore registers
1652	unlk a6 * Release temporary stack space
1653	rts * Return to caller
1654	*
1655	* drvmap -- get drive map
1656	* ------ -------------
1657	drvmap: move.l drvbits,d0 * Get drive bits
1658	rts * Return to caller
1659	*
1660	.page
1661	*
1662	* getbpb -- get BIOS parameter block
1663	* ------ ------------------------
1664	getbpb: link a6,#-12 * Reserve space for temporaries
1665	movem.l d5-d7/a4-a5,-(a7) * Save registers on stack
1666	cmp.w #2,8(a6) * Check drive number
1667	blt gbpb1 * Jump if OK
1668	*
1669	clr.l d0 * Set drive number to 0
1670	bra gbpber * Go flag error
1671	*
1672	gbpb1: move.w 8(a6),d0 * Get drive number
1673	asl.w #5,d0 * ... times 32
1674	ext.l d0 * ... extend sign
1675	move.l d0,a5 * Move to a5
1676	add.l #drvbpbs,a5 * Add base of drive bpb are
1677	move.l a5,a4 * Save in a4
1678	*
1679	gbpbrds: move.w #1,(a7) * floprd count = 1,
1680	clr.w -(a7) * ... side = 0,
1681	clr.w -(a7) * ... track = 0,
1682	move.w #1,-(a7) * ... sector = 1,
1683	move.w 8(a6),-(a7) * ... drive #,
1684	clr.l -(a7) * ... filler
1685	move.l #buffer,-(a7) * ... buffer address,
1686	jsr floprd * Go read the sector
1687	add.l #16,a7 * Cleanup stack
1688	move.l d0,-12(a6) * Save error code
1689	tst.l -12(a6) * ... and test it
1690	bge gbpb2 * Jump if OK
1691	*
1692	move.w 8(a6),(a7) * Put drive number on stack
1693	move.l -12(a6),d0 * Get error code
1694	move.w d0,-(a7) * ... and put it on the stack
1695	jsr criter * Go do critical error routine
1696	addq.l #2,a7 * Cleanup stack
1697	move.l d0,-12(a6) * Save error code
1698	*
1699	gbpb2: move.l -12(a6),d0 * Get error code
1700	cmp.l #RETRYIT,d0 * Magic number for retry ?
1701	beq gbpbrds * Re-read if so
1702	*
1703	tst.l -12(a6) * Test error code
1704	bge gbpb3 * Jump if OK
1705	*
1706	clr.l d0 * Set code in d0
1707	bra gbpber * Go set error code
1708	*
1709	.page
1710	*
1711	gbpb3: move.l #buffer+11,(a7) * Bytes per sector
1712	bsr itom * Convert 8086 to 68K format
1713	move.w d0,d7 * Save bytes per sector
1714	beq gbpb4 * Jump if zero
1715	*
1716	move.b buffer+13,d6 * Sectors per cluster
1717	ext.w d6 * ... sign extended
1718	and.w #$FF,d6 * ... and trimmed
1719	bne gbpb5 * Jump if non-zero
1720	*
1721	gbpb4: clr.l d0 * Set error code
1722	bra gbpber * ...
1723	*
1724	gbpb5: move.w d7,(a4) * Set recsize
1725	move.w d6,2(a4) * Set clsiz
1726	move.l #buffer+22,(a7) * Convert sectors per fat
1727	bsr itom * ...
1728	move.w d0,8(a4) * Set fsiz
1729	move.w 8(a4),d0 * Get fsiz
1730	addq.w #1,d0 * ... plus 1
1731	move.w d0,10(a4) * Set fatrec
1732	move.w (a4),d0 * Get recsize
1733	muls.w 2(a4),d0 * ... times clsiz
1734	move.w d0,4(a4) * Set clsizb
1735	move.l #buffer+17,(a7) * Convert number of dir ents
1736	bsr itom * ...
1737	asl.w #5,d0 * ... times 32
1738	ext.l d0 * ... sign extended
1739	divs.w (a4),d0 * ... / recsize
1740	move.w d0,6(a4) * Set rdlen
1741	move.w 10(a4),d0 * Get fatrec
1742	add.w 6(a4),d0 * ... + rdlen
1743	add.w 8(a4),d0 * ... + fsiz
1744	move.w d0,12(a4) * Set datrec
1745	move.l #buffer+19,(a7) * Get number of sectors
1746	bsr itom * ... convert
1747	sub.w 12(a4),d0 * ... - datrec
1748	ext.l d0 * ... sign extended
1749	divs.w 2(a4),d0 * ... / clsiz
1750	move.w d0,14(a4) * Set numcl
1751	*
1752	.page
1753	*
1754	move.l #buffer+26,(a7) * Convert number of heads
1755	bsr itom * ...
1756	move.w d0,20(a5) * Set dnsides
1757	move.l #buffer+24,(a7) * Convert sectors per track
1758	bsr itom * ...
1759	move.w d0,24(a5) * Set dspt
1760	move.w 20(a5),d0 * Get dnsides
1761	muls.w 24(a5),d0 * ... * dspt
1762	move.w d0,22(a5) * Set dspc
1763	move.l #buffer+28,(a7) * Convert number of hidden sects
1764	bsr itom * ...
1765	move.w d0,26(a5) * Set dhidden
1766	move.l #buffer+19,(a7) * Convert sectors on disk
1767	bsr itom * ...
1768	ext.l d0 * ... sign extended
1769	divs.w 22(a5),d0 * ... / dspc
1770	move.w d0,18(a5) * Set dntracks
1771	clr.w d7 * Counter = 0
1772	bra gbpblpt * Jump to end of loop
1773	*
1774	gbpb6: move.l a5,a0 * Get buffer pointer
1775	move.w d7,a1 * Loop count to a1
1776	add.l a1,a0 * ... + bpb address
1777	move.w d7,a1 * Loop count to a1
1778	add.l #buffer,a1 * ... + buffer address
1779	move.b 8(a1),28(a0) * Copy a s/n byte
1780	addq.w #1,d7 * Update loop count
1781	*
1782	gbpblpt: cmp.w #3,d7 * Moved 3 bytes ?
1783	blt gbpb6 * Loop if not
1784	*
1785	.page
1786	*
1787	move.l #cdev,a0 * Address of cdev table
1788	move.w 8(a6),a1 * ... plus drive number
1789	add.l a1,a0 * ... to a0
1790	move.l #wpstatus,a1 * Address of wpstatus table
1791	move.w 8(a6),a2 * ... plus drive number
1792	add.l a2,a1 * ... to a1
1793	move.b (a1),(a0) * Move wpstatus to cdev
1794	beq gbpb7
1795	*
1796	moveq.l #1,d0 * Set status = "Uncertain"
1797	bra gbpb8
1798	*
1799	gbpb7: clr.w d0 * Set status = "Unchanged"
1800	*
1801	gbpb8: move.l #dskmode,a1 * Update dskmode table
1802	move.w 8(a6),a2 * ...
1803	add.l a2,a1 * ...
1804	move.b d0,(a1) * ...
1805	move.l a5,d0 * Setup to return bpb pointer
1806	*
1807	gbpber: tst.l (a7)+ * Pop garbage off top of stack
1808	movem.l (a7)+,d6-d7/a4-a5 * Restore registers
1809	unlk a6
1810	rts
1811	*
1812	.page
1813	*
1814	* mediach -- check for media change
1815	* ------- ----------------------
1816	mediach: link a6,#0 * Create scratch on stack
1817	movem.l d6-d7/a5,-(a7) * Save registers on stack
1818	cmp.w #2,8(a6) * Check drive number
1819	blt media1 * Jump if OK
1820	*
1821	moveq.l #ERR15,d0 * Error -- "unknown device"
1822	bra media2 * ...
1823	*
1824	media1: move.w 8(a6),d7 * Get drive number in d7
1825	movea.w d7,a5 * Point into dskmode table
1826	add.l #dskmode,a5 * ...
1827	cmp.b #2,(a5) * Definitely changed ?
1828	bne media3 * Jump if not
1829	*
1830	moveq.l #2,d0 * Setup to return "Changed"
1831	bra media2 * Done -- go return to caller
1832	*
1833	media3: move.l #wplatch,a0 * Check wplatch for drive
1834	tst.b 0(a0,d7) * ...
1835	beq media4 * Jump if not set
1836	*
1837	move.b #1,(a5) * Set dskmode to "Uncertain"
1838	*
1839	media4: move.l _hz_200,d0 * Get time in d0
1840	movea.w d7,a1 * Calculate acctim table address
1841	add.l a1,a1 * ... = drive # * 4
1842	add.l a1,a1 * ...
1843	add.l #acctim,a1 * ... + acctim base address
1844	move.l (a1),d1 * Get acctim for drive
1845	sub.l d1,d0 * Subtract from current time
1846	cmp.l maxactim,d0 * Timed out ?
1847	bge media5 * Jump if so
1848	*
1849	clr.w d0 * Setup to return "Unchanged"
1850	bra media2
1851	*
1852	media5: move.b (a5),d0 * Return status from dskmode
1853	ext.w d0
1854	*
1855	media2: tst.l (a7)+ * Pop extra stack word
1856	movem.l (a7)+,d7/a5 * Restore registers
1857	unlk a6
1858	rts * Return to caller
1859	*
1860	.page
1861	*
1862	* rwabs -- read / write sector(s)
1863	* ----- ----------------------
1864	rwabs: link a6,#-4 * Reserve stack for temps
1865	movem.l d4-d7/a5,-(a7) * Save registers on stack
1866	cmp.w #2,18(a6) * Drive number
1867	blt rwabs1
1868	*
1869	moveq.l #ERR15,d0 * ERROR -- "unknown device"
1870	bra rwabser
1871	*
1872	rwabs1: move.w 18(a6),d6 * Save drive number
1873	cmp.w #2,8(a6) * Check rwflag
1874	bge rwabs7
1875	*
1876	move.w d6,d0
1877	asl.w #5,d0
1878	ext.l d0
1879	move.l d0,a5
1880	add.l #drvbpbs,a5
1881	move.w d6,(a7)
1882	bsr mediach * Test for media change
1883	move.w d0,d7 * Save status
1884	cmp.w #2,d7 * Disk changed ?
1885	bne rwabs2 * Jump if not
1886	*
1887	moveq.l #ERR14,d0 * ERROR -- "media changed"
1888	bra rwabser * ...
1889	*
1890	rwabs2: cmp.w #1,d7 * Disk possibly changed ?
1891	bne rwabs7
1892	*
1893	rwabs3: move.w #1,(a7) * floprd count = 1,
1894	clr.w -(a7) * ... side = 0,
1895	clr.w -(a7) * ... track = 0,
1896	move.w #1,-(a7) * ... sector = 1,
1897	move.w d6,-(a7) * ... drive number,
1898	clr.l -(a7) * ... filler,
1899	move.l #buffer,-(a7) * ... buffer address,
1900	jsr floprd * Read boot sector
1901	add.l #16,a7 * Cleanup stack
1902	move.l d0,-4(a6) * Save error number
1903	tst.l -4(a6) * ... and test it
1904	bge rwabs11 * Jump if OK
1905	*
1906	.page
1907	*
1908	move.w d6,(a7)
1909	move.l -4(a6),d0
1910	move.w d0,-(a7)
1911	jsr criter * Call critical error code
1912	addq.l #2,a7 * Cleanup stack
1913	move.l d0,-4(a6)
1914	*
1915	rwabs11: move.l -4(a6),d0
1916	cmp.l #RETRYIT,d0
1917	beq rwabs3 * Read again
1918	*
1919	tst.l -4(a6) * Test error number
1920	bge rwabs4 * OK ?
1921	*
1922	move.l -4(a6),d0
1923	bra rwabser * ERROR
1924	*
1925	rwabs4: clr.w d7 * Clear media change status
1926	bra rwabs10
1927	*
1928	rwabs6: move.l #buffer,a0 * Address of sector buffer to a0
1929	move.b 8(a0,d7),d0 * Serial number
1930	ext.w d0
1931	move.b 28(a5,d7),d1 * Compare to old one
1932	ext.w d1
1933	cmp.w d1,d0
1934	beq rwabs5 * Jump if they're the same
1935	*
1936	moveq.l #ERR14,d0 * ERROR -- "media changed"
1937	bra rwabser
1938	*
1939	rwabs5: addq.w #1,d7 * Next byte of serial number
1940	*
1941	rwabs10: cmp.w #3,d7 * All 3 bytes checked ?
1942	blt rwabs6 * Loop if not
1943	*
1944	.page
1945	*
1946	move.w d6,a0 * Point at wplatch for drive
1947	add.l #wplatch,a0 * ...
1948	move.w d6,a1 * Point at wpstatus for drive
1949	add.l #wpstatus,a1 * ...
1950	move.b (a1),(a0) * Move wpstatus to wplatch
1951	bne rwabs9 * Jump if set
1952	*
1953	move.w d6,a0 * Set dskmode to "Unchanged"
1954	add.l #dskmode,a0 * ...
1955	clr.b (a0) * ...
1956	*
1957	rwabs7: tst.w nflops * Test nflops
1958	bne rwabs8
1959	*
1960	moveq.l #ERR02,d0 * ERROR -- "drive not ready"
1961	bra rwabser
1962	*
1963	rwabs8: cmp.w #1,8(a6) * Check rwflag
1964	ble rwabs9
1965	*
1966	subq.w #2,8(a6) * Adjust to 0\|1
1967	*
1968	rwabs9: move.w 14(a6),(a7) * Setup count,
1969	move.w d6,-(a7) * ... drive,
1970	move.w 16(a6),-(a7) * ... recno,
1971	move.l 10(a6),-(a7) * ... buffer,
1972	move.w 8(a6),-(a7) * ... rwflag
1973	bsr floprw * Call floprw
1974	*
1975	add.l #10,a7 * Cleanup stack
1976	*
1977	rwabser: tst.l (a7)+ * Pop stack scratch
1978	movem.l (a7)+,d5-d7/a5 * Restore registers
1979	unlk a6 * Release temporaries
1980	rts * Return to caller
1981	*
1982	.page
1983	*
1984	* floprw -- Floppy read / write driver
1985	* ------ --------------------------
1986	floprw: link a6,#-6 * Reserve space for temps
1987	movem.l d2-d7/a5,-(a7) * Save registers
1988	move.w 16(a6),d0 * Drive number to d0
1989	asl.w #5,d0 * Shift ( *32 )
1990	ext.l d0 * Sign extend it, too
1991	move.l d0,a5 * Result in a5
1992	add.l #drvbpbs,a5 * Add base of BPB table
1993	btst #0,13(a6) * Buffer address even ?
1994	bne floprw01 * Jump if not
1995	*
1996	clr.w d0 * Clear odd flag
1997	bra floprw02 * Go save the flag
1998	*
1999	floprw01: moveq.l #1,d0 * Set odd flag
2000	*
2001	floprw02: move.w d0,-2(a6) * Save it
2002	tst.w 22(a5) * dspc set ?
2003	bne floprw20 * Jump if so
2004	*
2005	moveq.l #9,d0 * Assume 9
2006	move.w d0,22(a5) * ... and make it the default
2007	move.w d0,24(a5) * ... for dspt and dspc
2008	*
2009	floprw20: bra floprw18
2010	*
2011	floprw03: tst.w -2(a6) * Is odd flag set ?
2012	beq floprw04 * Jump if not
2013	*
2014	move.l #buffer,d0 * Point to sector buffer
2015	bra floprw05
2016	*
2017	floprw04: move.l 10(a6),d0 * Get buffer address
2018	*
2019	floprw05: move.l d0,-6(a6) * ... and save
2020	move.w 14(a6),d6 * Get recno (lsn)
2021	ext.l d6 * Extend it to long
2022	divs.w 22(a5),d6 * Divide by dspc for track #
2023	move.w 14(a6),d4 * Get recno
2024	ext.l d4 * Extend to long
2025	divs.w 22(a5),d4 * Divide by dspc
2026	swap d4 * Use remainder as sector number
2027	cmp.w 24(a5),d4 * Compare with dspt
2028	bge floprw06 * Greater than or equal ?
2029	*
2030	clr.l d5 * Use side 0
2031	bra floprw07
2032	*
2033	floprw06: moveq.l #1,d5 * Use side 1
2034	sub.w 24(a5),d4 * Subtract dspt from sector #
2035	*
2036	.page
2037	*
2038	floprw07: tst.w -2(a6) * Is odd flag set ?
2039	beq floprw08 * Jump if not
2040	*
2041	moveq.l #1,d3 * Set counter to 1
2042	bra floprw10
2043	*
2044	floprw08: move.w 24(a5),d0 * Get dspt
2045	sub.w d4,d0 * Subtract sector number
2046	cmp.w 18(a6),d0 * Compare with number of sectors
2047	bge floprw09 * Jump if greater than or eq to
2048	*
2049	move.w 24(a5),d3 * Get dspt
2050	sub.w d4,d3 * Subtract sector number
2051	bra floprw10
2052	*
2053	floprw09: move.w 18(a6),d3 * Count = number of sectors
2054	*
2055	floprw10: addq.w #1,d4 * Adjust sector number (1 org)
2056	*
2057	floprw11: tst.w 8(a6) * Test r/w flag
2058	beq floprw14 * Jump if it's a read
2059	*
2060	move.l -6(a6),d0 * Get buffer pointer
2061	cmp.l 10(a6),d0 * See if it's = buffer addr
2062	beq floprw12 * Jump if so
2063	*
2064	move.l -6(a6),(a7) * Get source address
2065	move.l 10(a6),-(a7) * Destination address
2066	jsr fastcopy * Copy the sector
2067	addq.l #4,a7 * Cleanup stack
2068	*
2069	floprw12: move.w d3,(a7) * Number of sectors
2070	move.w d5,-(a7) * Side number
2071	move.w d6,-(a7) * Track number
2072	move.w d4,-(a7) * Sector number
2073	move.w 16(a6),-(a7) * Drive number
2074	clr.l -(a7) * Filler
2075	move.l -6(a6),-(a7) * Buffer address
2076	jsr flopwr * Write sector
2077	add.l #16,a7 * Cleaup stack
2078	move.l d0,d7 * Save error code in d7
2079	tst.l d7 * Errors ?
2080	bne floprw13 * Jump if so
2081	*
2082	.page
2083	*
2084	tst.w fverify * Verify after write ?
2085	beq floprw13 * Jump if not
2086	*
2087	move.w d3,(a7) * Number of sectors
2088	move.w d5,-(a7) * Side number
2089	move.w d6,-(a7) * Track number
2090	move.w d4,-(a7) * Sector number
2091	move.w 16(a6),-(a7) * Drive number
2092	clr.l -(a7) * Filler
2093	move.l #buffer,-(a7) * Buffer address
2094	jsr flopver * Verify sector(s)
2095	add.l #16,a7 * Cleanup stack
2096	move.l d0,d7 * Save error code in d7
2097	tst.l d7 * Errors ?
2098	bne floprw13 * Jump if so
2099	*
2100	move.l #buffer,(a7) * Address of sector buffer
2101	bsr itom * Convert first word of buffer
2102	tst.w d0 * Bad sectors ?
2103	beq floprw13 * Jump if not
2104	*
2105	moveq.l #ERR16,d7 * ERROR -- "Bad sectors"
2106	*
2107	floprw13: bra floprw15
2108	*
2109	.page
2110	*
2111	floprw14: move.w d3,(a7) * Number of sectors
2112	move.w d5,-(a7) * Side number
2113	move.w d6,-(a7) * Track number
2114	move.w d4,-(a7) * Sector number
2115	move.w 16(a6),-(a7) * Drive number
2116	clr.l -(a7) * Filler
2117	move.l -6(a6),-(a7) * Sector buffer
2118	jsr floprd * Read floppy sector(s)
2119	add.l #16,a7 * Cleanup stack
2120	move.l d0,d7 * Save error code in d7
2121	move.l -6(a6),d0 * User buffer address
2122	cmp.l 10(a6),d0 * Is it the desired buffer ?
2123	beq floprw15 * Jump if so
2124	*
2125	move.l 10(a6),(a7) * Push source address
2126	move.l -6(a6),-(a7) * Push destination address
2127	jsr fastcopy * Copy the sector
2128	addq.l #4,a7 * Cleanup stack
2129	*
2130	floprw15: tst.l d7 * Error code set ?
2131	bge floprw16 * Jump if not
2132	*
2133	move.w 16(a6),(a7) * Push drive number
2134	move.l d7,d0 * Error code
2135	move.w d0,-(a7) * ... onto stack
2136	jsr criter * Call critical error handler
2137	addq.l #2,a7 * Cleanup stack
2138	move.l d0,d7 * Get error code
2139	*
2140	floprw16: cmp.l #RETRYIT,d7 * Re-try ?
2141	beq floprw11 * Jump if so
2142	*
2143	tst.l d7 * Check error code
2144	bge floprw17 * Jump if no error
2145	*
2146	move.l d7,d0 * Error code is the result
2147	bra floprw19
2148	*
2149	.page
2150	*
2151	floprw17: move.w d3,d0 * Sector counter to d0
2152	ext.l d0 * Sign extend
2153	moveq.l #9,d1 * Times 512
2154	asl.l d1,d0 * ...
2155	add.l d0,10(a6) * Update buffer address
2156	add.w d3,14(a6) * Update sector number
2157	sub.w d3,18(a6) * Update sector count
2158	*
2159	floprw18: tst.w 18(a6) * More sectors ?
2160	bne floprw03 * Jump if so
2161	*
2162	clr.l d0 * Set "no error" as result
2163	*
2164	floprw19: tst.l (a7)+ * Test top of stack
2165	movem.l (a7)+,d3-d7/a5 * Restore registers
2166	unlk a6 * Release stack space
2167	rts * Return to caller
2168	*
2169	.page
2170	*
2171	* itom -- Convert 8086 integer format to 680000 integer format
2172	* ---- ----------------------------------------------------
2173	itom: link a6,#-4 * Reserve stack for temps
2174	move.l 8(a6),a0 * Address of the number to a0
2175	move.b 1(a0),d0 * Get high byte
2176	ext.w d0 * Make it a word
2177	and.w #$FF,d0 * Isolate bits 0..7
2178	asl.w #8,d0 * Shift in bits 8..15
2179	move.l 8(a6),a1 * Address of the number to a1
2180	move.b (a1),d1 * Get low byte
2181	ext.w d1 * Extend to word
2182	and.w #$FF,d1 * Isolate bits 0..7
2183	or.w d1,d0 * Combine with bits 8..15
2184	unlk a6 * Release stack space
2185	rts * Return to caller
2186	*
2187	.page
2188	*
2189	* flopini -- Initialize floppy drive
2190	* ------- -----------------------
2191	flopini: lea dsb0,a1 * Point to dsb for drive A
2192	tst.w 12(a7) * Drive A wanted ?
2193	beq flopin01 * Jump if so
2194	*
2195	lea dsb1,a1 * Drive B dsb address to a1
2196	*
2197	flopin01: move.w seekrate,2(a1) * Get seek rate
2198	moveq.l #ERR01,d0 * Set default error number
2199	clr.w 0(a1) * Set track number to 0
2200	bsr floplock * Setup floppy parameters
2201	bsr select * Select drive and side
2202	move.w #$FF00,0(a1)
2203	bsr restore * Restore the drive
2204	moveq.l #6,d7
2205	bsr hseek1
2206	bne flopin02
2207	*
2208	bsr restore * Restore the drive
2209	beq flopok * Jump if no error
2210	*
2211	flopin02: bra flopfail * Jump to error handler
2212	*
2213	.page
2214	*
2215	* floprd -- Read floppy
2216	* ------ -----------
2217	floprd: bsr change * Disk changed ?
2218	moveq.l #ERR11,d0 * Set to "read error"
2219	bsr floplock * Set parameters
2220	*
2221	floprd01: bsr select * Select drive and side
2222	bsr go2track * Position on track
2223	bne floprd02 * Try again on error
2224	*
2225	move.w #ERR01,deferr * Set default error
2226	move.l edma(a5),a0 * Get final DMA address
2227	move.l cdma(a5),a2 * Get first DMA address
2228	move.l #$40000,d7 * Set timeout counter
2229	move.b #FL_RM,DSKCMD(a6) * Start readng the disk
2230	*
2231	floprd03: btst #0,DSKCMD(a6) * Disk busy yet ?
2232	bne floprd05 * Jump if so
2233	*
2234	subq.l #1,d7 * Decrement timeout counter
2235	beq floprd04 * Jump if timed out
2236	*
2237	bra floprd03 * Go try for busy again
2238	*
2239	floprd05: move.l #$40000,d7 * Reset timeout counter
2240	bra floprd09 * Go join main read loop
2241	*
2242	floprd07: subq.l #1,d7 * Decrement timeout counter
2243	beq floprd04 * Jump if timed out
2244	*
2245	btst #0,DSKCMD(a6) * Done yet ?
2246	beq floprd08 * Jump if so
2247	*
2248	floprd09: btst #1,DSKCMD(a6) * DRQ set ?
2249	beq floprd07 * Jump if not
2250	*
2251	move.b DSKDAT(a6),(a2)+ * Read the byte into the buffer
2252	cmp.l a0,a2 * Done reading ?
2253	bne floprd07 * Jump if not
2254	*
2255	.page
2256	*
2257	floprd08: move.b DSKCMD(a6),d0 * Read final status into d0
2258	and.b #$1C,d0 * Mask for error bits
2259	beq flopok * Jump if no errors
2260	*
2261	bsr errbits * Determine error code
2262	*
2263	floprd02: cmp.w #1,retrycnt(a5) * Re-try ?
2264	bne floprd06 * Jump if not
2265	*
2266	bsr reseek * Home and repeat the seek
2267	*
2268	floprd06: subq.w #1,retrycnt(a5) * Update re-try count
2269	bpl floprd01 * Re-try if count still >0
2270	*
2271	bra flopfail * Failure
2272	*
2273	floprd04: move.w #ERR02,curerr(a5) * Set error code "not ready"
2274	bsr rs1772 * Reset the WD1772
2275	bra floprd02 * See if it can be retried
2276	*
2277	.page
2278	*
2279	* errbits -- Develop error code for floppy I/O error
2280	* ------- ---------------------------------------
2281	errbits: moveq.l #ERR13,d1 * Write protect ?
2282	btst #6,d0 * ...
2283	bne errbits1 * Jump if so
2284	*
2285	moveq.l #ERR08,d1 * Record not found ?
2286	btst #4,d0 * ...
2287	bne errbits1 * Jump if so
2288	*
2289	moveq.l #ERR04,d1 * CRC error ?
2290	btst #3,d0 * ...
2291	bne errbits1 * Jump if so
2292	*
2293	moveq.l #ERR12,d1 * Lost data ?
2294	btst #2,d0 * ...
2295	bne errbits1 * Jump if so
2296	*
2297	move.w deferr(a5),d1 * Use default error
2298	*
2299	errbits1: move.w d1,curerr(a5) * ... as curerr
2300	rts * Return to caller
2301	*
2302	.page
2303	*
2304	* flopwr -- Floppy write
2305	* ------ ------------
2306	flopwr: bsr change * Check for disk change
2307	moveq.l #ERR10,d0 * Set write error
2308	bsr floplock * Set parameters
2309	move.w csect(a5),d0 * Get sector number in d0
2310	subq.w #1,d0 * ... -1
2311	or.w ctrack(a5),d0 * OR with track number
2312	or.w cside(a5),d0 * OR with side number
2313	bne flopwr01 * Jump if not boot sector
2314	*
2315	moveq.l #2,d0 * Media change
2316	bsr setdmode * Set to "unsure"
2317	*
2318	flopwr01: bsr select * Select drive and side
2319	bsr go2track * Seek
2320	bne flopwr06 * Re-try on error
2321	*
2322	flopwr02: move.w #ERR01,curerr(a5) * Set for default error
2323	move.l cdma(a5),a2 * Get I/O address
2324	move.l #$40000,d7 * Set timeout counter
2325	move.w ctrack(a5),d0 * Get track number
2326	cmpi.w #40,d0 * See if we need precomp
2327	bcs flopwr10 * Jump if not
2328	*
2329	move.b #FL_WS,DSKCMD(a6) * Write with precomp
2330	bra flopwr08 * Go join main write loop
2331	*
2332	flopwr10: move.b #FL_WS+FL_NC,DSKCMD(a6) * Write (no precomp)
2333	*
2334	.page
2335	*
2336	flopwr08: btst #0,DSKCMD(a6) * Busy yet ?
2337	bne flopwr09 * Jump if so
2338	*
2339	subq.l #1,d7 * Decrement tiemout count
2340	bne flopwr08 * Jump if not timed out
2341	*
2342	flopwr13: bsr rs1772 * Reset WD1772
2343	bra flopwr05 * See if we can retry
2344	*
2345	flopwr11: btst #0,DSKCMD(a6) * Done ?
2346	beq flopwr04 * Jump if so
2347	*
2348	flopwr09: btst #1,DSKCMD(a6) * DRQ set ?
2349	bne flopwr12 * Jump if so
2350	*
2351	subq.l #1,d7 * Decrement timeout counter
2352	beq flopwr13 * Jump if timed out
2353	*
2354	bra flopwr11 * Jump if not
2355	*
2356	flopwr12: move.b (a2)+,DSKDAT(a6) * Write byte to floppy
2357	bra flopwr11 * Go get the next one
2358	*
2359	.page
2360	*
2361	flopwr04: move.b DSKCMD(a6),d0 * Get floppy status
2362	bsr errbits * Set error code
2363	btst #6,d0 * Write protect error ?
2364	bne flopfail * Fail if so
2365	*
2366	and.b #$5C,d0 * Mask error bits
2367	bne flopwr05 * Jump if an error occurred
2368	*
2369	addq.w #1,csect(a5) * Update sector number
2370	add.l #512,cdma(a5) * Update DMA address
2371	subq.w #1,ccount(a5) * Decrement sector count
2372	beq flopok * Jump if zero -- done
2373	*
2374	bsr select1 * Set sector and DMA pointer
2375	bra flopwr02 * Write next sector
2376	*
2377	flopwr05: cmp.w #1,retrycnt(a5) * Second re-try ?
2378	bne flopwr07 * Jump if not
2379	*
2380	flopwr06: bsr reseek * Restore and re-seek
2381	*
2382	flopwr07: subq.w #1,retrycnt(a5) * Update re-try count
2383	bpl flopwr01 * Re-try if still >0
2384	*
2385	bra flopfail * ... else fail
2386	*
2387	.page
2388	*
2389	* flopfmt -- Format a track on the floppy
2390	* ------- ----------------------------
2391	flopfmt: cmp.l #FMAGIC,22(a7) * Is the magic right ?
2392	bne flopfail * Fail immediately if not
2393	*
2394	bsr change * Check for disk change
2395	moveq.l #ERR01,d0 * Set default error number
2396	bsr floplock * Set parameters
2397	bsr select * Select drive and side
2398	move.w 14(a7),spt(a5) * Set sectors per track,
2399	move.w 20(a7),interlv(a5) * ... interleave,
2400	move.w 26(a7),virgin(a5) * ... initial data,
2401	moveq.l #2,d0 * Disk changed
2402	bsr setdmode * ...
2403	bsr hseek * Seek
2404	bne flopfail * Fail if seek error occurs
2405	*
2406	move.w ctrack(a5),0(a1) * Current track to DSB
2407	move.w #ERR01,curerr(a5) * Default to curerr
2408	bsr fmtrack * Format the track
2409	bne flopfail * Fail if error occurs
2410	*
2411	move.w spt(a5),ccount(a5) * Use spt as ccount
2412	move.w #1,csect(a5) * Start with sector 1
2413	bsr verify1 * Verify the sector
2414	move.l cdma(a5),a2 * Get bad sector list
2415	tst.w (a2) * Any bad ones ?
2416	beq flopok * Jump if not
2417	*
2418	move.w #ERR16,curerr(a5) * ERROR -- "bad sectors"
2419	bra flopfail
2420	*
2421	.page
2422	*
2423	* fmtrack -- Do the dirty work of formatting a track
2424	* ------- ---------------------------------------
2425	fmtrack: move.w #ERR10,deferr(a5) * Set default error number
2426	move.w #1,d3 * Start with sector 1
2427	move.l cdma(a5),a2 * Get track buffer address
2428	move.w #60-1,d1 * Set count = 60
2429	move.b #$4E,d0 * Write $4E as initial gap
2430	bsr wmult * ...
2431	*
2432	fmtrak01: move.w d3,d4 * Save sector number in d4
2433	*
2434	fmtrak02: move.w #12-1,d1 * Set count = 12
2435	clr.b d0 * Write $00 as sync
2436	bsr wmult * ...
2437	move.w #3-1,d1 * Set count = 3
2438	move.b #$F5,d0 * Write $F5's
2439	bsr wmult * ...
2440	move.b #$FE,(a2)+ * Write $FE (address mark)
2441	move.b ctrack+1,(a2)+ * Write track #
2442	move.b cside+1,(a2)+ * Write side #
2443	move.b d4,(a2)+ * Write sector #
2444	move.b #2,(a2)+ * Write sector size code
2445	move.b #$F7,(a2)+ * Write checksum code
2446	move.w #22-1,d1 * Set count = 22
2447	move.b #$4E,d0 * Write gap
2448	bsr wmult * ...
2449	move.w #12-1,d1 * Set count = 12
2450	clr.b d0 * Write $00 as sync
2451	bsr wmult * ...
2452	move.w #3-1,d1 * Set count = 3
2453	move.b #$F5,d0 * Write $F5's
2454	bsr wmult * ...
2455	move.b #$FB,(a2)+ * Write DAM
2456	move.w #256-1,d1 * Set count = 256 words
2457	*
2458	.page
2459	*
2460	fmtrak03: move.b virgin(a5),(a2)+ * Write virgin data in buffer
2461	move.b virgin+1(a5),(a2)+ * ...
2462	dbf d1,fmtrak03 * ...
2463	*
2464	move.b #$F7,(a2)+ * Write CRC code
2465	move.w #40-1,d1 * Set count = 40
2466	move.b #$4E,d0 * Write gap
2467	bsr wmult * ...
2468	add.w interlv(a5),d4 * Add interleave to sector #
2469	cmp.w spt(a5),d4 * Check against spt
2470	ble fmtrak02 * Jump if not >
2471	*
2472	addq.w #1,d3 * Starting sector +1
2473	cmp.w interlv(a5),d3
2474	ble fmtrak01
2475	*
2476	move.w #1401-1,d1 * Set count = 1401
2477	move.b #$4E,d0 * Write final gap
2478	bsr wmult * ...
2479	move.l cdma(a5),a2 * Get buffer address
2480	move.l #$40000,d7 * Set timeout count
2481	move.w ctrack(a5),d0 * Get track number
2482	cmpi.w #40,d0 * Do we need precomp ?
2483	bcs fmtrak08 * Jump if not
2484	*
2485	move.b #FL_WT,DSKCMD(a6) * Start format with precomp
2486	bra fmtrak07 * Go join main format loop
2487	*
2488	fmtrak08: move.b #FL_WT+FL_NC,DSKCMD(a6) * Start format without precomp
2489	*
2490	.page
2491	*
2492	fmtrak07: btst #0,DSKCMD(a6) * Busy yet ?
2493	bne fmtrak09 * Jump if so
2494	*
2495	fmtrak04: subq.l #1,d7 * Decrement timeout counter
2496	bne fmtrak07 * Jump if not timed out
2497	*
2498	fmtrak05: bsr rs1772 * Reset WD1772
2499	moveq.l #1,d7 * Set error flag
2500	rts * Return to caller
2501	*
2502	fmtrak11: btst #0,DSKCMD(a6) * Done ?
2503	beq fmtrak06 * Jump if so
2504	*
2505	fmtrak09: btst #1,DSKCMD(a6) * DRQ set ?
2506	bne fmtrak10 * Jump if so
2507	*
2508	subq.l #1,d7 * Decrement timeout coutner
2509	beq fmtrak05 * Jump if timed out
2510	*
2511	bra fmtrak11 * Go check again
2512	*
2513	fmtrak10: move.b (a2)+,DSKDAT(a6) * Write a byte of format
2514	bra fmtrak11 * Go wait for DRQ
2515	*
2516	fmtrak06: move.b DSKCMD(a6),d0 * Get final status
2517	bsr errbits * Set possible error code
2518	andi.b #$44,d0 * Check error bits
2519	rts * Return to caller with status
2520	*
2521	* wmult -- write multiple bytes into the track buffer
2522	* ----- ------------------------------------------
2523	wmult: move.b d0,(a2)+ * Move a byte into the buffer
2524	dbf d1,wmult * Loop until we're done
2525	*
2526	rts * Return to caller
2527	*
2528	.page
2529	*
2530	* flopver -- verify sector(s) on a floppy
2531	* ------- ----------------------------
2532	flopver: bsr change * Check for disk change
2533	moveq.l #ERR11,d0 * Set default to "read error"
2534	bsr floplock * Set parameters
2535	bsr select * Select drive and side
2536	bsr go2track * Seek
2537	bne flopfail * Jump if seek error
2538	*
2539	bsr verify1 * Verify the data
2540	bra flopok * Done
2541	*
2542	* verify1 -- Verify the data for a sector
2543	* ------- ----------------------------
2544	verify1: move.w #ERR11,deferr(a5) * Set default = "read error"
2545	move.l cdma(a5),a2 * Pointer for bad sector list
2546	add.l #512,cdma(a5) * Update by length of a sector
2547	*
2548	verify01: move.w #2,retrycnt(a5) * Set retrycnt for 2 attempts
2549	move.w csect(a5),d7 * Get sector nubmer
2550	move.b d7,DSKSEC(a6) * Send to WD1772
2551	*
2552	verify02: moveq.l #0,d6 * Clear bad compare flag
2553	move.l cdma(a5),a0 * Get compare address
2554	move.l #$40000,d7 * Set timeout counter
2555	move.b #FL_RS,DSKCMD(a6) * Start the read
2556	*
2557	verify08: btst #0,DSKCMD(a6) * Busy yet ?
2558	bne verify09 * Jump if so
2559	*
2560	subq.l #1,d7 * Decrement timeout counter
2561	beq verify13 * Jump if timed out
2562	*
2563	bra verify08 * Wait for busy some more
2564	*
2565	verify09: move.l #$40000,d7 * Reset timeout counter
2566	bra verify11 * Go join main compare loop
2567	*
2568	verify10: subq.l #1,d7 * Decrement timeout counter
2569	beq verify13 * Jump if timed out
2570	*
2571	btst #0,DSKCMD(a6) * Done yet ?
2572	beq verify12 * Jump if so
2573	*
2574	.page
2575	*
2576	verify11: btst #1,DSKCMD(a6) * DRQ set ?
2577	beq verify10 * Jump if not
2578	*
2579	move.b DSKDAT(a6),d0 * Read data
2580	bra verify10 * Continue reading
2581	*
2582	verify12: move.b DSKCMD(a6),d0 * Get final status
2583	bsr errbits * Determine error code
2584	and.b #$1C,d0 * Mask RNF, CRC, LOST
2585	bne verify06 * Jump to re-try if any set
2586	*
2587	verify05: addq.w #1,csect(a5) * Update sector number
2588	subq.w #1,ccount(a5) * Update sector count
2589	bne verify01 * Jump if more to do
2590	*
2591	sub.l #512,cdma(a5) * Reset DMA pointer
2592	clr.w (a2) * Set NIL in bad sector list
2593	rts * Return to caller
2594	*
2595	verify06: cmp.w #1,retrycnt(a5) * Is it the 2nd attempt ?
2596	bne verify07 * Jump if not
2597	*
2598	bsr reseek * Restore and re-seek
2599	*
2600	verify07: subq.w #1,retrycnt(a5) * Decrement retry count
2601	bpl verify02 * Re-try if still positive
2602	*
2603	move.w csect(a5),(a2)+ * Add to bad sector list
2604	bra verify05 * Go do next sector
2605	*
2606	verify13: move.w #ERR02,curerr(a5) * Set timeout error code
2607	bsr rs1772 * Reset WD1772
2608	bra verify06 * See if we can retry it
2609	*
2610	.page
2611	*
2612	* flopvbl -- Floppy VBL timer interrupt handling
2613	* ------- -----------------------------------
2614	flopvbl: movem.l d0-d1/a0-a1/a5-a6,-(a7) * Save registers
2615	sub.l a5,a5 * Clear a5 for use as RAM base
2616	lea FLOPPY,a6 * Base of floppy regs
2617	st motoron(a5) * Set motoron flag
2618	move.l frclock(a5),d0 * Get interrupt count
2619	move.b d0,d1 * ...
2620	and.b #7,d1 * ... MOD 8
2621	bne flopvb02 * Jump if not 8th int
2622	*
2623	move.w sr,-(a7) * Save interrupt level
2624	ori.w #IPL7,sr * Mask off interrupts
2625	clr.w deslflag(a5) * Clear deselect flag
2626	move.b mc1iorec+cfr1,d0 * Get port status
2627	ori.b #1,d0 * Set drive select bit
2628	move.b d0,MC1ACIA+ACIA_CFR * Send drive select to port
2629	move.b d0,mc1iorec+cfr1 * Store updated port status
2630	move.w (a7)+,sr * Restore interrupt level
2631	lea wpstatus(a5),a0 * Point at wpstatus for drive
2632	lea dsb0(a5),a1 * Point at dsb0
2633	move.b DSKCMD(a6),d0 * Read WD1772 status
2634	btst #6,d0 * Test write protect bit
2635	sne (a0) * ... and save
2636	*
2637	.page
2638	*
2639	flopvb02: move.w wpstatus(a5),d0 * Get wpstatus of drive A
2640	or.w d0,wplatch(a5) * OR into wplatch
2641	tst.w deslflag(a5) * Floppies already deselected ?
2642	bne flopvb03 * Jump if so
2643	*
2644	move.b DSKCMD(a6),d0 * Read WD1772 status
2645	btst #7,d0 * Motor-on bit set ?
2646	bne flopvb04 * Don't de-select if it is
2647	*
2648	move.w sr,-(a7) * Save sr
2649	ori.w #IPL7,sr * Disable interrupts
2650	move.b mc1iorec+cfr1,d0 * Get cfr1 image
2651	bclr #0,d0 * Clear d0 (drive select)
2652	move.b d0,mc1iorec+cfr1 * Save new value
2653	move.b d0,MC1ACIA+ACIA_CFR * Send to hardware
2654	move.w (a7)+,sr * Restore sr (enable ints)
2655	move.w #1,deslflag(a5) * Set the deselect flag
2656	*
2657	flopvb03: clr.w motoron(a5) * Clear motoron flag
2658	*
2659	flopvb04: movem.l (a7)+,d0-d1/a0-a1/a5-a6 * Restore registers
2660	rts * Return to caller
2661	*
2662	.page
2663	*
2664	* floplock -- Setup floppy parameters
2665	* -------- -----------------------
2666	floplock: movem.l d3-d7/a3-a6,flpregs * Save registers
2667	move.w sr,flpsrsv * Save sr
2668	ori.w #IPL7,sr * Disable ints
2669	sub.l a5,a5 * Clear a5
2670	lea FLOPPY,a6 * Base of floppy registers
2671	st motoron(a5) * Set motoron flag
2672	move.w d0,deferr(a5) * Set default error code
2673	move.w d0,curerr(a5) * ... current error code
2674	move.w #1,flock(a5) * Disable flopvbl routine
2675	move.l 8(a7),cdma(a5) * Set cdma
2676	move.w 16(a7),cdev(a5) * ... cdev
2677	move.w 18(a7),csect(a5) * ... csect
2678	move.w 20(a7),ctrack(a5) * ... ctrack
2679	move.w 22(a7),cside(a5) * ... cside
2680	move.w 24(a7),ccount(a5) * ... ccount
2681	move.w #2,retrycnt(a5) * ... retrycnt
2682	lea dsb0(a5),a1 * Address of dsb0
2683	tst.w cdev(a5) * Drive A ?
2684	beq floplk01 * Jump if so
2685	*
2686	lea dsb1(a5),a1 * Drive B, use dsb1
2687	*
2688	floplk01: moveq.l #0,d7 * Clear out d7
2689	move.w ccount(a5),d7 * Get ccount
2690	lsl.w #8,d7 * ... * sector length (512)
2691	lsl.w #1,d7 * ...
2692	move.l cdma(a5),a0 * Get DMA start address
2693	add.l d7,a0 * Add length of sectors
2694	move.l a0,edma(a5) * Set edma (end DMA address)
2695	tst.w 0(a1) * Check current track
2696	bpl floplk03 * Jump if >= 0
2697	*
2698	bsr select * Select the drive
2699	clr.w 0(a1) * Set current track to 0
2700	bsr restore * Restore drive to track 0
2701	beq floplk03 * Jump if OK
2702	*
2703	moveq.l #10,d7 * Seek out to track 10
2704	bsr hseek1 * ...
2705	bne floplk02 * Jump if an error occurred
2706	*
2707	bsr restore * Try the restore again
2708	beq floplk03 * Jump if OK
2709	*
2710	floplk02: move.w #$FF00,0(a1) * Recalibrate error
2711	*
2712	floplk03: rts * Return to caller
2713	*
2714	.page
2715	*
2716	* flopfail -- Floppy I/O failure exit
2717	* -------- -----------------------
2718	flopfail: moveq.l #1,d0 * Set media change to "unsure"
2719	bsr setdmode * ...
2720	move.w curerr(a5),d0 * Get curerr
2721	ext.l d0 * ...
2722	bra flopok1 * Go set end status
2723	*
2724	* flopok -- Floppy I/O success exit
2725	* ------ -----------------------
2726	flopok: clr.l d0 * Set error code = 0 (no error)
2727	*
2728	flopok1: move.l d0,-(a7) * Push code onto stack
2729	move.w 0(a1),d7 * Get track number
2730	move.b d7,DSKDAT(a6) * Send to WD1772
2731	move.w #FL_SK,d6 * Seek command to d6
2732	bsr flopcmds * Send command
2733	move.w cdev(a5),d0 * Get drive number
2734	lsl.w #2,d0 * Use as index
2735	lea acctim(a5),a0 * ... into acctim
2736	move.l _hz_200(a5),0(a0,d0) * Set last access time
2737	cmp.w #1,nflops(a5)
2738	bne flopok01
2739	*
2740	move.l _hz_200(a5),4(a0) * Time for other drive
2741	*
2742	flopok01: move.w flpsrsv,sr * Restore sr (enable ints)
2743	move.l (a7)+,d0 * Restore error number to d0
2744	movem.l flpregs,d3-d7/a3-a6 * Restore registers
2745	clr.w flock * Release flopvbl routine
2746	rts * Return to caller
2747	*
2748	.page
2749	*
2750	* hseek -- seek to track in ctrack
2751	* ----- -----------------------
2752	hseek: move.w ctrack,d7 * Get ctrack
2753	*
2754	* hseek1 -- seek to track in d7
2755	* ------ -------------------
2756	hseek1: move.w #ERR10,curerr * Set curerr = "seek error"
2757	move.b d7,DSKDAT(a6) * Send track number to WD1772
2758	move.w #FL_SK,d6 * Seek command
2759	bra flopcmds * Go send command to WD1772
2760	*
2761	* reseek -- Restore, then re-seek
2762	* ------ ---------------------
2763	reseek: move.w #ERR10,curerr * Set curerr = "seek error"
2764	bsr restore * Restore
2765	bne reseek01 * Jump if error occurred
2766	*
2767	clr.w 0(a1) * Clear current track to 0
2768	move.b #0,DSKTRK(a6) * Send track to WD1772
2769	move.b #5,DSKDAT(a6) * Setup to seek to track 5
2770	move.w #FL_SK,d6 * Seek command
2771	bsr flopcmds * Seek
2772	bne reseek01 * Jump if error
2773	*
2774	move.w #5,0(a1) * Update current track = 5
2775	*
2776	* go2track -- seek with verify
2777	* -------- ----------------
2778	go2track: move.w #ERR10,curerr(a5) * Set curerr = "seek error"
2779	move.w ctrack(a5),d7 * Put track # in d7
2780	move.b d7,DSKDAT(a6) * Send track to WD1772
2781	moveq.l #FL_SV,d6 * Seek/verify command
2782	bsr flopcmds * Send command to floppy
2783	bne reseek01 * Jump if error occurred
2784	*
2785	move.w ctrack(a5),0(a1) * Update track number in dsb
2786	and.b #$18,d7 * Test for RNF, CRC, LOST
2787	*
2788	reseek01: rts * Return to caller
2789	*
2790	.page
2791	*
2792	* restore -- Restore to track 0
2793	* ------- ------------------
2794	restore: clr.w d6 * Restore command
2795	bsr flopcmds * Send to WD1772
2796	bne restor01 * Jump if an error occurred
2797	*
2798	btst #2,d7 * Check track 0 bit
2799	eori #0004,sr * Invert Z flag in 680000 sr
2800	bne restor01 * Jump if not track 0
2801	*
2802	clr.w 0(a1) * Set track = 0 in dsb
2803	*
2804	restor01: rts * Return to caller
2805	*
2806	* flopcmds -- Send command to WD1772 floppy controller
2807	* -------- ----------------------------------------
2808	flopcmds: move.w 2(a1),d0 * Get seek rate from dsb
2809	and.b #$3,d0 * ...
2810	or.b d0,d6 * OR into command word
2811	move.l #$40000,d7 * Set timeout counter
2812	btst #7,DSKCMD(a6) * Motor on ?
2813	bne flopcm01 * Jump if so
2814	*
2815	move.l #$60000,d7 * Set longer timeout count
2816	*
2817	flopcm01: move.b d6,DSKCMD(a6) * Write command from d6
2818	*
2819	move.l #$1000,d0 * Set initial busy timeout in d0
2820	*
2821	flopcm04: btst #0,DSKCMD(a6) * Controller busy yet ?
2822	bne flopcm02 * Jump if so
2823	*
2824	subq.l #1,d0 * Decrement timeout counter
2825	beq flopcm03 * Jump if timed out
2826	*
2827	bra flopcm04 * Wait for busy some more
2828	*
2829	flopcm02: subq.l #1,d7 * Decrement timeout counter
2830	beq flopcm03 * Jump if timed out
2831	*
2832	btst #0,DSKCMD(a6) * WD1772 done ?
2833	bne flopcm02 * Jump if not
2834	*
2835	clr.l d7 * Clear out upper bits of d7
2836	move.b DSKCMD(a6),d7 * Read status into LS byte of d7
2837	clr.l d6 * Clear error flag in d6
2838	rts * Return to caller
2839	*
2840	flopcm03: bsr rs1772 * Reset WD1772 (end transfer)
2841	moveq.l #1,d6 * Set error flag in d6
2842	rts * Return to caller
2843	*
2844	.page
2845	*
2846	* rs1772 -- Reset WD1772 floppy controller
2847	* ------ ------------------------------
2848	rs1772: move.b #FL_FR,DSKCMD(a6) * Send reset to WD1772
2849	move.w #15,d7 * Set delay count
2850	*
2851	rs1772a: dbf d7,rs1772a * Delay a while
2852	rts * Return to caller
2853	*
2854	* select -- Select drive and side
2855	* ------ ----------------------
2856	select: move.w sr,-(a7) * Save sr on stack
2857	ori.w #IPL7,sr * Disable interrupts
2858	clr.w deslflag(a5) * Clear deselect flag
2859	move.b mc1iorec+cfr1,d0 * Get current MC1 cfr1 image
2860	ori.b #1,d0 * Select drive (we only have 1)
2861	move.b d0,mc1iorec+cfr1 * Store updated image
2862	move.b d0,MC1ACIA+ACIA_CFR * Send it to the MC1 ACIA
2863	move.w cside(a5),d0 * Get side number (LS bit)
2864	and.w #1,d0 * Mask off garbage bits
2865	andi.b #$FE,mc2iorec+cfr1 * Mask off D0 in MC2 cfr1 image
2866	or.b mc2iorec+cfr1,d0 * OR side with mc2iorec cfr1
2867	move.b d0,mc2iorec+cfr1 * Store updated cfr1 image
2868	move.b d0,MC2ACIA+ACIA_CFR * Send it to the MC2 ACIA
2869	move.w (a7)+,sr * Restore interrupts
2870	move.w 0(a1),d7 * Get track from dsb
2871	move.b d7,DSKTRK(a6) * Send it to the WD1772
2872	clr.b tmpdma(a5) * Clear bits 31..24 of tmpdma
2873	*
2874	select1: move.w csect(a5),d7 * Get sector number
2875	move.b d7,DSKSEC(a6) * Send it to the WD1772
2876	move.l cdma(a5),a0 * Setup transfer address in a0
2877	rts * Return to caller
2878	*
2879	.page
2880	*
2881	* change -- Check for disk change status
2882	* ------ ----------------------------
2883	change: cmp.w #1,nflops * Check # of floppies
2884	bne change02
2885	*
2886	move.w 16(a7),d0 * Drive number to d0
2887	cmp.w disknum,d0
2888	beq change01 * Jump if =
2889	*
2890	move.w d0,-(a7) * Stack drive number
2891	move.w #ERR17,-(a7) * Stack error code
2892	bsr criter * Do critical error routine
2893	addq.w #4,a7 * Cleanup stack
2894	move.w #$FFFF,wplatch * Status for drives = "unsure"
2895	move.w 16(a7),disknum * Save disk number
2896	*
2897	change01: clr.w 16(a7) * Clear disk number
2898	*
2899	change02: rts * Return to caller
2900	*
2901	* setdmode -- Set drive change mode
2902	* -------- ---------------------
2903	setdmode: lea dskmode,a0 * Point at disk mode table
2904	move.b d0,-(a7) * Save mode on stack
2905	move.w cdev(a5),d0 * Get drive number
2906	move.b (a7)+,0(a0,d0) * Set drive mode / cleanup stack
2907	rts * Return to caller
2908	*
2909	.page
2910	*
2911	* bootload -- Load boot sector
2912	* -------- ----------------
2913	bootload: link a6,#0 * Link stack frames
2914	movem.l d6-d7,-(a7) * Save registers
2915	jsr _hdvini * Init drive
2916	tst.w nflops * See if any connected
2917	beq bootld01 * Jump if drive there
2918	*
2919	moveq.l #1,d0 * "couldn't load"
2920	bra bootld02
2921	*
2922	bootld01: moveq.l #2,d0 * "no drive connected"
2923	*
2924	bootld02: move.w d0,d7 * Save possible error in d7
2925	tst.w nflops
2926	beq bootld04
2927	*
2928	cmp.w #2,bootdev
2929	bge bootld04
2930	*
2931	move.w #1,(a7) * Sector count = 1,
2932	clr.w -(a7) * ... side = 0,
2933	clr.w -(a7) * ... track = 0,
2934	move.w #1,-(a7) * ... sector = 1,
2935	move.w bootdev,-(a7) * ... drive = bootdev,
2936	clr.l -(a7) * ... filler,
2937	move.l #buffer,-(a7) * ... buffer address
2938	jsr floprd * Read the sector
2939	add.l #16,a7 * Cleanup stack
2940	tst.l d0 * Error ?
2941	bne bootld03 * Jump if not
2942	*
2943	clr.w d7
2944	bra bootld04
2945	*
2946	bootld03: tst.b wpstatus
2947	bne bootld04
2948	*
2949	moveq.l #3,d0 * "unreadable"
2950	bra bootld07
2951	*
2952	bootld04: tst.w d7
2953	beq bootld05
2954	*
2955	move.w d7,d0 * Get old error code
2956	bra bootld07
2957	*
2958	.page
2959	*
2960	bootld05: move.w #256,(a7) * Set count for 256 words
2961	move.l #buffer,-(a7) * Point at buffer
2962	bsr chksum * Calculate checksum
2963	addq.l #4,a7 * Cleanup stack
2964	cmp.w #$1234,d0 * Boot sector checksum ?
2965	bne bootld06 * Jump if not
2966	*
2967	clr.w d0 * Set flag for OK
2968	move.w bootdev,booted * Save last boot device
2969	bra bootld07
2970	*
2971	bootld06: moveq.l #4,d0 * "not valid boot sector"
2972	*
2973	bootld07: tst.l (a7)+
2974	movem.l (a7)+,d7 * Restore registers
2975	unlk a6
2976	rts * Return to caller
2977	*
2978	.page
2979	*
2980	* chksum -- caluculate checksum
2981	* ------ -------------------
2982	chksum: link a6,#0
2983	movem.l d6-d7,-(a7) * Preserve registers
2984	clr.w d7 * Clear sum
2985	bra chksum02 * Jump into loop
2986	*
2987	chksum01: move.l 8(a6),a0 * Get buffer address
2988	move.w (a0),d0 * Get word
2989	add.w d0,d7 * Add to checksum in d7
2990	addq.l #2,8(a6) * Update buffer address
2991	*
2992	chksum02: move.w 12(a6),d0 * Get word count
2993	subq.w #1,12(a6) * Decrement it
2994	tst.w d0 * Done ?
2995	bne chksum01 * Loop if not
2996	*
2997	move.w d7,d0 * Put result in d0
2998	tst.l (a7)+
2999	movem.l (a7)+,d7 * Restore registers
3000	unlk a6
3001	rts * Return to caller
3002	*
3003	.page
3004	*
3005	* mult32 -- 32 bit signed multiply
3006	* ------ ----------------------
3007	mult32: link a6,#-4
3008	clr.w d2
3009	tst.l 8(a6)
3010	bge mult32a
3011	*
3012	neg.l 8(a6)
3013	addq.w #1,d2
3014	*
3015	mult32a: tst.l 12(a6)
3016	bge mult32b
3017	*
3018	neg.l 12(a6)
3019	addq.w #1,d2
3020	*
3021	mult32b: move.w 10(a6),d0
3022	mulu 14(a6),d0
3023	move.l d0,-4(a6)
3024	move.w 8(a6),d0
3025	mulu 14(a6),d0
3026	move.w 12(a6),d1
3027	mulu 10(a6),d1
3028	add.w d1,d0
3029	add.w -4(a6),d0
3030	move.w d0,-4(a6)
3031	move.l -4(a6),d0
3032	btst #0,d2
3033	beq mult32c
3034	*
3035	neg.l d0
3036	*
3037	mult32c: unlk a6
3038	rts
3039	*
3040	.page
3041	*
3042	* rand -- Generate a random number
3043	* ---- ------------------------
3044	rand: link a6,#-4 * Reserve stack for temps
3045	tst.l rseed * See if the seed is zero
3046	bne rand01 * Jump if not
3047	*
3048	move.l _hz_200,d0 * Pick up the 200 Hz clock
3049	moveq.l #16,d1 * Shift it left
3050	asl.l d1,d0 * ...
3051	or.l _hz_200,d0 * OR in current 200 Hz clock
3052	move.l d0,rseed * Use that as the seed
3053	*
3054	rand01: move.l #$BB40E62D,-(a7) * Put PI on the stack
3055	move.l rseed,-(a7) * ... and rseed, too
3056	bsr mult32 * Multiply them
3057	addq.l #8,a7 * Cleanup stack
3058	addq.l #1,d0 * Add 1 to the result
3059	move.l d0,rseed * Save as new seed
3060	move.l rseed,d0
3061	asr.l #8,d0 * Make it a 24 bit number
3062	and.l #$FFFFFF,d0 * ...
3063	unlk a6 * Release stack
3064	rts * Return to caller
3065	*
3066	.page
3067	*
3068	* protobt -- Generate a prototype boot sector
3069	* ------- --------------------------------
3070	protobt: link a6,#-6
3071	movem.l d5-d7/a5,-(a7) * Save registers
3072	tst.w 18(a6) * Test execflg
3073	bge protbt03 * Jump if set
3074	*
3075	move.w #256,(a7) * Count = 256 words
3076	move.l 8(a6),-(a7) * Address of buffer
3077	bsr chksum * Calculate checksum
3078	addq.l #4,a7 * Cleanup stack
3079	cmp.w #$1234,d0 * Boot checksum ?
3080	beq protbt01 * Jump if so
3081	*
3082	clr.w d0 * Not executable
3083	bra protbt02
3084	*
3085	protbt01: moveq.l #1,d0 * Executable
3086	*
3087	protbt02: move.w d0,18(a6) * Set execflg
3088	*
3089	protbt03: tst.l 12(a6) * Serial number ?
3090	blt protbt07 * Jump if not to be changed
3091	*
3092	move.l 12(a6),d0 * Get it into d0
3093	cmp.l #$FFFFFF,d0 * > $FFFFFF
3094	ble protbt04 * Jump if not
3095	*
3096	bsr rand * Generate a random number
3097	move.l d0,12(a6) * Save as s/n
3098	*
3099	protbt04: clr.w d7 * Clear counter
3100	bra protbt06 * Enter move loop
3101	*
3102	.page
3103	*
3104	protbt05: move.l 12(a6),d0 * Get s/n
3105	and.l #$FF,d0 * Isolate low 8 bits
3106	move.w d7,a1 * Point to next byte
3107	add.l 8(a6),a1 * ...
3108	move.b d0,8(a1) * Write byte in buffer
3109	move.l 12(a6),d0 * Get s/n
3110	asr.l #8,d0 * Shift right 8 bits
3111	move.l d0,12(a6) * Save shifted value
3112	addq.w #1,d7 * Update counter
3113	*
3114	protbt06: cmp.w #3,d7 * See if we're done
3115	blt protbt05 * Loop if not
3116	*
3117	protbt07: tst.w 16(a6) * Diskette size ?
3118	blt protbt10 * Jump if not to be changed
3119	*
3120	move.w 16(a6),d6 * Get diskette size
3121	muls.w #19,d6 * ... times 19 as pointer
3122	clr.w d7 * Clear counter
3123	bra protbt09 * Go move in BPB
3124	*
3125	protbt08: move.w d7,a0 * Get counter
3126	add.l 8(a6),a0 * Add base of buffer
3127	move.w d6,a1 * Get BPB pointer
3128	add.l #pbpbtab,a1 * Add base of prototype BPB's
3129	move.b (a1),11(a0) * Copy BPB data
3130	addq.w #1,d6 * Update pointer
3131	addq.w #1,d7 * Update counter
3132	*
3133	protbt09: cmp.w #19,d7 * Done ?
3134	blt protbt08 * Loop if not
3135	*
3136	protbt10: clr.w -6(a6)
3137	move.l 8(a6),-4(a6)
3138	bra protbt12
3139	*
3140	.page
3141	*
3142	protbt11: move.l -4(a6),a0 * Get buffer pointer
3143	move.w (a0),d0 * Get word from buffer
3144	add.w d0,-6(a6) * Sum for checksum
3145	addq.l #2,-4(a6) * Point at next word
3146	*
3147	protbt12: move.l 8(a6),d0 * Get buffer address
3148	add.l #$1FE,d0 * Plus sector length
3149	cmp.l -4(a6),d0 * Done ?
3150	bhi protbt11 * Loop if not
3151	*
3152	move.w #$1234,d0 * Checksum for boot sector
3153	sub.w -6(a6),d0 * Subtract checksum for buffer
3154	move.l -4(a6),a1
3155	move.w d0,(a1) * Store checksum in buffer
3156	tst.w 18(a6) * Check execflg
3157	bne protbt13 * Boot sector to be executable ?
3158	*
3159	move.l -4(a6),a0 * Mung checksum so it's not
3160	addq.w #1,(a0)
3161	*
3162	protbt13: tst.l (a7)+
3163	movem.l (a7)+,d6-d7/a5 * Restore registers
3164	unlk a6 * Release stack
3165	rts * Return to caller
3166	*
3167	.endc
3168	*
3169	* criter -- Critical error handler
3170	* ------ ----------------------
3171	criter: move.l critvec,-(a7) * Put error vector on stack
3172	moveq.l #-1,d0 * Set default error return
3173	rts * "Return" to handler
3174	*
3175	.page
3176	*
3177	.ifne BUCHLA
3178	*
3179	* api_int -- Analog processor interrupt handler
3180	* ------- ----------------------------------
3181	api_int: movem.l d0-d1/a0-a1,-(a7) * Save registers
3182	clr.l d0 * Read input port
3183	move.b ANALOG,d0 * ... into d0[7..0]
3184	move.b d0,api_inp * ... and api_inp
3185	btst #7,d0 * Check for signal number flag
3186	bne api_s0a * Jump if signal number read
3187	*
3188	lea api_tv,a0 * Get api_tv base in a0
3189	clr.w d1 * Get api_sv in d1
3190	move.b api_sv,d1 * ...
3191	cmpi.b #6,d1 * Check range
3192	bgt api_sve * Jump if out of range
3193	*
3194	lsl.w #2,d1 * Develop jump address
3195	move.l 0(a0,d1.W),a1 * ... from api_tv in a1
3196	jmp (a1) * Jump to state handler
3197	*
3198	api_s0: btst #7,d0 * Check for signal number flag
3199	beq api_ret * Jump if not signal number
3200	*
3201	api_s0a: clr.b api_val * Clear value byte
3202	andi.b #$7F,d0 * Mask off signal number flag
3203	cmpi.b #82,d0 * See if it's in range
3204	bgt api_err * Jump if out of range (GT 82)
3205	*
3206	move.b d0,api_sig * Store signal number
3207	beq api_pub * Jump if it was "all off"
3208	*
3209	lea api_tab,a0 * Get sv table base
3210	move.b 0(a0,d0.W),api_sv * Set sv for next time
3211	*
3212	api_ret: movem.l (a7)+,d0-d1/a0-a1 * Restore registers
3213	rte * Return to interrupted code
3214	*
3215	api_err: move.b d0,api_bug * Catch the bug
3216	clr.b api_sv * Force state zero
3217	bra api_ret * Go back to interrupted code
3218	*
3219	api_sve: move.b d1,api_svb * Catch the bug
3220	clr.b api_sv * Force state zero
3221	bra api_ret * Go back to interrupted code
3222	*
3223	.page
3224	api_s1: btst #0,d0 * See if it takes a value
3225	beq api_s1a * Jump if not
3226	*
3227	move.b #2,api_sv * Set sv for state 2
3228	bra api_ret * Go return from interrupt
3229	*
3230	api_s1a: clr.b api_val * Clear value byte
3231	bra api_pub * Go output to fifo
3232	*
3233	api_s2: ori.b #$80,d0 * Set status = 1
3234	move.b d0,api_val * Set value byte
3235	bra api_pub * Go output to fifo
3236	*
3237	api_s3: ror.b #1,d0 * Set status in value byte
3238	andi.b #$80,d0 * ...
3239	move.b d0,api_val * ...
3240	move.b #4,api_sv * Set sv for state 4
3241	bra api_ret * Go return from interrupt
3242	*
3243	api_s4: or.b d0,api_val * Set value byte
3244	bra api_pub * Go output to fifo
3245	*
3246	api_s5: ror.b #1,d0 * Set status in value byte
3247	andi.b #$80,d0 * ...
3248	*
3249	api_s6: move.b d0,api_val * Set value byte
3250	*
3251	api_pub: movea.l api_fi,a0 * Get fifo input pointer in a0
3252	move.w api_sig,(a0)+ * Store new input
3253	cmpa.l #api_fe,a0 * Wrap around ?
3254	blt api_pb1 * Jump if not
3255	*
3256	movea.l #api_fum,a0 * Wrap input pointer to start
3257	*
3258	api_pb1: move.l a0,api_fi * Update input pointer
3259	cmpa.l api_fo,a0 * Buffer full ?
3260	bne api_pb3 * Jump if not
3261	*
3262	movea.l api_fo,a1 * Get fifo output pointer in a1
3263	adda.l #2,a1 * Increment it
3264	cmpa.l #api_fe,a1 * Wrap around ?
3265	blt api_pb2 * Jump if not
3266	*
3267	movea.l #api_fum,a1 * Wrap output pointer to start
3268	*
3269	api_pb2: move.l a1,api_fo * Set new output pointer
3270	*
3271	api_pb3: clr.b api_sv * Set state to 0
3272	bra api_ret * Return from interrupt
3273	*
3274	.page
3275	*
3276	* api_get -- Get analog input
3277	* ------- ----------------
3278	api_get: move.w sr,-(a7) * Save status register
3279	ori.w #IPL3,sr * Disable ANALOG I/O interrupts
3280	movea.l api_fo,a0 * Get fifo output pointer
3281	cmpa.l api_fi,a0 * See if fifo is empty
3282	bne api_g1 * Jump if not
3283	*
3284	moveq.l #-1,d0 * Set empty-fifo value
3285	move.w (a7)+,sr * Restore interrupt mask
3286	rts * Return to caller
3287	*
3288	api_g1: clr.l d0 * Get fifo value
3289	move.w (a0)+,d0 * ...
3290	cmpa.l #api_fe,a0 * See if pointer wrapped
3291	blt api_g2 * Jump if not
3292	*
3293	movea.l #api_fum,a0 * Wrap the pointer around
3294	*
3295	api_g2: move.l a0,api_fo * Update pointer
3296	move.w (a7)+,sr * Restore interrupt mask
3297	rts * Return to caller
3298	*
3299	* api_zap -- clear analog I/O FIFO
3300	* ------- ---------------------
3301	api_zap: move.w sr,-(a7) * Save status register
3302	ori.w #IPL3,sr * Disable ANALOG I/O interrupts
3303	move.l #api_fum,api_fi * Clear analog processor fifo
3304	move.l #api_fum,api_fo * ...
3305	move.w (a7)+,sr * Restore interrupt mask
3306	rts
3307	*
3308	.endc
3309	*
3310	.page
3311	*************************************************************************
3312	* *
3313	* Constant definitions *
3314	* -------------------- *
3315	*************************************************************************
3316	*
3317	.even
3318	*
3319	.ifne BUCHLA
3320	*
3321	* Buchla 700 tables:
3322	*
3323	* t13tab -- Trap-13 pointer table -- Primary BIOS functions
3324	* ------ -----------------------------------------------
3325	t13tab: dc.w 12 * Number of Trap-13 routines
3326	*
3327	dc.l nullrts * 0 - (getmpb)
3328	dc.l bconstat * 1 - bconstat
3329	dc.l bconin * 2 - bconin
3330	dc.l bconout * 3 - bconout
3331	dc.l rwabs * 4 - rwabs
3332	dc.l setexec * 5 - setexec
3333	dc.l nullrts * 6 - (tickcal)
3334	dc.l getbpb * 7 - getbpb
3335	dc.l bcostat * 8 - bcostat
3336	dc.l mediach * 9 - mediach
3337	dc.l drvmap * 10 - drvmap
3338	dc.l nullrts * 11 - (shift)
3339	*
3340	.page
3341	*
3342	* t14tab -- Trap-14 pointer table -- Extended BIOS functions (Buchla 700 only)
3343	* ------ ------------------------------------------------------------------
3344	t14tab: dc.w 10 * Number of trap14 routines
3345	*
3346	dc.l piorec * 0 - Get iorec address
3347	dc.l setport * 1 - Set ACIA parameters
3348	dc.l floprd * 2 - Read floppy
3349	dc.l flopwr * 3 - Write floppy
3350	dc.l flopfmt * 4 - Format floppy
3351	dc.l flopver * 5 - Verify floppy
3352	dc.l protobt * 6 - Create prototype boot sec.
3353	dc.l rand * 7 - Generate random number
3354	dc.l api_get * 8 - Get analog input
3355	dc.l api_zap * 9 - Clear analog FIFO
3356	*
3357	.endc
3358	*
3359	.even
3360	*
3361	.ifeq BUCHLA
3362	*
3363	* NASA 3D Helmet tables:
3364	*
3365	* t13tab -- Trap-13 pointer table -- Primary BIOS functions
3366	* ------ -----------------------------------------------
3367	t13tab: dc.w 12 * Number of Trap-13 routines
3368	*
3369	dc.l nullrts * 0 - (getmpb)
3370	dc.l bconstat * 1 - bconstat
3371	dc.l bconin * 2 - bconin
3372	dc.l bconout * 3 - bconout
3373	dc.l nullrts * 4 - (rwabs)
3374	dc.l setexec * 5 - setexec
3375	dc.l nullrts * 6 - (tickcal)
3376	dc.l nullrts * 7 - (getbpb)
3377	dc.l bcostat * 8 - bcostat
3378	dc.l nullrts * 9 - (mediach)
3379	dc.l nullrts * 10 - (drvmap)
3380	dc.l nullrts * 11 - (shift)
3381	*
3382	.page
3383	*
3384	* t14tab -- Trap-14 pointer table -- Extended BIOS functions (Buchla 700 only)
3385	* ------ ------------------------------------------------------------------
3386	t14tab: dc.w 10 * Number of trap14 routines
3387	*
3388	dc.l piorec * 0 - Get iorec address
3389	dc.l setport * 1 - Set ACIA parameters
3390	dc.l nullrts * 2 - (Read floppy)
3391	dc.l nullrts * 3 - (Write floppy)
3392	dc.l nullrts * 4 - (Format floppy)
3393	dc.l nullrts * 5 - (Verify floppy)
3394	dc.l nullrts * 6 - (Create prototype boot sec.)
3395	dc.l nullrts * 7 - (Generate random number)
3396	dc.l nullrts * 8 - (Get analog input)
3397	dc.l nullrts * 9 - (Clear analog FIFO)
3398	*
3399	.endc
3400	*
3401	.page
3402	*
3403	* cdt01 -- Character device dispatch table #1 -- input status
3404	* ----- --------------------------------------------------
3405	cdt01: dc.l sr1ist * 0 - PRT -- Printer
3406	dc.l sr2ist * 1 - AUX -- Serial-2
3407	dc.l sr2ist * 2 - CON -- Console
3408	*
3409	.ifne BUCHLA
3410	*
3411	dc.l mc1ist * 3 - MC1 -- MIDI-1
3412	dc.l mc2ist * 4 - MC2 -- MIDI-2
3413	*
3414	.endc
3415	*
3416	* cdt02 -- Character device dispatch table #2 -- input
3417	* ----- -------------------------------------------
3418	cdt02: dc.l sr1inp * 0 - PRT -- Printer
3419	dc.l sr2inp * 1 - AUX -- Serial-2
3420	dc.l sr2inp * 2 - CON -- Console
3421	*
3422	.ifne BUCHLA
3423	*
3424	dc.l mc1inp * 3 - MC1 -- MIDI-1
3425	dc.l mc2inp * 4 - MC2 -- MIDI-2
3426	*
3427	.endc
3428	*
3429	* cdt03 -- Character device dispatch table #3 -- output
3430	* ----- --------------------------------------------
3431	cdt03: dc.l sr1out * 0 - PRT -- Printer
3432	dc.l sr2out * 1 - AUX -- Serial-2
3433	dc.l sr2out * 2 - CON -- Console
3434	.ifne BUCHLA
3435	*
3436	dc.l mc1out * 3 - MC1 -- MIDI-1
3437	dc.l mc2out * 4 - MC2 -- MIDI-2
3438	*
3439	.endc
3440	*
3441	* cdt04 -- Character device dispatch table #4 -- output status
3442	* ----- ---------------------------------------------------
3443	cdt04: dc.l sr1ost * 0 - PRT -- Printer
3444	dc.l sr2ost * 1 - AUX -- Serial-2
3445	dc.l sr2ost * 2 - CON -- Console
3446	.ifne BUCHLA
3447	*
3448	dc.l mc1ost * 3 - MC1 -- MIDI-1
3449	dc.l mc2ost * 4 - MC2 -- MIDI-2
3450	*
3451	.endc
3452	*
3453	.page
3454	*
3455	* iorec defaults:
3456	* ---------------
3457	* Serial-1:
3458	* ---------
3459	sr1dflt: dc.l sr1ibuf
3460	dc.w SR1IBS
3461	dc.w 0,0
3462	dc.w SR1IBS/4
3463	dc.w SR1IBS-(SR1IBS/4)
3464	dc.l sr1obuf
3465	dc.w SR1OBS
3466	dc.w 0,0
3467	dc.w SR1OBS/4
3468	dc.w SR1OBS-(SR1OBS/4)
3469	dc.b SR1CFR0,SR1CFR1
3470	dc.b 0,0
3471	dc.b SR1DISC,0
3472	dc.b 0,0
3473	dc.w 0,0
3474	*
3475	* Serial-2:
3476	* ---------
3477	sr2dflt: dc.l sr2ibuf
3478	dc.w SR2IBS
3479	dc.w 0,0
3480	dc.w SR2IBS/4
3481	dc.w SR2IBS-(SR2IBS/4)
3482	dc.l sr2obuf
3483	dc.w SR2OBS
3484	dc.w 0,0
3485	dc.w SR2OBS/4
3486	dc.w SR2OBS-(SR2OBS/4)
3487	dc.b SR2CFR0,SR2CFR1
3488	dc.b 0,0
3489	dc.b SR2DISC,0
3490	dc.b 0,0
3491	dc.w 0,0
3492	*
3493	.page
3494	*
3495	.ifne BUCHLA
3496	*
3497	* MIDI-1:
3498	* -------
3499	mc1dflt: dc.l mc1ibuf
3500	dc.w MC1IBS
3501	dc.w 0,0
3502	dc.w MC1IBS/4
3503	dc.w MC1IBS-(MC1IBS/4)
3504	dc.l mc1obuf
3505	dc.w MC1OBS
3506	dc.w 0,0
3507	dc.w MC1OBS/4
3508	dc.w MC1OBS-(MC1OBS/4)
3509	dc.b MC1CFR0,MC1CFR1
3510	dc.b 0,0
3511	dc.b MC1DISC,0
3512	dc.b 0,0
3513	dc.w 0,0
3514	*
3515	* MIDI-2:
3516	* -------
3517	mc2dflt: dc.l mc2ibuf
3518	dc.w MC2IBS
3519	dc.w 0,0
3520	dc.w MC2IBS/4
3521	dc.w MC2IBS-(MC2IBS/4)
3522	dc.l mc2obuf
3523	dc.w MC2OBS
3524	dc.w 0,0
3525	dc.w MC2OBS/4
3526	dc.w MC2OBS-(MC2OBS/4)
3527	dc.b MC2CFR0,MC2CFR1
3528	dc.b 0,0
3529	dc.b MC2DISC,0
3530	dc.b 0,0
3531	dc.w 0,0
3532	*
3533	.endc
3534	*
3535	.page
3536	*
3537	* brtable -- Baud rate setup table
3538	* ------- ---------------------
3539	brtable: dc.b BR_19K2 * 0 - 19200 baud
3540	dc.b BR_9600 * 1 - 9600 baud
3541	dc.b BR_4800 * 2 - 4800 baud
3542	dc.b BR_3600 * 3 - 3600 baud
3543	dc.b BR_2400 * 4 - 2400 baud
3544	dc.b BR_7200 * 5 - 7200 baud (2000 on Atari)
3545	dc.b BR_1800 * 6 - 1800 baud
3546	dc.b BR_1200 * 7 - 1200 baud
3547	dc.b BR_600 * 8 - 600 baud
3548	dc.b BR_300 * 9 - 300 baud
3549	*
3550	* iortab -- iorec pointer table
3551	* ------ -------------------
3552	iortab: dc.l sr1iorec * 0 - PRT Serial-1 Printer
3553	dc.l sr2iorec * 1 - AUX Serial-2 Host
3554	dc.l sr2iorec * 2 - CON Serial-2 Console
3555	*
3556	.ifne BUCHLA
3557	*
3558	dc.l mc1iorec * 3 - MC1 MIDI-1 MIDI port #1
3559	dc.l mc2iorec * 4 - MC2 MIDI-2 MIDI port #2
3560	*
3561	.endc
3562	*
3563	* aciatab -- iorec and ACIA pointer table
3564	* ------- ----------------------------
3565	aciatab: dc.l sr1iorec,SR1ACIA * 0 - PRT Serial-1
3566	dc.l sr2iorec,SR2ACIA * 1 - AUX Serial-2
3567	dc.l sr2iorec,SR2ACIA * 2 - CON Serial-2
3568	*
3569	.ifne BUCHLA
3570	*
3571	dc.l mc1iorec,MC1ACIA * 3 - MC1 MIDI-1
3572	dc.l mc2iorec,MC2ACIA * 4 - MC2 MIDI-2
3573	*
3574	.endc
3575	*
3576	.page
3577	*
3578	.ifne BUCHLA
3579	*
3580	* pbpbtab -- Prototype BPB data table (BPS..NHID) 19 bytes per entry
3581	* ------- ---------------------------------------------------------
3582	*
3583	* 0 -- 40 tracks, single sided (180K)
3584	*
3585	pbpbtab: dc.b $00,$02,$01,$01,$00,$02,$40,$00
3586	dc.b $68,$01,$FC,$02,$00,$09,$00,$01
3587	dc.b $00,$00,$00
3588	*
3589	* 1 -- 40 tracks, double sided (360K)
3590	*
3591	dc.b $00,$02,$02,$01,$00,$02,$70,$00
3592	dc.b $D0,$02,$FD,$02,$00,$09,$00,$02
3593	dc.b $00,$00,$00
3594	*
3595	* 2 -- 80 tracks, single sided (360K)
3596	*
3597	dc.b $00,$02,$02,$01,$00,$02,$70,$00
3598	dc.b $D0,$02,$F8,$05,$00,$09,$00,$01
3599	dc.b $00,$00,$00
3600	*
3601	* 3 -- 80 tracks, double sided (720K)
3602	*
3603	dc.b $00,$02,$02,$01,$00,$02,$70,$00
3604	dc.b $A0,$05,$F9,$05,$00,$09,$00,$02
3605	dc.b $00,$00,$00
3606	*
3607	* VSDD initialization table
3608	*
3609	.even
3610	*
3611	vsddtab: dc.w $8252 * R0 Mode word 0
3612	dc.w $E474 * R1 Mode word 1
3613	dc.w $0006 * R2 Register window base
3614	dc.w $0100 * R3 Data window base
3615	dc.w $0000 * R4 Data length mask
3616	dc.w $0000 * R5 Data segment base
3617	dc.w $0001 * R6 Priority access count
3618	dc.w $0040 * R7 ODT base
3619	dc.w $0080 * R8 AT base
3620	dc.w $0010 * R9 CLT base
3621	dc.w $0011 * R10 CG bases
3622	dc.w $0000 * R11 AT counter (R/O)
3623	*
3624	dc.w $0C08 * R12 HC0 = 3, VC0 = 8
3625	dc.w $140A * R13 HC1 = 5, VC1 = 10
3626	dc.w $9568 * R14 HC2 = 37, VC2 = 360
3627	dc.w $A16A * R15 HC3 = 40, VC3 = 362
3628	*
3629	vsddit01: dc.w $8253 * R0 with UCF = 1, DEN = 0
3630	vsddit02: dc.w $825B * R0 with UCF = 1, DEN = 1
3631	*
3632	.page
3633	*
3634	* analog processor input state table
3635	*
3636	api_tab: dc.b 0,1,1,1,1,1,1,1,1,1 * 0..9
3637	dc.b 1,1,1,1,1,1,1,1,1,1 * 10..19
3638	dc.b 1,1,1,1,1 * 20..24
3639	dc.b 3,3,3,3,3 * 25..29
3640	dc.b 3,3,3,3,3,3,3,3,3 * 30..38
3641	dc.b 5 * 39
3642	dc.b 5,5,5,5,5,5,5,5,5,5 * 40..49
3643	dc.b 5,5,5 * 50..52
3644	dc.b 3,3,3,3,3,3,3 * 53..59
3645	dc.b 5,5,5,5,5,5,5,5,5,5 * 60..69
3646	dc.b 5,5,5 * 70..72
3647	dc.b 6,6,6,6,6,6,6 * 73..79
3648	dc.b 6,6,6 * 80..82
3649	*
3650	.even
3651	*
3652	* analog processor state transfer vector
3653	*
3654	api_tv: dc.l api_s0,api_s1,api_s2,api_s3
3655	dc.l api_s4,api_s5,api_s6
3656	*
3657	.endc
3658	*
3659	.page
3660	*************************************************************************
3661	* *
3662	* RAM storage definitions *
3663	* ----------------------- *
3664	*************************************************************************
3665	*
3666	.bss
3667	.even
3668	*
3669	* RAM data area
3670	* -------------
3671	* WARNING:
3672	* --------
3673	* The variables from timevec through rsarea are permanently assigned so
3674	* that we can link to certain bios variables without having to link to the
3675	* bios object file itself. Some of these get defined in hwdefs.s and in
3676	* hwdefs.s so beware of changing them.
3677	*
3678	timevec: ds.l 1 * System timer trap vector
3679	critvec: ds.l 1 * Critical error handler vector
3680	termvec: ds.l 1 * Process terminate hook vector
3681	resvec3: ds.l 1 * Reserved vector 3
3682	resvec4: ds.l 1 * Reserved vector 4
3683	resvec5: ds.l 1 * Reserved vector 5
3684	resvec6: ds.l 1 * Reserved vector 6
3685	resvec7: ds.l 1 * Reserved vector 7
3686	*
3687	fc_sw: ds.w 1 * Frame clock switch (<0=dn, 0=off, >0=up)
3688	fc_val: ds.l 1 * Frame clock value (0..FCMAX)
3689	*
3690	_wzcrsh: ds.w 1 * Crash area: flag for ROMP
3691	_crshsr: ds.w 1 * Crash area: SR
3692	_crshpc: ds.l 1 * Crash area: PC
3693	_crshsp: ds.l 1 * Crash area: SP
3694	_crshus: ds.l 1 * Crash area: USP
3695	_crshvc: ds.l 1 * Crash area: vector # in MS byte
3696	_crshrg: ds.l 16 * Crash area: registers
3697	_crshst: ds.w 16 * Crash area: top 16 words of stack
3698	*
3699	* The area from biosram to SSTACK-1 is cleared on reset.
3700	* ------------------------------------------------------
3701	biosram .equ * * Start of BIOS RAM variables
3702	*
3703	.ifne BUCHLA
3704	*
3705	_hz_1k: ds.l 1 * 1000 Hz clock
3706	_hz_200: ds.l 1 * 200 Hz clock
3707	frclock: ds.l 1 * 50 Hz clock
3708	t1count: ds.w 1 * Timer 1 count
3709	t2count: ds.w 1 * Timer 2 count
3710	t3count: ds.w 1 * Timer 3 count
3711	*
3712	seekrate: ds.w 1 * Seek rate
3713	cdev: ds.w 1 * Current drive
3714	ctrack: ds.w 1 * Current track
3715	csect: ds.w 1 * Current sector
3716	cside: ds.w 1 * Current side
3717	ccount: ds.w 1 * Current sector count
3718	spt: ds.w 1 * Sectors per track
3719	interlv: ds.w 1 * Sector interleave count
3720	virgin: ds.w 1 * Initial formatting data
3721	deferr: ds.w 1 * Default error number
3722	curerr: ds.w 1 * Current error number
3723	*
3724	cdma: ds.l 1 * Current DMA address
3725	edma: ds.l 1 * Ending DMA address
3726	tmpdma: ds.l 1 * Temporary DMA address
3727	*
3728	.endc
3729	*
3730	rseed: ds.l 1 * Random number seed
3731	*
3732	savptr: ds.l 1 * Pointer to register save area
3733	*
3734	_rsflag: ds.l 1 * Register save area overflow flag
3735	ds.l 1832 Register save area (32 levels)
3736	rsarea: ds.l 1 * Dummy long word at top of save area
3737	*
3738	* *** end of the permanently assigned bios variables ***
3739	*
3740	.page
3741	*
3742	.ifne BUCHLA
3743	*
3744	acctim: ds.l 2 * Accumulated disk time table
3745	maxactim: ds.l 1 * Maximum acctim value
3746	hdv_init: ds.l 1 * Disk init vector
3747	hdv_bpb: ds.l 1 * Disk get bpb vector
3748	hdv_rw: ds.l 1 * Disk r/w vector
3749	hdv_boot: ds.l 1 * Disk boot vector
3750	hdv_mchg: ds.l 1 * Disk media change vector
3751	drvbits: ds.l 1 * Drive map bits
3752	dskbufp: ds.l 1 * Disk buffer pointer
3753	.page
3754	nflops: ds.w 1 * Number of drives
3755	disknum: ds.w 1 * Current disk number
3756	booted: ds.w 1 * Most recent boot device or -1
3757	flock: ds.w 1 * Floppy semaphore
3758	fverify: ds.w 1 * Floppy verify flag
3759	*
3760	tdiv1: ds.w 1 * Timer divider 1 (divides _hz_1k)
3761	tdiv2: ds.w 1 * Timer divider 2 (divides _hz_200)
3762	*
3763	retrycnt: ds.w 1 * Re-try count
3764	wpstatus: ds.w 1 * Write protect status table
3765	wplatch: ds.w 1 * Write protect latch table
3766	bootdev: ds.w 1 * Boot device number
3767	*
3768	motoron: ds.w 1 * Motor-on flag
3769	deslflag: ds.w 1 * Drive deselect flag
3770	*
3771	.endc
3772	*
3773	flpsrsv: ds.w 1 * Status register save area
3774	flpregs: ds.l 16 * Register save area
3775	*
3776	.ifne BUCHLA
3777	*
3778	dsb0: ds.l 1 * Drive A DSB
3779	dsb1: ds.l 1 * Drive B DSB
3780	*
3781	dskmode: ds.b 2 * Disk change mode table
3782	dskerrs: ds.w 2 * Disk error code table
3783	drvbpbs: ds.w 162 Disk BPB save area
3784	*
3785	.endc
3786	*
3787	.page
3788	*
3789	sr1iorec: ds.b IORECLN * Serial-1 iorec structure
3790	sr2iorec: ds.b IORECLN * Serial-2 iorec structure
3791	*
3792	.ifne BUCHLA
3793	*
3794	mc1iorec: ds.b IORECLN * MIDI-1 iorec structure
3795	mc2iorec: ds.b IORECLN * MIDI-2 iorec structure
3796	*
3797	.endc
3798	*
3799	sr1ibuf: ds.b SR1IBS * Serial-1 input buffer
3800	sr1obuf: ds.b SR1OBS * Serial-1 output buffer
3801	sr2ibuf: ds.b SR2IBS * Serial-2 input buffer
3802	sr2obuf: ds.b SR2OBS * Serial-2 output buffer
3803	*
3804	.ifne BUCHLA
3805	*
3806	mc1ibuf: ds.b MC1IBS * MIDI-1 input buffer
3807	mc1obuf: ds.b MC1OBS * MIDI-1 output buffer
3808	mc2ibuf: ds.b MC2IBS * MIDI-2 input buffer
3809	mc2obuf: ds.b MC2OBS * MIDI-2 output buffer
3810	*
3811	api_inp: ds.b 1 * Analog processor input byte
3812	api_bug: ds.b 1 * Analog processor signal # "bug trap"
3813	api_sv: ds.b 1 * Analog processor state
3814	api_svb: ds.b 1 * Analog processor state "bug trap"
3815	*
3816	.even
3817	*
3818	api_sig: ds.b 1 * Analog signal number
3819	api_val: ds.b 1 * Analog value
3820	*
3821	api_fi: ds.l 1 * Analog processor FIFO input pointer
3822	api_fo: ds.l 1 * Analog processor FIFO output pointer
3823	api_fum: ds.w APISIZE * Analog processor FIFO
3824	api_fe .equ * * End of analog processor FIFO
3825	*
3826	.endc
3827	*
3828	.even
3829	*
3830	basepage: ds.l 64 * Pseudo base page
3831	*
3832	buffer: ds.b 1024 * Default disk buffer
3833	*
3834	biostop .equ * * End of BIOS RAM
3835	*
3836	.end

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format