1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
|
;
; Copyright 2005 Sun Microsystems, Inc. All rights reserved.
; Use is subject to license terms.
;
; CDDL HEADER START
;
; The contents of this file are subject to the terms of the
; Common Development and Distribution License, Version 1.0 only
; (the "License"). You may not use this file except in compliance
; with the License.
;
; You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
; or http://www.opensolaris.org/os/licensing.
; See the License for the specific language governing permissions
; and limitations under the License.
;
; When distributing Covered Code, include this CDDL HEADER in each
; file and include the License file at usr/src/OPENSOLARIS.LICENSE.
; If applicable, add the following below this CDDL HEADER, with the
; fields enclosed by brackets "[]" replaced with your own identifying
; information: Portions Copyright [yyyy] [name of copyright owner]
;
; CDDL HEADER END
;
; Multi-threaded general purpose script for the
; Symbios 53C825/875 host bus adapter chips.
;
; ident "%Z%%M% %I% %E% SMI"
ARCH 825A
ABSOLUTE NBIT_ICON = 0x10 ; CON bit in SCNTL1 register
;
; Scatter/Gather DMA instructions for datain and dataout
;
ENTRY dt_do_list_end
ENTRY dt_di_list_end
ENTRY do_list_end
ENTRY di_list_end
; SCSI I/O entry points. One of these addresses must be loaded into the
; DSA register to initiate SCSI I/O.
ENTRY start_up
ENTRY resel_m
ENTRY ext_msg_out
ENTRY clear_ack
ENTRY continue
ENTRY errmsg
ENTRY abort
ENTRY dev_reset
ENTRY ext_msg_in
ENTRY phase_mis_match
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
start_up:
SELECT ATN FROM 0, REL(resel_m)
; after selection, next phase should be msg_out or status
INT PASS(NINT_ILI_PHASE), WHEN NOT MSG_OUT
msgout:
MOVE FROM PASS(NTOFFSET(nt_sendmsg)), WHEN MSG_OUT
JUMP REL(command_phase), WHEN CMD
JUMP REL(switch), WHEN NOT MSG_OUT
; target requested repeat, set atn in case it's an extended msg
SET ATN
JUMP REL(msgout)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; The sync (SDTR) message interrupt handler restarts here if the
; initiator and target have both succesfully exchanged SDTR messages.
clear_ack:
CLEAR ACK
JUMP REL(switch)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Restart here after phase mismatch interrupt, clear ATN in case the
; interrupt occurred during the msg_out phase.
continue:
CLEAR ATN
JUMP REL(switch)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Send error message to the target. Usually the target will change
; phase immediately. But if in data in or data out phase, or part
; way through a command or message in the phase change will happen
; at the end of the current phase.
errmsg:
SET ATN
CLEAR ACK
JUMP REL(errmsg_out), WHEN MSG_OUT
; not message out phase, the target will change phase later
JUMP REL(switch)
errmsg_out:
MOVE FROM PASS(NTOFFSET(nt_errmsg)), WHEN MSG_OUT
JUMP REL(switch) , WHEN NOT MSG_OUT
; target requested repeat
JUMP REL(errmsg_out)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Send an abort message to a target that's attempting an invalid
; reconnection.
abort:
SET ATN
CLEAR ACK
INT PASS(NINT_ILI_PHASE), WHEN NOT MSG_OUT
abort_out:
MOVE FROM PASS(NTOFFSET(nt_errmsg)), WHEN MSG_OUT
JUMP REL(abort_done), WHEN NOT MSG_OUT
SET ATN
JUMP REL(abort_out)
abort_done:
MOVE 0x00 TO SCNTL2
CLEAR ACK
WAIT DISCONNECT
INT PASS(NINT_OK)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; send an Abort or Bus Device Reset message and wait for the disconnect
dev_reset:
MOVE 0x00 TO SCNTL2
SELECT ATN FROM 0, REL(resel_m)
; after selection, next phase should be msg_out
INT PASS(NINT_ILI_PHASE), WHEN NOT MSG_OUT
dev_reset_out:
MOVE FROM PASS(NTOFFSET(nt_sendmsg)), WHEN MSG_OUT
CLEAR ACK
MOVE SCNTL2 & 0x7F TO SCNTL2
WAIT DISCONNECT
INT PASS(NINT_DEV_RESET)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; The sync (SDTR) or wide (WDTR) message interrupt handler restarts here
; if the initiator needs to send an SDTR/WDTR message in response to the
; target's SDTR/WDTR.
;
; Set the ATN signal to let target know we've got a message to send
; and ack the last byte of its SDTR/WDTR message.
ext_msg_out:
SET ATN
CLEAR ACK
JUMP REL(msg_out), WHEN MSG_OUT
; not message out phase, assume target decided not to do sync i/o
; if this doesn't work, change it to treat this as illegal phase
CLEAR ATN
INT PASS(NINT_NEG_REJECT)
msg_out:
MOVE FROM PASS(NTOFFSET(nt_sendmsg)), WHEN MSG_OUT
JUMP REL(ext_msg_out_chk), WHEN NOT MSG_OUT
SET ATN ; target requested repeat
JUMP REL(msg_out)
ext_msg_out_chk:
; test whether the target accepted the SDTR message
; any phase besides MSG_IN means the sdtr message is okay
JUMP REL(switch), WHEN NOT MSG_IN
; any message besides Message Reject means the SDTR message is okay
MOVE FROM PASS(NTOFFSET(nt_rcvmsg)), WHEN MSG_IN
JUMP REL(msgin2), IF NOT 0x07 ; anything else is okay
; SDTR got Message Reject response
MOVE 0x00 TO SXFER
INT PASS(NINT_NEG_REJECT)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
resel_m:
WAIT RESELECT REL(alt_sig_p)
MOVE SSID SHL SFBR
MOVE SFBR SHL SFBR
MOVE SFBR & 0x3C TO DSA0
MOVE SCRATCHB1 TO SFBR
MOVE SFBR TO DSA1
MOVE SCRATCHB2 TO SFBR
MOVE SFBR TO DSA2
MOVE SCRATCHB3 TO SFBR
MOVE SFBR TO DSA3
SELECT FROM 0x00, REL(Next_Inst)
Next_Inst:
MOVE 0x00 TO DSA0
INT PASS(NINT_MSGIN), WHEN NOT MSG_IN
;
; reselection Identify msg.
;
MOVE FROM PASS(HBAOFFSET(g_rcvmsg)), WHEN MSG_IN
CLEAR ACK
;
; Target will either continue in msg-in phase (tag q'ing) or
; transistion to data or status phase.
;
; non-tq case: target switched to status phase.
;
INT PASS(NINT_RESEL), WHEN NOT MSG_IN ; Let UNIX driver grab it
;
; should be the 0x20 (tag msg).
;
MOVE FROM PASS(HBAOFFSET(g_moremsgin)), WHEN MSG_IN
;
; if the target resel and disconnects, handle that here.
JUMP REL(resel_disc), IF 0x04
;
; Check msg-in byte for 20, 21, or 22.
JUMP REL(Got_tag), IF 0x20 AND MASK 0x01
INT PASS(NINT_RESEL), IF NOT 0x22 ; Let UNIX driver grab it
Got_tag:
CLEAR ACK
MOVE FROM PASS(HBAOFFSET(g_tagmsg)), WHEN MSG_IN
CLEAR ACK
INT PASS(NINT_RESEL) ; Let UNIX driver grab it
alt_sig_p:
; The driver hit sig_p to start a new cmd.
; Test the connected bit in SCNTL1. If its set, retry the
; wait reselect. Otherwise, let the driver start a new cmd.
MOVE CTEST2 TO SFBR ; clear sig_p bit, if set
MOVE SCNTL1 & NBIT_ICON TO SFBR ; test the connected bit
; Interrupt if not connected.
INT PASS(NINT_SIGPROC), IF NOT NBIT_ICON
; otherwise, handle reselection.
JUMP REL(resel_m)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Every phase comes back to here.
switch:
JUMP REL(msgin), WHEN MSG_IN
JUMP REL(dataout_gotos), IF DATA_OUT
JUMP REL(datain_gotos), IF DATA_IN
JUMP REL(status_phase), IF STATUS
JUMP REL(command_phase), IF CMD
JUMP REL(errmsg_out), WHEN MSG_OUT
JUMP REL(dt_dataout_gotos), IF RES4
JUMP REL(dt_datain_gotos), IF RES5
INT PASS(NINT_ILI_PHASE)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
msgin:
; read the first byte
MOVE FROM PASS(NTOFFSET(nt_rcvmsg)), WHEN MSG_IN
msgin2:
JUMP REL(end), IF 0x00 ; command complete message
INT PASS(NINT_SDP_MSG), IF 0x02 ; save data pointers
JUMP REL(disc), IF 0x04 ; disconnect message
INT PASS(NINT_RP_MSG), IF 0x03 ; restore data pointers
INT PASS(NINT_MSGREJ), IF 0x07 ; Message Reject
JUMP REL(ext_msg_in), IF 0x01 ; extended message
JUMP REL(ignore_wide_residue), IF 0x23 ; ignore wide residue
INT PASS(NINT_UNS_MSG) ; unsupported message type
disc:
MOVE 0x00 TO SCNTL2
CLEAR ACK
WAIT DISCONNECT
INT PASS(NINT_DISC)
resel_disc:
MOVE 0x00 TO SCNTL2
CLEAR ACK
WAIT DISCONNECT
INT PASS(NINT_RESEL)
ext_msg_in:
CLEAR ACK
MOVE FROM PASS(NTOFFSET(nt_extmsg)), WHEN MSG_IN
JUMP REL(wide_msg_in), IF 0x02
JUMP REL(sync_msg_in), IF 0x03
JUMP REL(ppr_msg_in), IF 0x06
INT PASS(NINT_UNS_EXTMSG)
ignore_wide_residue:
CLEAR ACK
MOVE FROM PASS(NTOFFSET(nt_rcvmsg)), WHEN MSG_IN
INT PASS(NINT_IWR)
ppr_msg_in:
CLEAR ACK
MOVE FROM PASS(NTOFFSET(nt_pprin)), WHEN MSG_IN
; don't ack the last byte until after the interrupt handler returns
INT PASS(NINT_PPR), IF 0x04
sync_msg_in:
CLEAR ACK
MOVE FROM PASS(NTOFFSET(nt_syncin)), WHEN MSG_IN
; don't ack the last byte until after the interrupt handler returns
INT PASS(NINT_SDTR), IF 0x01
; unsupported extended message
INT PASS(NINT_UNS_EXTMSG)
wide_msg_in:
CLEAR ACK
MOVE FROM PASS(NTOFFSET(nt_widein)), WHEN MSG_IN
; don't ack the last byte until after the interrupt handler returns
INT PASS(NINT_WDTR), IF 0x03
; unsupported extended message
INT PASS(NINT_UNS_EXTMSG)
phase_mis_match:
INT PASS(NINT_PMM)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
command_phase:
MOVE FROM PASS(NTOFFSET(nt_cmd)), WHEN CMD
JUMP REL(msgin), WHEN MSG_IN
JUMP REL(switch)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
status_phase:
MOVE FROM PASS(NTOFFSET(nt_status)), WHEN STATUS
JUMP REL(switch), WHEN NOT MSG_IN
MOVE FROM PASS(NTOFFSET(nt_rcvmsg)), WHEN MSG_IN
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
end:
MOVE 0x00 TO SCNTL2
CLEAR ACK
WAIT DISCONNECT
INT PASS(NINT_OK)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; The data in and data out scatter/gather dma lists are set up by
; the driver such that they're right justified in the table indirect
; array. In other words if the s/g list contains a single segment then
; only the last entry in the list is used. If the s/g list contains
; two entries then the last two entries are used, etc.. The jump table
; below skip over the unused entries. This way when a phase mismatch
; interrupt occurs I can easily compute how far into the list processing
; has proceeded and reset the pointers and the scratch register to
; properly restart the dma.
dataout_gotos:
MOVE SCRATCHA0 TO SFBR
INT PASS(NINT_TOOMUCHDATA), IF 0
JUMP REL(dataout_1), IF 1
JUMP REL(dataout_2), IF 2
JUMP REL(dataout_3), IF 3
JUMP REL(dataout_4), IF 4
JUMP REL(dataout_5), IF 5
JUMP REL(dataout_6), IF 6
JUMP REL(dataout_7), IF 7
JUMP REL(dataout_8), IF 8
JUMP REL(dataout_9), IF 9
JUMP REL(dataout_10), IF 10
JUMP REL(dataout_11), IF 11
JUMP REL(dataout_12), IF 12
JUMP REL(dataout_13), IF 13
JUMP REL(dataout_14), IF 14
JUMP REL(dataout_15), IF 15
JUMP REL(dataout_16), IF 16
JUMP REL(dataout_17), IF 17
INT PASS(NINT_TOOMUCHDATA)
dataout_17: MOVE FROM PASS(NTOFFSET(nt_data[16])), WHEN DATA_OUT
dataout_16: MOVE FROM PASS(NTOFFSET(nt_data[15])), WHEN DATA_OUT
dataout_15: MOVE FROM PASS(NTOFFSET(nt_data[14])), WHEN DATA_OUT
dataout_14: MOVE FROM PASS(NTOFFSET(nt_data[13])), WHEN DATA_OUT
dataout_13: MOVE FROM PASS(NTOFFSET(nt_data[12])), WHEN DATA_OUT
dataout_12: MOVE FROM PASS(NTOFFSET(nt_data[11])), WHEN DATA_OUT
dataout_11: MOVE FROM PASS(NTOFFSET(nt_data[10])), WHEN DATA_OUT
dataout_10: MOVE FROM PASS(NTOFFSET(nt_data[9])), WHEN DATA_OUT
dataout_9: MOVE FROM PASS(NTOFFSET(nt_data[8])), WHEN DATA_OUT
dataout_8: MOVE FROM PASS(NTOFFSET(nt_data[7])), WHEN DATA_OUT
dataout_7: MOVE FROM PASS(NTOFFSET(nt_data[6])), WHEN DATA_OUT
dataout_6: MOVE FROM PASS(NTOFFSET(nt_data[5])), WHEN DATA_OUT
dataout_5: MOVE FROM PASS(NTOFFSET(nt_data[4])), WHEN DATA_OUT
dataout_4: MOVE FROM PASS(NTOFFSET(nt_data[3])), WHEN DATA_OUT
dataout_3: MOVE FROM PASS(NTOFFSET(nt_data[2])), WHEN DATA_OUT
dataout_2: MOVE FROM PASS(NTOFFSET(nt_data[1])), WHEN DATA_OUT
dataout_1: MOVE FROM PASS(NTOFFSET(nt_data[0])), WHEN DATA_OUT
do_list_end:
MOVE 0 TO SCRATCHA0
JUMP REL(switch)
;
; data in processing
;
datain_gotos:
MOVE SCRATCHA0 TO SFBR
INT PASS(NINT_TOOMUCHDATA), IF 0
JUMP REL(datain_1), IF 1
JUMP REL(datain_2), IF 2
JUMP REL(datain_3), IF 3
JUMP REL(datain_4), IF 4
JUMP REL(datain_5), IF 5
JUMP REL(datain_6), IF 6
JUMP REL(datain_7), IF 7
JUMP REL(datain_8), IF 8
JUMP REL(datain_9), IF 9
JUMP REL(datain_10), IF 10
JUMP REL(datain_11), IF 11
JUMP REL(datain_12), IF 12
JUMP REL(datain_13), IF 13
JUMP REL(datain_14), IF 14
JUMP REL(datain_15), IF 15
JUMP REL(datain_16), IF 16
JUMP REL(datain_17), IF 17
INT PASS(NINT_TOOMUCHDATA)
datain_17: MOVE FROM PASS(NTOFFSET(nt_data[16])), WHEN DATA_IN
datain_16: MOVE FROM PASS(NTOFFSET(nt_data[15])), WHEN DATA_IN
datain_15: MOVE FROM PASS(NTOFFSET(nt_data[14])), WHEN DATA_IN
datain_14: MOVE FROM PASS(NTOFFSET(nt_data[13])), WHEN DATA_IN
datain_13: MOVE FROM PASS(NTOFFSET(nt_data[12])), WHEN DATA_IN
datain_12: MOVE FROM PASS(NTOFFSET(nt_data[11])), WHEN DATA_IN
datain_11: MOVE FROM PASS(NTOFFSET(nt_data[10])), WHEN DATA_IN
datain_10: MOVE FROM PASS(NTOFFSET(nt_data[9])), WHEN DATA_IN
datain_9: MOVE FROM PASS(NTOFFSET(nt_data[8])), WHEN DATA_IN
datain_8: MOVE FROM PASS(NTOFFSET(nt_data[7])), WHEN DATA_IN
datain_7: MOVE FROM PASS(NTOFFSET(nt_data[6])), WHEN DATA_IN
datain_6: MOVE FROM PASS(NTOFFSET(nt_data[5])), WHEN DATA_IN
datain_5: MOVE FROM PASS(NTOFFSET(nt_data[4])), WHEN DATA_IN
datain_4: MOVE FROM PASS(NTOFFSET(nt_data[3])), WHEN DATA_IN
datain_3: MOVE FROM PASS(NTOFFSET(nt_data[2])), WHEN DATA_IN
datain_2: MOVE FROM PASS(NTOFFSET(nt_data[1])), WHEN DATA_IN
datain_1: MOVE FROM PASS(NTOFFSET(nt_data[0])), WHEN DATA_IN
di_list_end:
MOVE 0 TO SCRATCHA0
JUMP REL(switch)
dt_dataout_gotos:
MOVE SCRATCHA0 TO SFBR
INT PASS(NINT_TOOMUCHDATA), IF 0
JUMP REL(dt_dataout_1), IF 1
JUMP REL(dt_dataout_2), IF 2
JUMP REL(dt_dataout_3), IF 3
JUMP REL(dt_dataout_4), IF 4
JUMP REL(dt_dataout_5), IF 5
JUMP REL(dt_dataout_6), IF 6
JUMP REL(dt_dataout_7), IF 7
JUMP REL(dt_dataout_8), IF 8
JUMP REL(dt_dataout_9), IF 9
JUMP REL(dt_dataout_10), IF 10
JUMP REL(dt_dataout_11), IF 11
JUMP REL(dt_dataout_12), IF 12
JUMP REL(dt_dataout_13), IF 13
JUMP REL(dt_dataout_14), IF 14
JUMP REL(dt_dataout_15), IF 15
JUMP REL(dt_dataout_16), IF 16
JUMP REL(dt_dataout_17), IF 17
INT PASS(NINT_TOOMUCHDATA)
dt_dataout_17: MOVE FROM PASS(NTOFFSET(nt_data[16])), WHEN RES4
dt_dataout_16: MOVE FROM PASS(NTOFFSET(nt_data[15])), WHEN RES4
dt_dataout_15: MOVE FROM PASS(NTOFFSET(nt_data[14])), WHEN RES4
dt_dataout_14: MOVE FROM PASS(NTOFFSET(nt_data[13])), WHEN RES4
dt_dataout_13: MOVE FROM PASS(NTOFFSET(nt_data[12])), WHEN RES4
dt_dataout_12: MOVE FROM PASS(NTOFFSET(nt_data[11])), WHEN RES4
dt_dataout_11: MOVE FROM PASS(NTOFFSET(nt_data[10])), WHEN RES4
dt_dataout_10: MOVE FROM PASS(NTOFFSET(nt_data[9])), WHEN RES4
dt_dataout_9: MOVE FROM PASS(NTOFFSET(nt_data[8])), WHEN RES4
dt_dataout_8: MOVE FROM PASS(NTOFFSET(nt_data[7])), WHEN RES4
dt_dataout_7: MOVE FROM PASS(NTOFFSET(nt_data[6])), WHEN RES4
dt_dataout_6: MOVE FROM PASS(NTOFFSET(nt_data[5])), WHEN RES4
dt_dataout_5: MOVE FROM PASS(NTOFFSET(nt_data[4])), WHEN RES4
dt_dataout_4: MOVE FROM PASS(NTOFFSET(nt_data[3])), WHEN RES4
dt_dataout_3: MOVE FROM PASS(NTOFFSET(nt_data[2])), WHEN RES4
dt_dataout_2: MOVE FROM PASS(NTOFFSET(nt_data[1])), WHEN RES4
dt_dataout_1: MOVE FROM PASS(NTOFFSET(nt_data[0])), WHEN RES4
dt_do_list_end:
MOVE 0 TO SCRATCHA0
JUMP REL(switch)
;
; data in processing
;
dt_datain_gotos:
MOVE SCRATCHA0 TO SFBR
INT PASS(NINT_TOOMUCHDATA), IF 0
JUMP REL(dt_datain_1), IF 1
JUMP REL(dt_datain_2), IF 2
JUMP REL(dt_datain_3), IF 3
JUMP REL(dt_datain_4), IF 4
JUMP REL(dt_datain_5), IF 5
JUMP REL(dt_datain_6), IF 6
JUMP REL(dt_datain_7), IF 7
JUMP REL(dt_datain_8), IF 8
JUMP REL(dt_datain_9), IF 9
JUMP REL(dt_datain_10), IF 10
JUMP REL(dt_datain_11), IF 11
JUMP REL(dt_datain_12), IF 12
JUMP REL(dt_datain_13), IF 13
JUMP REL(dt_datain_14), IF 14
JUMP REL(dt_datain_15), IF 15
JUMP REL(dt_datain_16), IF 16
JUMP REL(dt_datain_17), IF 17
INT PASS(NINT_TOOMUCHDATA)
dt_datain_17: MOVE FROM PASS(NTOFFSET(nt_data[16])), WHEN RES5
dt_datain_16: MOVE FROM PASS(NTOFFSET(nt_data[15])), WHEN RES5
dt_datain_15: MOVE FROM PASS(NTOFFSET(nt_data[14])), WHEN RES5
dt_datain_14: MOVE FROM PASS(NTOFFSET(nt_data[13])), WHEN RES5
dt_datain_13: MOVE FROM PASS(NTOFFSET(nt_data[12])), WHEN RES5
dt_datain_12: MOVE FROM PASS(NTOFFSET(nt_data[11])), WHEN RES5
dt_datain_11: MOVE FROM PASS(NTOFFSET(nt_data[10])), WHEN RES5
dt_datain_10: MOVE FROM PASS(NTOFFSET(nt_data[9])), WHEN RES5
dt_datain_9: MOVE FROM PASS(NTOFFSET(nt_data[8])), WHEN RES5
dt_datain_8: MOVE FROM PASS(NTOFFSET(nt_data[7])), WHEN RES5
dt_datain_7: MOVE FROM PASS(NTOFFSET(nt_data[6])), WHEN RES5
dt_datain_6: MOVE FROM PASS(NTOFFSET(nt_data[5])), WHEN RES5
dt_datain_5: MOVE FROM PASS(NTOFFSET(nt_data[4])), WHEN RES5
dt_datain_4: MOVE FROM PASS(NTOFFSET(nt_data[3])), WHEN RES5
dt_datain_3: MOVE FROM PASS(NTOFFSET(nt_data[2])), WHEN RES5
dt_datain_2: MOVE FROM PASS(NTOFFSET(nt_data[1])), WHEN RES5
dt_datain_1: MOVE FROM PASS(NTOFFSET(nt_data[0])), WHEN RES5
dt_di_list_end:
MOVE 0 TO SCRATCHA0
JUMP REL(switch)
|
