|
1187
|
1 ********************************************************************
|
|
|
2 * Boot - Burke & Burke Boot Module
|
|
|
3 *
|
|
|
4 * $Id$
|
|
|
5 *
|
|
|
6 * Burke & Burke boot module... needs to be patched for OS9Boots that are
|
|
|
7 * far into the device.
|
|
|
8 * Track is the literal cylinder #, Cylinder would be including all heads
|
|
|
9 * of that track
|
|
|
10 *
|
|
|
11 * Ed. Comments Who YY/MM/DD
|
|
|
12 * ------------------------------------------------------------------
|
|
|
13
|
|
|
14 nam Boot
|
|
|
15 ttl Burke & Burke Boot Module
|
|
|
16
|
|
|
17 org 0
|
|
|
18 buffptr rmb 2 Pointer to sector buffer in memory
|
|
|
19 numcyl rmb 2 Number of tracks for drive geometry init
|
|
|
20 sechead rmb 2 # of logical sectors/physical sector
|
|
|
21 numhead rmb 1 # of heads (sides)
|
|
|
22 seccyl rmb 2 # of sectors/cylinder (# of heads*sectors per head)
|
|
|
23 track rmb 2 Cylinder number last calculated ($9 - $A)
|
|
|
24 head rmb 1 Drive/head number (drive always 0)
|
|
|
25 sector rmb 1 Sector number (0-63)
|
|
|
26 vars equ 13-buffptr Size of stack variables buffer
|
|
|
27
|
|
|
28
|
|
|
29 ifp1
|
|
|
30 use defsfile
|
|
|
31 use rbfdefs
|
|
|
32 endc
|
|
|
33
|
|
|
34 tylg set Systm+Objct
|
|
|
35 atrv set ReEnt+rev
|
|
|
36 rev set $02
|
|
|
37 edition set 2
|
|
|
38
|
|
|
39 mod eom,name,tylg,atrv,start,size
|
|
|
40
|
|
|
41 u0000 rmb 0
|
|
|
42 size equ .
|
|
|
43
|
|
|
44 name fcs /Boot/
|
|
|
45 fcb edition
|
|
|
46
|
|
|
47 start ldb >MPI.Slct Set up Multipak properly for us
|
|
|
48 lda #$10
|
|
|
49 mul
|
|
|
50 ldb #$11
|
|
|
51 mul
|
|
|
52 stb >MPI.Slct
|
|
|
53 leas -vars,s Reserve work area on stack of 13 bytes
|
|
|
54 tfr s,u U points to beginning of 13 byte buffer
|
|
|
55 pshs u,y,x,b,a Preserve registers
|
|
|
56 ldd #$0200 512 bytes for each read from XT-GEN
|
|
|
57 std numcyl,u # of cyls on drive
|
|
|
58 sta sechead+1,u # of sectors/head
|
|
|
59 sta numhead,u # of heads on drive
|
|
|
60 os9 F$SRqMem Request 512 byte buffer from OS9P1
|
|
|
61 lbcs L00B6 Error
|
|
|
62 tfr u,d d=Starting address of 512 byte block
|
|
|
63 ldu $06,s Get back pointer to 13 byte buffer
|
|
|
64 std buffptr,u Preserve buffer pointer
|
|
|
65
|
|
|
66 clr >$FF51 Reset controller
|
|
|
67
|
|
|
68 clr >$FF53 Set controller mode to 0 (part of init)
|
|
|
69 lbsr drvtype Set drive geometry (type of drive)
|
|
|
70 clrb Set initial LSN to 0
|
|
|
71 ldx #$0000
|
|
|
72 lbsr GetSect Figure out track/head/sector for LSN0
|
|
|
73 bcs L00B6 Error occured in read
|
|
|
74 ldy buffptr,u Get buffer pointer
|
|
|
75 ldd DD.NAM+PD.CYL,y Get real # cylinders on drive
|
|
|
76 std numcyl,u Preserve
|
|
|
77 ldd DD.NAM+PD.SCT,y Get real # sectors/track
|
|
|
78 std sechead,u Preserve
|
|
|
79 lda DD.NAM+PD.SID,y Get real # heads
|
|
|
80 sta numhead,u Preserve
|
|
|
81 leay DD.BT,y Point to OS9Boot information
|
|
|
82 ldd DD.BSZ-DD.BT,y Get size of OS9Boot
|
|
|
83 std ,s Preserve on stack
|
|
|
84 ldb DD.BT-DD.BT,y Get MSB of starting LSN of OS9Boot
|
|
|
85 ldx DD.BT-DD.BT+1,y Get LSW of starting LSN of OS9Boot
|
|
|
86 pshs x,b Push on stack
|
|
|
87 lbsr drvtype Set up drive for real drive specs
|
|
|
88 ldd #$0200 Get size of our buffer
|
|
|
89 ldu buffptr,u Get pointer to our 512 byte buffer
|
|
|
90 os9 F$SRtMem Deallocate our old sector buffer
|
|
|
91 ldd $03,s Get back size of OS9Boot
|
|
|
92 inca Increase size by 1 block (256 bytes)
|
|
|
93 IFEQ Level-1
|
|
|
94 os9 F$SRqMem
|
|
|
95 ELSE
|
|
|
96 os9 F$BtMem Allocate memory for boot file
|
|
|
97 ENDC
|
|
|
98 bcs L00B0 Error
|
|
|
99 stu $05,s Preserve pointer to start of OS9boot memory
|
|
|
100 ldu $09,s Get back pointer to local variables
|
|
|
101 ldd $05,s Get pointer to start of OS9Boot memory
|
|
|
102 std buffptr,u Move disk buffer pointer to there
|
|
|
103 ldd $03,s Get size of bootfile
|
|
|
104 beq L00A9 If zero, do someting
|
|
|
105 pshs b,a Otherwise push on stack
|
|
|
106 ReadBt std ,s Store # bytes left in boot on stack
|
|
|
107 ldb $02,s Get MSB of start sector of boot
|
|
|
108 ldx $03,s Get LSW of start sector of boot
|
|
|
109 bsr GetSect Convert to track/head/sector
|
|
|
110 bcs L00B4 If an error in getting, do something
|
|
|
111 inc buffptr,u Bump up buffer pointer by a page
|
|
|
112 ldx $03,s Bump up LSW of sector number
|
|
|
113 leax $01,x
|
|
|
114 stx $03,s And put it back
|
|
|
115 bne L00A0 If no carry over needed, proceed
|
|
|
116 inc $02,s Bump up MSB of sector number
|
|
|
117 L00A0 ldd ,s Get current boot size left to do
|
|
|
118 subd #$0100 Subtract 256 from it
|
|
|
119 bhi ReadBt If not zero yet, keep reading
|
|
|
120 leas $02,s Eat our temporary size left
|
|
|
121 L00A9 leas $03,s Eat our current LSN to get
|
|
|
122 clrb Clear carry (No error)
|
|
|
123 puls b,a pull off multipak settings (?)
|
|
|
124 bra BtExit
|
|
|
125 L00B0 leas $03,s Purge stack
|
|
|
126 bra L00B6
|
|
|
127 L00B4 leas $05,s Purge stack
|
|
|
128
|
|
|
129 L00B6 leas $02,s Purge stack
|
|
|
130
|
|
|
131 BtExit pshs a
|
|
|
132 lda #$FF
|
|
|
133 sta >$FF51 Reset controller
|
|
|
134 sta >MPI.Slct Reset multipak
|
|
|
135 sta >$FFD9 Double speed on
|
|
|
136 puls u,y,x,a Get exit parameters for Boot
|
|
|
137 leas vars,s Reset stack
|
|
|
138 rts Exit from Boot
|
|
|
139
|
|
|
140 * Get 512 byte sector from controller
|
|
|
141 * Entry X:B = 24 bit Logical sector number to get
|
|
|
142
|
|
|
143 GetSect pshs x,b Preserve registers
|
|
|
144 ldx #$FFFF (Init X so it will be 0 in loop)
|
|
|
145
|
|
|
146 * 24 bit divide routine. Stack=LSN (3 bytes)
|
|
|
147 * Entry: u=pointer to our local variable list
|
|
|
148
|
|
|
149 cyldiv leax $01,x # of loops through subtract
|
|
|
150 ldd $01,s Get original x (0)
|
|
|
151 subd seccyl,u Subtract # sector/cylinder
|
|
|
152 std $01,s Preserve it back
|
|
|
153 ldb ,s Continue subtract with borrow for 24 bit
|
|
|
154 sbcb #$00
|
|
|
155 stb ,s
|
|
|
156 bcc cyldiv If not trying to borrow again, continue
|
|
|
157 stx track,u Got track #
|
|
|
158 ldd $01,s Reset value to last in loop
|
|
|
159 addd seccyl,u
|
|
|
160 clr head,u Set head # to 0?
|
|
|
161 hddiv inc head,u Increase head #?
|
|
|
162 subd sechead,u Subtract # sectors/head?
|
|
|
163 bcc hddiv Continue subtracting until it wraps
|
|
|
164 dec head,u Adjust head to not include wrap
|
|
|
165 addd sechead,u Adjust leftover to not include wrap
|
|
|
166 lsrb Divide b by 2 (256 byte sector to 512)
|
|
|
167 stb sector,u Preserve sector #
|
|
|
168 leas $03,s Clear stack of 24 bit number
|
|
|
169
|
|
|
170 pshs cc Preserve odd sector flag (carry bit)
|
|
|
171
|
|
|
172 bsr cmdstrt Set up controller for new command
|
|
|
173 lda #$08 Read sector command
|
|
|
174 ldb head,u Drive/head byte (Drive always 0)
|
|
|
175 bsr dblsend Send to controller
|
|
|
176 ldd track,u Get msb of track
|
|
|
177 lsra Move right 2 bits into left two for the
|
|
|
178 rora controller
|
|
|
179 rora
|
|
|
180 ora sector,u mask in the sector number into remaining 6 bits
|
|
|
181 * ldb track+1,u Get LSB of track
|
|
|
182 bsr dblsend Send to controller
|
|
|
183 ldd #$0100 1 sector to read/no error correction/3 ms step
|
|
|
184 bsr dblsend Send that to controller
|
|
|
185 ldx buffptr,u Get pointer to sector buffer
|
|
|
186 * new code is here
|
|
|
187 puls cc Get back odd sector 1/2 indicator
|
|
|
188 bcc normal Even sector, use 1st half
|
|
|
189 bsr Eat256 Odd sector, use 2nd half
|
|
|
190 bsr Read256 Read 256 bytes off of controller
|
|
|
191 lbra chkcmplt See if command is complete
|
|
|
192 normal bsr Read256 Read 1/2 of sector
|
|
|
193 bsr Eat256 Eat half of sector
|
|
|
194 lbra chkcmplt See if command is complete
|
|
|
195
|
|
|
196 Eat256 clrb Eat 256 bytes off of controller
|
|
|
197 Eatlp lbsr nxtready Get byte from controller
|
|
|
198 decb counter
|
|
|
199 bne Eatlp Keep eating until 256 bytes done
|
|
|
200 clrb
|
|
|
201 rts
|
|
|
202
|
|
|
203 * Read 256 bytes from controller
|
|
|
204 * Entry: X=Pointer to current position in 512 physical sector buffer
|
|
|
205
|
|
|
206 Read256 clrb Set counter for 256 byte read
|
|
|
207 ReadLp lbsr nxtready Go get a byte from controller
|
|
|
208 sta ,x+ Put in buffer
|
|
|
209 decb keep doing until all 256 are read
|
|
|
210 bne ReadLp
|
|
|
211
|
|
|
212 middle clrb Clear carry for no error & return
|
|
|
213 rts
|
|
|
214
|
|
|
215 * Send 2 bytes to the controller
|
|
|
216 * Entry: a=1st byte to send
|
|
|
217 * b=2nd byte to send
|
|
|
218
|
|
|
219 dblsend pshs b,a Preserve d for a moment
|
|
|
220 bsr sendbyte Go send what is in a to controller
|
|
|
221 tfr b,a Send what was in b to the controller
|
|
|
222 bsr sendbyte
|
|
|
223 puls pc,b,a Return with a and b intact
|
|
|
224
|
|
|
225 * Sends a byte to the controller when it is ready for it
|
|
|
226 * Entry: a=byte to send
|
|
|
227
|
|
|
228 sendbyte pshs a Preserve a for a moment
|
|
|
229 waitsend bsr stable Make sure status register is stable and get it
|
|
|
230 anda #%00001011 Mask out bits
|
|
|
231 cmpa #$09 Is it expecting next byte of data packet?
|
|
|
232 bne waitsend
|
|
|
233 puls a Yes, get the byte we are sending next
|
|
|
234 sta >$FF50 Store in data register
|
|
|
235 rts
|
|
|
236
|
|
|
237 * Sends out command packet (6 bytes). Hard coded for drive 0, head 0,
|
|
|
238 * track 0, sector 0, interleave 0, no error correction, 3 ms step rate
|
|
|
239
|
|
|
240 cmdpckt pshs a Preserve command for a moment
|
|
|
241 bsr cmdstrt Go initialize controller for command start
|
|
|
242 puls a Get back command byte
|
|
|
243 clrb 1st option byte to 0
|
|
|
244 bsr dblsend Send both to controller
|
|
|
245 clra
|
|
|
246 bsr dblsend Send 4 more 0's to controller
|
|
|
247 bsr dblsend (sent command byte and 5 zero bytes for command
|
|
|
248 rts packet)
|
|
|
249
|
|
|
250 cmdstrt bsr stable
|
|
|
251 anda #%00001001 Mask out all but bits 0 and 3
|
|
|
252 bne cmdstrt If controller command is not complete or expecting
|
|
|
253 clr >$FF52 data, keep reading status register until it is ready
|
|
|
254 rts Otherwise initialize command start
|
|
|
255
|
|
|
256 * Make sure controller's status register is stable
|
|
|
257
|
|
|
258 stable lda >$FF51 Get status from controller
|
|
|
259 cmpa >$FF51 Keep getting until it stabilizes
|
|
|
260 bne stable
|
|
|
261 rts
|
|
|
262
|
|
|
263 * Set the drive type (set to 512 track - may be the error)
|
|
|
264 * Using the initialize drive geometry command
|
|
|
265 * Exit: Carry set if non-recoverable error
|
|
|
266
|
|
|
267 drvtype lda #$0C Initialize drive geometry command
|
|
|
268 bsr cmdpckt Go init
|
|
|
269 ldd numcyl,u Get # of cylinders on media
|
|
|
270 bsr dblsend Send it out (indicates drive has 512 tracks)
|
|
|
271 ldb sechead+1,u Get # of sectors/head
|
|
|
272 lda numhead,u Get # of heads on media
|
|
|
273 lsrb Divide OS9 sectors by 2
|
|
|
274 bsr sendbyte Send out # of heads for drive geometry
|
|
|
275 lslb Multiply WD sectors by 2 to get OS9 sectors again.
|
|
|
276 mul
|
|
|
277 std seccyl,u # sectors per cylinder (all heads on a track)
|
|
|
278 ldd numcyl,u Get # of tracks back
|
|
|
279 subd #$0001 Reduce write track=last track-1
|
|
|
280 bsr dblsend Send out reduced write track #
|
|
|
281 bsr dblsend Also use as write precomp track #
|
|
|
282 lda #$04 Maximum ECC burst length correctable=4
|
|
|
283 bsr sendbyte Send it out
|
|
|
284
|
|
|
285 * Make sure command has completed
|
|
|
286 * Exit: Carry set if controller reported a non-recoverable error
|
|
|
287 * Carry clear if everything went fine
|
|
|
288
|
|
|
289 chkcmplt bsr stable When status register is stable get it
|
|
|
290 anda #%00000111 Keep checking until controller indicates that
|
|
|
291 cmpa #%00000111 command completion code is ready to be read
|
|
|
292 bne chkcmplt
|
|
|
293 lda >$FF50 Get command completion code
|
|
|
294 bita #%00000010 Was there in error in completing the command?
|
|
|
295 beq noerror Nope, everything fine setting drive geometry
|
|
|
296 lda #$03 Error, Request Sense Status from the drive
|
|
|
297 bsr cmdpckt send Request Sense Status code
|
|
|
298 bsr nxtready Go get response from controller
|
|
|
299 anda #%00111111 Mask out all but error type and error code
|
|
|
300 pshs a Preserve it for a second
|
|
|
301 bsr eat2 Go eat next 4 bytes from controller (remaining 3
|
|
|
302 bsr eat2 from Sense Status & command completion code)
|
|
|
303 puls a Get back original error byte
|
|
|
304 tsta No error occured?
|
|
|
305 beq noerror No error; exit without error
|
|
|
306 cmpa #%00011000 Type 1, error 8 (correctable data error)?
|
|
|
307 beq noerror Yes, return without error
|
|
|
308 comb Set carry to indicate error
|
|
|
309 rts return
|
|
|
310 noerror clrb
|
|
|
311 rts
|
|
|
312
|
|
|
313 * Reads two byte from controller without caring what they are
|
|
|
314
|
|
|
315 eat2 bsr nxtready
|
|
|
316
|
|
|
317 * Waits until next byte coming from controller is ready, then gets it
|
|
|
318 * Exit: a=byte from controller
|
|
|
319
|
|
|
320 nxtready bsr stable Make sure status register is stable and get it
|
|
|
321 anda #%00001011 Controller ready to send me next byte?
|
|
|
322 cmpa #%00001011
|
|
|
323 bne nxtready Nope, keep waiting
|
|
|
324 lda >$FF50 Yes, get byte and return
|
|
|
325 rts Padding to get $1D0 Size
|
|
|
326 * Pad to $1d0 bytes exactly
|
|
|
327 Pad fill $39,$1D0-3-*
|
|
|
328
|
|
|
329 emod
|
|
|
330 eom equ *
|
|
|
331 end
|
