; ; 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)