X7$ ?BOOT-U-No boot on volume ߋtv @Ǝ kQO$kQO$SRT11A DECRT11A ۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m%S'oW%S'e4@%S's:%S's:[ S'Iq S'%S'ąfa[S'9g&S'kQ-O$kQO$KkQAO$MkQO$MkQ$O$WkQ+O$XkQO$`YkQO$(ZkQO$ZkQ O$xdkQO$dkQ O$pqkQO$8rkQ O$@ykQ+O$~kQ"O$kQO$kQ(O$HkQ%O$xkQO$9g&9g&m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m۶m  @ƎMICROVMS MICROVMS03 SYSTEM DECFILE11B   0~ MICROVMS.[SYS0.SYSEXE]DCL.EXE;1tE;1  MICROVMS.NBACKUP/VERIFY _DUB0: _DUA1:[000000]MICROVMS/SAVESET/IMAGE/INTERCHANGE/NOREWIND SYSTEM @ƎY4.4 _::  _DUA1: V4.4 ~   .; CUR.COM, IND control file. .; Reports on your current default device. .; .; This file looks at the directory volume identification .; to determine where it is. .; The Volume ID format may either be the standard RT one, or .; it can be compatible with the DSKLIB disk catalog program, .; i.e., the 12-character Volume ID label is of the form .; NNNFFFFFFXXX, where NNN is a three-digit number .; used by DSKLIB for its cataloging purposes, .; FFFFFF is the volume name, and XXX is an extension. .; Examples are 001SYSTEMSYS, or 675FORTRADSK. .; .; This file is used by UP and HOME. Because there is no IND .; directive to relate LD's with files, we can't figure out which .; device the file is on when we come "up" from a deeper-nested .; subdevice. Therefore, no device is shown. .; .; You can also display CURDK.TMP dirctly to tell you where you are: .; When used in conjunction with UCL, you can type a KMON command .; CUR and your current default device will print on the terminal. .; The UCL+ entry is .; CUR == TYPE SY:CURDK.TMP .; .; Written by: .; R. W. Barnard .; Sandia National Laboratories, Division 7523 .; Albuquerque, NM 87185 .; .; Version 1.1; 3-May-85 .; .enable quiet .; .vol CURVOL DK .sets DLBNUM CURVOL[1:3] .;Separate off the number. .if DLBNUM gt "999" .goto 10 .;Not a DSKLIB-formatted volume. .sets VOLID CURVOL[4:9.] .;Get the name. .sets VOLEXT CURVOL[10.:12.] .;Get the extension. .sets CURFIL "'VOLID'.'VOLEXT'" .;DSKLIB volume ID. .goto 20 .10: .sets CURFIL CURVOL .;Non-DSKLIB volume ID. .; .20: .open SY:CURDK.TMP .data E DK is 'CURFIL' .close .; Message is printed in bold, and is positioned better on screen. TYPE SY:CURDK.TMP .exit .; DOWN.COM, IND control file. .; Assigns default device to specified logical device. .; .; This command file can support up to two levels of .; directory nesting. It uses LD7 and LD6 for its operations. .; The first level is LD7, and the second is LD6. .; The file SY:CURDK.TMP holds the current default information. .; .; When used in conjunction with UCL, you can type .; DO[WN] FILNAM and have that file become the default. .; The UCL entry is .; DOWN == R IND\SY:DOWN ^ (assuming you are using UCL+). .; .; Written by: .; R. W. Barnard .; Sandia National Laboratories, Division 7523 .; Albuquerque, NM 87185 .; .; Version 1.5; 24-May-85 .; .enable quiet .disable lowercase .disable prefix,suffix .; .if p1 ne "" .goto 10 .asks P1 Down to which file .; .10: .parse P1 ":" DEV FNAME .if FNAME ne "" .goto 20 .;Device was entered. .sets FNAME DEV .;Device not entered - use default. .sets DEV "DK" .; See if the filespec has a null extension. .20: .test P1 .sets EXTQ P1[:] .sett NULEXT .;If null ext, last char of filespec will be . .if EXTQ ne "." .setf NULEXT .parse FNAME "." FNAME EXT .if EXT ne "" .goto 30 .;Extension was entered. .iff NULEXT .sets EXT "DSK" .;Ext not entered - use default. .; .30: .sets FILNAM "'FNAME'.'EXT'" .;Build the complete file name. .testfile 'DEV':'FILNAM' .sets CURFIL .if ne .goto badnam .; ASS 'DEV' DK .testdevice DK .parse "," DEVNAM SIZE A1 A2 A3 LOAD ONL MOU NAT .sets CURLD "LD7" .;See if we are already down one level. .if DEVNAM ne CURLD .goto mou .sets CURLD "LD6" .; .mou: MOUNT 'CURLD' 'FILNAM' DK .; Show where we are. .open SY:CURDK.TMP .data E DK is 'CURFIL' .close .; Message is printed in bold, and is positioned better on screen. TYPE SY:CURDK.TMP .exit .; .badnam: .testdevice 'DEV' .parse "," DEVNAM SIZE .if eq 346 ; No such file 'DEVNAM':'FILNAM' .if eq 340 ; 'DEV' not mounted. .exit .; HOME.COM, IND control file. .; Moves back to default (SY) device and deassigns DK. .; .; When used in conjunction with UCL, you can type a KMON command .; HO[ME] and move back to the system default for DK. .; The UCL+ entry is .; HOME == R IND\SY:HOME .; .; Written by: .; R. W. Barnard .; Sandia National Laboratories, Division 7523 .; Albuquerque, NM 87185 .; .; Version 1.2; 2-May-85 .; .enable quiet .disable lowercase .enable global .; .testdevice DK .parse "," DEVNAM SIZE A1 A2 A3 LOAD ONL MOU NAT .if DEVNAM eq "LD6" DISMOUNT LD6 DISMOUNT LD7 DEASS DK .; Show where we are. @SY:CUR .exit .; INCBUP.COM, IND control file. .; .; Format is INCBUP P1 P2 P3 P4 .; P1 is SOURCE VOLUME .; P2 is BACKUP VOLUME .; P3 is DATE OF BACKUP .; P4 is BACKUP DEVICE .; Refer to INCBUP.DOC for instructions and definitions. .; .; Version 2 gives unique file names to subdevices used for .; backups, so several can be put on one physical device. .; Version 3 now checks disk size to be sure files will fit. .; Version 4 includes cataloging by DSKLIB, and better MULTIVOLUME .; verification. .; Version 4.2, 22-May-85 .; .; Written by: R. W. Barnard .; Sandia National Laboratories, Division 7523 .; Albuquerque, NM 87185 .; .disable lowercase,octal .disable prefix .enable escape .enable quiet SET TT QUIET .; .; Clear the screen. ; ; ; INCBUP - RT-11 Incremental file backup. .; .; Exiting instructions to the user. ; ; You may stop the command file by typing ; in answer to any question. ; .; .; Change the assignment of your work device here. ASSIGN VM WF .; Change the name of the file to remember DSKLIB catalog numbers here. .sets DLBFIL "SY:INCBUP.DAT" .; Change the volume initialization owner name here. .sets OWNAME "R W Barnard" .; Change the default SOURCE VOLUME here. .sets SRV "WA" .; Change the default BACKUP VOLUME here. .sets BKV "LD4" .; Change the default BACKUP DEVICE here (used for backing up to LD's). .sets BKD "FW0" .; .if P1 ne "" .goto 10 .asks [0:4:"'SRV'"] A1 Enter the source volume .ift .goto quit .sets P1 A1 .10: .parse P1 ":" P1 A2 ASSIGN 'P1' INP .sets SRCVOL P1+" " .;Fill out the device name to 3 characters. .sets SRCVOL SRCVOL[1:3] .;Now trim to exactly 3 characters. .; .sets LASDAT P3 .if P3 ne "" .goto 20 .disable suffix .getdat: .asks LASDAT Enter the date (plus 1 day!) of the last backup .ift .goto quit .if LASDAT eq "" .goto getdat .enable suffix .; .20: .parse "-" DAY MON YR .gosub trnmon DIR/BRI/OUT:WF:INCBUP/SINCE:'LASDAT'/EXCLUDE INP:*.(BAK,DSK) .openr WF:INCBUP.DIR .read DIRREC .;Read the date line. .loop: .read DIRREC .;Read the remainder of the directory. .parse DIRREC "," FILES BLOCKS .if BLOCKS eq "" .goto 30 .parse FILES " " A1 NUMFIL A2 .parse BLOCKS " " A1 BLKSIZ A2 .goto 40 .; .30: .iff .goto loop .40: .close .if BLKSIZ eq "0" .goto nuttin .; ; ; You have 'BLKSIZ' blocks, 'NUMFIL' files to be backed up. ; .setn SEGSIZ 'NUMFIL'/70+1 .if P2 ne "" .goto 50 .asks [0:4:"'BKV'"] BKVOL Enter the backup volume .ift .goto quit .sets P2 BKVOL .; Get rid of any : that may have been typed. .50: .parse P2 ":" BKVOL A2 .; ASSIGN 'BKVOL' OUP .; Create the file to initialize the output volume. .testfile 'DLBFIL' .if ne .gosub dsknum .openr #2 'DLBFIL' .read #2 DSKNUM .close #2 .enable lowercase .open WF:INITD.COM .enable data DUP OUP:/Z/V/Y/N:'SEGSIZ' 'DSKNUM'Bak'SRCVOL''MO''DAY' 'OWNAME' ^C .disable data .close .disable lowercase .sets MULCOP "" .; .sets DEVNAM BKVOL[1:2] .;Get the 1st 2 chars of device name. .if DEVNAM ne "LD" .goto 100 .; .; ***Backup to Logical Devices*** .; .if P4 ne "" .goto 60 .asks [0:4:"'BKD'"] BKPDEV Enter the backup device for the logical disk .ift .goto quit .sets P4 BKPDEV .60: .parse P4 ":" BKPDEV A3 .setn BKPSIZ 'BLKSIZ'.+6+(2*'SEGSIZ') .; .disable suffix .dsksiz: .gosub dskchk .if MAXSIZ ge BKPSIZ .goto 70 .ask QQ Your files won''t fit on this disk. Put in another and type .ift .goto quit .goto dsksiz .; .70: .enable suffix .sets BKUFIL "'BKPDEV':BAK'P1'.'MO''DAY'" .testfile 'BKUFIL' .if ne .goto 90 .ask [] QQ File 'BKUFIL' exists... Delete it .iff QQ .goto 80 UNPROT 'BKUFIL' DELETE/NOQUERY 'BKUFIL' .goto 90 .; .80: .disable suffix .ask QQ Put in another disk and type .ift .goto quit .enable suffix .goto dsksiz .; .90: CREATE 'BKUFIL'/ALL:'BKPSIZ' MOUNT 'BKVOL' 'BKUFIL' .; .; Make the file to run the DSKLIB cataloguer. .open WF:DSKLIB.COM .data SET TT QUIET .data R DLBCOM .data OSY:INCBUP UF'BKUFIL' Q .close ; ; Initializing the backup volume ('BKVOL') now. $@WF:INITD.COM .goto 130 .; .; ***Backup to a Physical device*** .; .100: .sets BKPDEV BKVOL ; .ask [] QQ Do you want to initialize the backup device .ift .goto quit .iff QQ .goto 110 $@WF:INITD.COM .110: .gosub dskchk .setn BLKN 'BLKSIZ' .if MAXSIZ ge BLKN .goto 120 .sets MULCOP "/MULTIVOL" ; Need to do a multivolume backup. .; .; Make the file to run the DSKLIB cataloguer. .120: .open WF:DSKLIB.COM .data SET TT QUIET .data R DLBCOM .data OSY:INCBUP UF'BKVOL': Q .close .; .130: DELETE/NOQ WF:INCBUP.DIR DELETE/NOQ WF:INITD.COM ; ; Copying the files to the backup volume now. COPY/SINCE:'LASDAT'/INFORM/EXCLUDE/NOLOG'MULCOP' INP:*.(BAK,DSK) OUP: .setf SLON .ifloa SL .sett SLON SET SL OFF .; .; Do different things depending on MULCOP. .if MULCOP ne "" .goto 140 ; ; Verifying the files on the backup volume now. COPY/SYSTEM/NOLOG OUP:*.* NL: ; ; Cataloging the backed-up files now. $@WF:DSKLIB DIRECTORY/PRINTER/VOLUME OUP: .if DEVNAM eq "LD" DISMOUNT 'BKVOL' .goto 160 .; .140: ; ; Verifying the backup output volumes now. ; Start with the first disk in the sequence. ; Type with no disk in 'BKVOL' when all have been verified. .setn DSKCNT 1 .disable suffix .vfylp: ; .ask QQ Put disk 'DSKCNT' in drive 'BKVOL' and type .testdevice OUP .parse "," A1 A2 A3 A4 A5 A6 ONLINE MOUNT .if ONLINE ne "ONL" .goto 160 COPY/SYSTEM/NOLOG OUP:*.* NL: .if DSKCNT eq 1 .goto 150 .; .setn DN 'DSKNUM' .;Need to give vol ID to second and later .inc DN .;disks. .sets DSKN "'DN'" .gosub longnm .open WF:DSKLIB.COM .enable data R DLBCOM OSY:INCBUPVF'BKVOL':'DSKNUM'Bk'DSKCNT''SRCVOL'.'MO''DAY'/OWUF'BKVOL':Q .disable data .close .150: ; ; Cataloging the backed-up files now. $@WF:DSKLIB DIRECTORY/PRINTER/VOLUME OUP: .inc DSKCNT .goto vfylp .; .160: .ift SLON SET SL ON .; Increment the number for DSLKIB. .setn DN 'DSKNUM' .inc DN .sets DSKN "'DN'" .gosub longnm .; Write the latest DSKLIB disk number in a file for use next time. .open #2 'DLBFIL' .data #2 'DSKNUM' .close #2 DELETE/NOQ WF:DSKLIB.COM DEASS INP DEASS OUP ; ; Backup of 'P1' completed. ; .exit .; .nuttin: ; ; Stoping because you have no new files... ; Rerun this command file when you have done some work! ; .exit .; .; ***Subroutines*** .; .; Routine for creating a unique extension for a subdevice file .; from the day and month. .; .trnmon: .sets MONTHS "JanFebMarAprMayJunJulAugSepOctNovDec" .setn COUNT 1 .mloop: .setn K 3*COUNT-2 .sets MO MONTHS[K:K+2] .if MON eq MO .goto retn .setn COUNT COUNT+1 .goto mloop .; .retn: .sets MONTHS "123456789OND" .sets MO MONTHS[COUNT:COUNT] .return .; .; Routine for checking disk presence and free space. .; .dskchk: .; See if the device is online (i.e., a disk in the drive). .testdevice 'BKPDEV' .parse "," A1 A2 A3 A4 A5 A6 ONLINE MOUNT .if ONLINE eq "ONL" .goto frespc .;Now check its free space. .disable suffix .ask QQ Put a disk in device 'BKPDEV'. Type to continue .enable suffix .ift .goto quit .goto dskchk .; .frespc: DIR/FRE/COL:1/OUT:WF:FRESPC 'BKPDEV': .; .; Find the largest free space on the disk. .; Open the directory file. .openr WF:FRESPC.DIR .setn MAXSIZ 0 .;Initialize maximum size. .read DIRREC .;Read the top line from the file. .floop: .read DIRREC .;Read another line from the file. .parse DIRREC ">" A1 SIZE .if SIZE eq "" .goto 200 .setn SIZN 'SIZE' .if SIZN gt MAXSIZ .setn MAXSIZ SIZN .iff .goto floop .200: .close DELETE/NOQ WF:FRESPC.DIR .return .; .; Routine to establish the file to hold DSKLIB disk catalog numbers. .; By using this file, subsequent backup volumes will have sequential numbers. .; .dsknum: .if ne 230. .goto quit ; ; File 'DLBFIL' not found. ; This file stores the next disk number for DSKLIB catalog. .asks [0:3:"001"] DSKNUM What disk number do you want to start with .ift .goto quit .sets DSKN DSKNUM .gosub longnm .open #2 'DLBFIL' .data #2 'DSKNUM' .close #2 .return .; .; Routine to make sure that DSKLIB catalog numbers are always 3 characters. .; .longnm: .test DSKN .if eq 3 .return .setn COUNT 3- .sets ZEROS "00" .sets DSKNUM ZEROS[1:COUNT] .sets DSKNUM DSKNUM+DSKN .return .; .quit: ; ; INCBUP aborted. ; .exit  May 18, 1985 INCBUP - RT-11 Incremental Backup R. W. Barnard Sandia National Laboratories Minicomputer Software Division 7523 P. O. Box 5800 Albuquerque, NM 87185 (505) 844-5115 Introduction ____________ INCBUP is an IND control file which provides RT-11 users an incremental backup facility quite similar to RSX BRU or VMS BACKUP. Using INCBUP, backups can easily be done on files created since a specified date. The backup volume can be either a physi- cal disk or a logical disk residing on a larger device. In the case of the latter, the subdevice files are given unique names, so backups from the same source volume made on different dates can be stored on the same backup device. INCBUP uses the DECUS Library program DSKLIB, #11-743, (also available on the Spring and Fall, 1984, RT SIG tapes) to catalog the backed-up files for instantane- ous reference. (Try it - you will see that DSKLIB works essentially instantaneously)! INCBUP supports RT-11 multivolume copies, and has considerable error checking. Some definitions: Source Volume is the disk or subdevice file ______ ______ to be backed up. Backup Volume is the disk or subdevice file that ______ ______ you are copying the files to. If the backup volume is a logical device, the physical disk that it resides on is the Backup Device. ______ ______ Setup _____ You can change the names of certain defaults in INCBUP. To do so, edit the file and search for the string "Change". Immedi- ately following each instance will be some device specification or string that you can change. INCBUP expects that you will have already created a DSKLIB catalog called INCBUP.DLB on SY:. This is a secondary catalog, not your primary DSKLIB catalog. (Refer to the DSKLIB documentation for more details). Useage ______ You run INCBUP by typing R IND *SY:INCBUP or IND SY:INCBUP INCBUP - RT-11 Incremental Backup Page 2 The parameters of INCBUP, which may be included after the file name in the first case, are: Source_Volume Backup_Volume Date Backup_Device If any of these are not provided, the file will prompt for them. The files you have backed up can be located with the DSKLIB F(ind) command. Mechanics _________ INCBUP creates backup volumes which are initialized according to the DSKLIB protocol. The volume ID is of the form nnnBakDEVMDA, where nnn is a 3-digit serial disk number (zero filled), BakDEV is the volume name (the source volume device name will be substituted for DEV), and MDA is the date of the backup (April 13 is 413, October 9 is O09). The disk number is automati- cally read from a file SY:INCBUP.DAT, and the correctly updated number will be written to INCBUP.DAT when INCBUP finishes. INCBUP uses logical device LD4 as the default when a subdev- ice is specified for the backup volume. The subdevice file must be able to fit on your backup device, or INCBUP will prompt you to put in a new disk. If the number of blocks you need to back up is greater than the size of your backup device, you can use the RT-11 COPY/MULTIVOLUME facility. To do this, specify the backup volume to be a physical disk. INCBUP will then automatically copy your files in /MULTIVOLUME mode. Note that you must initialize each backup device disk that you expect to use before you start, because COPY/MULTIVOLUME doesn't let you stop in the middle to do initializations. It isn't necessary to do the correct volume identification when you initialize, because INCBUP will reinitial- ize the volume ID of each backup device disk that you have used. The output from INCBUP is a printer directory listing of the files you have backed up. Additionally, the files are catalogued in the DSKLIB catalog with a unique DSKLIB disk serial number. DSKLIB is run by the program DLBCOM, which provides for chain entry into DSKLIB, and a command line of DSKLIB commands. The format of the command line should not be changed unless you are familiar with DSKLIB. Restriction ___________ If you assign the logical name WF (Work File) to a device you are backing up, INCBUP will not copy the correct files. The file WF:DSKLIB.COM may be copied in place of one which was originally specified. If WF is assigned to the VM memory device, this won't happen.  B May 18, 19853 IND Control Files. INCBUP - Incremental Backup6 DOWN - Go down one logical device4 UP - Go up one logical device5 HOME - Go back to SY: as default7 CUR - Show current default device Written by:1 R. W. Barnard8 Sandia National Laboratories< Minicomputer Software Division 75231 P. O. Box 58005 Albuquerque, NM 871851 (505) 844-5115H INCBUP provides for an incremental (since the last backup)H facility for RT-11 users. The file is described in the writeup INCBUP.DOC.J UP, DOWN, HOME allow movement among subdevices. When you goH DOWN to a filespec, it becomes your default device. Thse files1 are described in the writeup UPDOWN.DOC.J CUR reports your current whereabouts (with respect to subde-5 vices). It is also described in UPDOWN.DOC.I If users have any suggestions for improvements, complaints,/ or bug discoveries, please contact me. .; UP.COM, IND control file. .; Moves up one logical device and reassigns default device. .; .; When used in conjunction with UCL, you can type a KMON command .; UP and move up one level. .; The UCL+ entry is .; UP == R IND\SY:UP .; .; Written by: .; R. W. Barnard .; Sandia National Laboratories, Division 7523 .; Albuquerque, NM 87185 .; .; Version 1.2; 2-May-85 .; .enable quiet .disable lowercase .testdevice DK .parse "," DEVNAM SIZE A1 A2 A3 LOAD ONL MOU NAT .sets CURLD "LD6" .;See if we are down two levels. .if DEVNAM eq CURLD .goto up1 .sets CURLD "LD7" .;No - just go back to SY: DEASS DK .goto 10 .up1: ASS LD7 DK .10: DISMOUNT 'CURLD' .; Show where we are. @SY:CUR .exit May 18, 1985 UPDOWN - RT-11 Subdevice Managers R. W. Barnard Sandia National Laboratories Minicomputer Software Division 7523 P. O. Box 5800 Albuquerque, NM 87185 (505) 844-5115 Introduction ____________ The IND control files DOWN, UP, and HOME can be used to con- veniently move among subdevices. DOWN will mount a subdevice and assign DK to that device. DOWN supports two levels of subdevices (i.e., a subdevice within a subdevice). UP moves back up one sub- device. HOME returns you from wherever you are to SY: as your default device. You can also create a command OVER, which goes from one subdevice to another. The files report the filespec of the subdevice file in which you are currently located with the IND file CUR. Useage ______ These files can be used very effectively with UCL. Thus, you can define DOWN == R IND\SY:DOWN ^ (assuming you are using UCL+... syntax is slightly different for the DEC UCL). To use, you can then just type DO[WN] FILESPEC Similarly, you can define UP == R IND\SY:UP, and OVER == R IND\SY:UP\R IND\SY:DOWN ^ Note that if you are two levels deep in subdevices, and want to go OVER to another subdevice located on the subdevice above (e.g., LD7), you do not need to specify the device name. Thus, if BIGDSK.DSK has the files DISK1.DSK and DISK2.DSK, and you are cur- rently in DISK1, then you may type OVER DISK2, instead of OVER LD7:DISK2. Mechanics _________ Because of a limitation of IND (which has been SPR'ed) it is not possible to relate a file to a logical device assignment (or vice versa) from within an IND file. Consequently, these IND files use LD7 for the first level of subdevice, and LD6 for the UPDOWN - RT-11 Subdevice Managers Page 2 next subdevice. Furthermore, when you go DOWN, you are told exactly which file is now your default (e.g., DU0:FORTRA.DSK), but when you come UP or HOME, IND cannot tell which file you are cur- rently in. It therefore can only report the name of the file, but not the device it is on. The file DOWN takes as an argument the file you want to go down to. It assumes it to be on DK:, with an extension .DSK, unless you specify otherwise. If you do not specify a file when you run DOWN, you will be prompted. In order to figure out where it is, the files UP and HOME use the volume ID of the disk or subdevice. The file which reads the Volume ID is CUR.COM (CURrent location). Volume IDs can be done in either of two formats - the regular RT format, in which you use the 12 characters of the Volume ID for something like FORTRA.DSK, or in the DSKLIB format. The latter program is a means of main- taining an on-line catalog of your disks. It is available as DECUS Library program #11-743. Regardless of the format, CUR reports only the file name and extension. You can define a UCL command CUR == TYPE SY:CUR.COM to report your whereabouts at any time. PEN BR 3$ 2$: JSR PC,NFOUND 3$: MOV WCSAV,R4 MOV CASAV,CA .IF NE MMG$T CLRB CTMVS .ENDC BR 1$ 4$: .ENDC ADD #200,R4 BCS RTSPC .IF NE MMG$T ADD #2,QPAR .IFF ADD #200,CA .ENDC BR 1$ .SBTTL READ SERVICE ROUTINE READU: .ADDR #LBLBUF,R0 MOV R0,CA READB: MOV #READ,R1 BR SOFT1 TSTBAK: TST BLOCK BNE RTSPC JSR R0,SOFT .WORD LSTFIL FSP: MOV #NXTBLK,R1 BR SOFT1 WSENT: JSR R0,SOFT .WORD WGAP JSR PC,NAMOFF CLRB (R1) JSR PC,LABEL BSP: MOV #LSTBLK,R1 BR SOFT1 .SBTTL SOFT - INITIATE SOFTWARE FUNCTION SOFT: MOV (R0)+,R1 MOV R0,@SP SOFT1: JSR R4,SAVSTK .SBTTL FUNCTION INITIATION ROUTINE .ENABL LSB XCT: BIC #177770,R1 MOV R1,CURFUN TSTB F.MACRO BNE 2$ BITB UBITS,F.HW BNE 1$ CMP R1,#REWIND BEQ 3$ JMP CTILLF 3$: BISB UBITS,F.HW 1$: MOV R1,-(SP) JSR PC,DUNDEL MOV (SP)+,R1 2$: MOV #3,(PC)+ RETRY: .WORD 0 ASL R1 RERE: CLRB BIP .IF NE MMG$T MOV CA,TACA MOV WC,TABC MOV TC,TATC MOV QPAR,TAQP MOV #512.,TAQPCT .IFF MOV CA,(PC)+ TACA: .WORD 0 MOV WC,(PC)+ TABC: .WORD 0 MOV TC,(PC)+ TATC: .WORD 0 .ENDC SETFUN: MOVB R1,(T5) JSR R3,RESREG BIS #INTEN+GO,@#TACS RTSPC: RTS PC .IF NE MMG$T TACA: .WORD 0 TABC: .WORD 0 TATC: .WORD 0 TAQP: .WORD 0 TAQPCT: .WORD 0 .ENDC .DSABL LSB .IF DF MUL .SBTTL SYNCH ROUTINE .ENABL LSB CTSYNCH:MOV @SP,1$ ADD #2,@SP BIT #SJMON,CTSJ BEQ 10$ JSR R4,SAVSTK ADD #SYNBLK-.,R4 JSR R3,RESREG CLR 12(R4) JSR R5,@SYNCH(R5) .IF NE MMG$T BR CTABRJ .IFF BR CTABRT .ENDC JSR PC,@(PC)+ 1$: .WORD 0 MOVB #PR6,@#PSW MOV @SP,-(SP) CLR 2(SP) BR CTINT 10$: JSR PC,@1$ RTS PC CTSJ: .WORD 0 .DSABL LSB .ENDC .IF NE MMG$T CTABRJ: JMP CTABRT .ENDC .SBTTL INTERRUPT ROUTINE .ENABL LSB .IF NE MMG$T .DRAST CT,6,CTABRJ .IFF .DRAST CT,6,CTABRT .ENDC MOV R3,-(SP) MOV R0,-(SP) MOV R1,-(SP) MOV R2,-(SP) MOV SP,SPSAV CTIN2: MOV #TACS,T5 TSTB (T5) BPL 10$ INC TABC BGT 3$ MOV TACA,R0 .IF NE MMG$T MOV #TADB,R3 .ENDC INC TATC .IF NE MMG$T BLE CDOXF .ADDR #CXFER,R0 BR CMRW CXFER: .WORD 0 RAWFLG: .BYTE 0 CTURW: .BYTE 0 CDOXF: TSTB CTURW BEQ CMRW TSTB CTMVS BNE CMRW TSTB RAWFLG BNE CMRW MOV R4,-(SP) .ADDR #TACA-4,R4 CMP CURFUN,#READ BNE XCWRIT XCREAD: MOVB (R3),-(SP) JSR PC,@$PTBYT BR 5$ XCWRIT: JSR PC,@$GTBYT MOVB (SP)+,(R3) 5$: MOV (SP)+,R4 BR 6$ CMRW: CMP CURFUN,#READ BNE 1$ MOVB (R3),(R0) BR 2$ 1$: MOVB (R0),(R3) 2$: INC TACA 6$: DEC TAQPCT BNE 4$ ADD #8.,TAQP SUB #8.*32.*2,TACA MOV #512.,TAQPCT .IFF BLE 1$ .ADDR #2$,R0 1$: MOV #TADB,R3 MOV #111013,2$ CMP CURFUN,#READ BNE 2$ MOV (PC)+,(PC) MOVB (R3),(R0) 2$: HALT INC TACA .ENDC BR 4$ 3$: BIS #ILBS,(T5) 4$: JSR R3,RESREG RTS PC 10$: BIC #INTEN,(T5) BIT #READY,(T5) BEQ ERRHW TST (T5) BMI 20$ 11$: TSTB BIP BNE 12$ TSTB F.MACRO BEQ RESP JSR R4,RESSTK RTS PC 12$: MOVB CURFUN,R1 .IF NE MMG$T JMP RERE .IFF BR RERE .ENDC 20$: MOV (T5),R3 BIT #BOTEOT,R3 BNE 22$ BIT #CRC+WRL+TIME,R3;IF NOT BOTEOT,OFF,OR FILE GAP BNE 21$ 22$: BITB UBITS,F.HW BNE 21$ BIT #OFF+WRL,(T5) BEQ 11$ TST (PC)+ IGNOFF: .WORD 0 BNE 11$ 21$: TSTB BIP BNE ERRHW DEC RETRY BLE ERRHW BIT #OFF+WRL+BOTEOT+FGAP,R3 BNE ERRHW MOV R3,(PC)+ CURFUN: .BYTE 0 BIP: .BYTE 0 MOV #LSTBLK*FUNC,R1 JMP SETFUN CTABRT: BIC #INTEN,@#TACS BR CTHOME .DSABL LSB .SBTTL EXIT SEQUENCE .ENABL LSB ERRHW: BIS #HWERR,@CSWPTR TSTB F.MACRO BEQ RESP BITB #FILNFD+ILLFUN,@SWWPTR BNE 2$ BISB #FILNFD,@SWWPTR CLEAN: BITB UBITS,F.WRITE BNE 1$ BITB UBITS,ENTFLG BEQ RESP 1$: JSR R0,SOFT .WORD LSTFIL JSR PC,WSENT 2$: JSR PC,DUNDEL RESP: CLR FIN MOV SPSAV,SP JSR R3,RESREG .IF NDF DEBUG CTHOME: .DRFIN CT .IFF JMP QMAN .ENDC .DSABL LSB .SBTTL SEEK .ENABL LSB SEEK: MOV CA,R2 ADD #6,R2 JSR PC,NAMOFF ADD #11,R1 CLRB (R1) MOV #^B<0010010010000000>,R3 1$: MOV -(R2),R0 2$: CLR R4 MOV #16.,-(SP) 3$: ASL R0 ROL R4 CMP R4,#50 BLO 4$ SUB #50,R4 INC R0 4$: DEC (SP) BNE 3$ BIS (SP)+,R4 BEQ 5$ CMP R4,#32 BLE 6$ SUB #36,R4 BCC 7$ 5$: MOV #-40,R4 6$: ADD #20,R4 7$: ADD #60,R4 MOVB R4,-(R1) ASL R3 BCC 2$ BNE 1$ TST BLOCK BGT CHKHDR NEG BLOCK SEEKC: JSR R0,SOFT .WORD REWIND CHKHDR: MOV #-32.,WC MOV #-32.,TC JSR PC,READU .IF DF MUL JSR PC,EOTCHK BNE SEEKC .ENDC JSR PC,NAMOFF MOV CA,R0 TSTB (R0) BEQ 12$ DEC BLOCK BEQ 11$ MOV #9.,R3 10$: BICB #200,(R0) CMPB (R0)+,(R1)+ BNE 20$ DEC R3 BGT 10$ .IF DF MUL CMPB 3(R0),(R1) BNE 20$ .ENDC 11$: ADD #2,(SP) 12$: JMP BSP 20$: JSR R0,SOFT .WORD NXTFIL BR CHKHDR .DSABL LSB .SBTTL EOTCHK, VOLCHK .IF DF MUL .ENABL LSB EOTCHK: JSR PC,VOLCHK BEQ 1$ .IF NE MMG$T INCB CTMVS .ENDC CMP WC,#-32. BEQ 2$ JSR PC,NAMOFF ADD #11,R1 INCB (R1) MOV R4,(PC)+ WCSAV: .WORD 0 MOV CA,(PC)+ CASAV: .WORD 0 2$: TST SP 1$: RTS PC .DSABL LSB .ENABL LSB VOLCHK: BIT #BOTEOT,(T5) BEQ 3$ DEC TABC BEQ 3$ CLR (PC)+ OFLAG: .WORD 0 JSR PC,CTSYNCH BR 10$ 1$: INC IGNOFF JSR R0,SOFT .WORD NXTBLK BIT #OFF,(T5) BEQ 2$ MOV #100001,OFLAG JSR PC,CTSYNCH RTS PC CLR IGNOFF BR 1$ 2$: CLR IGNOFF TST OFLAG BEQ 4$ DEC OFLAG BVC 1$ 3$: RTS PC 4$: BIT #BOTEOT+OFF,(T5) BNE 1$ JSR R0,SOFT .WORD REWIND BICB UBITS,F.CLOSE JMP SWEOF 10$: .ADDR #UNO,R0 MOVB UNIT,@R0 BISB #'0,@R0 TST -(R0) .PRINT RTS PC .NLIST BEX MSG: .ASCII "CT" UNO: .ASCIZ "0: PUSH REWIND OR MOUNT NEW VOLUME" .LIST BEX .EVEN .DSABL LSB .ENDC .SBTTL LABEL PROCESSOR LABEL: JSR PC,NAMOFF .ADDR #FILNAM,R2 MOV #9.,R4 1$: MOVB (R1)+,(R2)+ DEC R4 BGT 1$ ADD #3,R2 MOVB (R1)+,(R2)+ TSTB (R2)+ .DATE MOV R0,R1 ASL R1 ASL R1 ASL R1 BIC #160377,R1 JSR PC,ASC MOV R0,R1 BNE 2$ CLRB -2(R2) 2$: ASR R1 ASR R1 JSR PC,ASC MOV R0,R1 BIC #177740,R1 ADD #72.,R1 SWAB R1 JSR PC,ASC ADD #FILNAM-GENNO,R2;POINT R2 TO START OF HEADER DELAB: MOV R2,CA MOV #-32.,WC JMP WRTBLK ASC: CLRB R1 1$: ADD #173001,R1 BPL 1$ ADD #"00+<10.*400-1>,R1 MOV R1,(R2)+ RTS PC .SBTTL UTILITY ROUTINES SAVSTK: JSR R2,@PC ADD #STAK-.,R2 MOV R2,STKPTR 1$: MOV (SP)+,(R2)+ CMP SPSAV,SP BHI 1$ MOV R2,(PC)+ SPSAVE: 0 JMP @R4 .ENABL LSB RESSTK: TST (SP)+ MOV SPSAVE,R2 1$: MOV -(R2),-(SP) CMP (PC)+,R2 STKPTR: 0 BNE 1$ MOV (SP)+,R2 RTS R4 .DSABL LSB RESREG: TST (SP)+ MOV (SP)+,R2 MOV (SP)+,R1 MOV (SP)+,R0 MOV @#MONLOW,R5 RTS R3 NAMOFF: MOV UNIT,R3 .ADDR #SNAME-12,R1 1$: ADD #12,R1 DEC R3 BGE 1$ RTS PC .SBTTL DATA AREAS MACROS=.-2 10$: .WORD $CLOSE-. .WORD $DELETE-. .WORD $LOOKUP-. .WORD $ENTER-. .WORD $READ-. .WORD $WRITE-. .IF DF NEWVOL .WORD $NEWVOL-. .ENDC MAXFUN = <. - 10$> / 2 FLGTAB: F.HW: .BYTE 0 F.MACRO:.BYTE 0 F.CLOSE:.BYTE 0 F.DELETE:.BYTE 377 F.LOOKUP:.BYTE 377 F.ENTER:.BYTE 377 F.READ: .BYTE 0 F.WRITE:.BYTE 0 .IF DF NEWVOL F.NEWVOL:.BYTE 377 .ENDC .EVEN FILNAM: .ASCII / / FILTYP: .BYTE 0 LENGTH: .BYTE 0 .BYTE 200 SEQNO: .BYTE 0 LEVEL: .BYTE 1 DATE: .ASCII / / GENNO: .BYTE 0 ATTR: .BYTE 0 UNUSED: .BYTE 0,0,0,0,0,0,0,0,0,0 .EVEN LBLBUF: .BLKB 32. .IF DF RCHECK .BLKB 128.-32. .ENDC .IF NE MMG$T FILENM: .WORD 0,0,0 .ENDC SNAME: .BLKB 12*2 SYNBLK: .WORD 0,0,0,0,0,0,0 STAK: .BLKW 12 .IIF NDF DEBUG, .NLIST .IF DF DEBUG .=.+100 .ENDC .IIF NDF DEBUG, .LIST .IF DF INIT .END TEST .ENDC .DREND CT .END .MCALL .MODULE .MODULE DD,VERSION=13,COMMENT=,AUDIT=YES ; COPYRIGHT (c) 1984,1985,1986 BY ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. ; ALL RIGHTS RESERVED. ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED ; ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE ; INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER ; COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY ; OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY ; TRANSFERRED. ; ; THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE ; AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT ; CORPORATION. ; ; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS ; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL. .SBTTL CONDITIONAL ASSEMBLY SUMMARY .SBTTL GENERAL COMMENTS .ENABL LC .SBTTL MACROS AND DEFINITIONS .MCALL .DRDEF, .MTPS, .ASSUME .ADDR .IIF NDF DD$PRI DD$PRI = 4 .IIF NDF DDT$O DDT$O = 0 .IIF NDF DD$CS2 DD$CS2 = 176510 .IIF NDF DD$VC2 DD$VC2 = 310 .DRDEF DD,34,FILST$,512.,176500,300 .IIF EQ MMG$T .DRPTR .IIF NE MMG$T .DRPTR FETCH=*NO* .DREST CLASS=DVC.DK .IIF NDF EIS$I EIS$I = MMG$T .IIF EQ EIS$I .MCALL SOB CS$INT =: 100 CS$BRK =: 1 DDCNT =: 8. DDNREG =: 10. R$$NOP =: 0 R$$INT =: 1 R$$RED =: 2 R$$WRT =: 3 R$$POS =: 5 R$$END =: 100 R$CONT =: 20 R$INIT =: 4 R$DATA =: 1 R$MSG =: 2 R$MSIZ =: 10. R$DSIZ =: 128. KISAR1 =: 172342 SYSPTR =: 54 CONFG2 =: 370 PROS$ =: 020000 SYSCHN =: 17 .READ =: 375 .WRITE =: 375 ..READ =: 010 ..WRIT =: 011 .SBTTL INSTALLATION CODE .ASECT .IF NE DDT$O .DRINS DD, .IFF .DRINS DD .ENDC BR 1$ .ASSUME . EQ INSSYS BR 15$ 1$: MOV @#SYSPTR,R0 BIT #PROS$,CONFG2(R0) BNE 2$ 15$: TST (PC)+ 2$: SEC RETURN BAREA: .BYTE SYSCHN,..READ .BLKW .BLKW .WORD 256. .WORD 0 O.RTR1: CMP R0,R3 BHI O.BAD MOV R0,DRETRY BEQ O.BAD BR O.GOOD O.SYWL: MOV @SP,R0 INC R0 CMPB #BR/400,(R0)+ BNE O.BAD MOV R0,@SP BR O.BAD .ASSUME . LE 400,MESSAGE=<;Install area too big> .SBTTL SET OPTIONS .DRSET CSR, 160000, O.CSR, OCT .DRSET VECTOR, 500, O.VEC, OCT .IF NE DDT$O .DRSET CSR2, 160000, O.CSR2, OCT .DRSET VEC2, 500, O.VEC2, OCT .ENDC .DRSET RETRY, 127., O.RTRY, NUM .IF NE ERL$G .DRSET SUCCES, -1, O.SUCC, NO .ENDC BTCSR = + + 1000 O.RTRY: BR O.RTR1 O.CSR: CMP R0,R3 BLO O.BAD MOV R0,INSCSR MOV R0,DISCSR .ADDR #BAREA+4,R1 .ADDR #1000,R2 MOV R2,(R1) MOV #BTCSR/1000,-(R1) TST -(R1) MOV R0,R3 MOV R1,R0 EMT .READ BCS O.BAD MOV R3,(R2) ADD #4,(R2) MOV R1,R0 .ASSUME ..READ+1 EQ ..WRIT INCB 1(R0) EMT .WRITE BCS O.SYWL MOV R1,R0 .ASSUME ..WRIT-1 EQ ..READ DECB 1(R0) MOV #1,2(R0) EMT .READ BCS O.BAD .IF NE DDT$O MOV R3,SET$L1+2 .ENDC .ADDR #TICSRA,R1 MOV #2,R0 MOV R3,(R1)+ ADD R0,R3 MOV R3,(R1)+ ADD R0,R3 MOV R3,(R1)+ ADD R0,R3 MOV R3,@R1 O.GOOD: TST (PC)+ O.BAD: SEC RETURN O.VEC: CMP R0,R3 BHIS O.BAD BIT #3,R0 BNE O.BAD MOV R0,VECTAB TST (R0)+ .IF NE DDT$O MOV R0,SET$L2+2 .ENDC .ADDR #TIVECA,R1 MOV R0,(R1)+ TST (R0)+ MOV R0,VECTAB+6 TST (R0)+ MOV R0,@R1 RETURN .IF NE DDT$O O.CSR2: CMP R0,R3 BLO O.BAD MOV R0,SET$L3+2 MOV R0,DISCS2 RETURN O.VEC2: CMP R0,R3 BHIS O.BAD BIT #3,R0 BNE O.BAD MOV R0,VECTAB+14 TST (R0)+ MOV R0,SET$L4+2 TST (R0)+ MOV R0,VECTAB+22 BR O.GOOD .ENDC .IF NE ERL$G O.SUCC: MOV #0,R3 N.SUCC: MOV R3,SCSFLG .ASSUME O.SUCC+4 EQ N.SUCC BR O.GOOD .ENDC .Assume . LE 1000,MESSAGE=<;SET area too big> .SBTTL START I/O ENTRY .DRBEG DD CALL STARIO ERR1: MOV DDCQE,R4 .ASSUME Q$BLKN-2 EQ Q$CSW BIS #HDERR$,@-(R4) BR PDEXIT VECTAB: .DRVTB DD,DD$VEC,DDINT .DRVTB ,DD$VEC+4,DDINT .ASSUME .-DDSTRT LE 1000 .IF NE DDT$O .DRVTB ,DD$VC2,DDINT .DRVTB ,DD$VC2+4,DDINT .ASSUME .-DDSTRT LE 1000 .ENDC .IF NE ERL$G SCSFLG: .WORD 0 .ASSUME .-DDSTRT LE 1000 .ENDC .SBTTL DD VECTOR AND CSR ADDRESS LIST TICSRA: .WORD DD$CSR TIBFRA: .WORD DD$CSR+2 TOCSRA: .WORD DD$CSR+4 TOBFRA: .WORD DD$CSR+6 TIVECA: .WORD DD$VEC+2 TOVECA: .WORD DD$VEC+6 .ASSUME .-DDSTRT LE 1000 .SBTTL INTERRUPT ENTRY .ENABL LSB BR DDABRT DDINT:: BCS 1$ JSR R5,@$INPTR .WORD ^C&^O340 CLR (PC)+ FKFLG: .WORD 0 JMP @I$INTR 1$: MOV R4,-(SP) CALL @I$INTR MOV (SP)+,R4 RTI .DSABL LSB .SBTTL INTERRUPT EXIT INIRTN: BIS #CS$INT,@TICSRA BR INPRTN OUTCHR: MOV R5,@TOBFRA OUTRTN: INPRTN: MOV (SP)+,I$INTR INTRTN: RETURN .SBTTL COMPLETION EXIT COMPLT: BCS ERR1 .IF NE ERL$G TST FKFLG BNE 1$ CALL FORK 1$: TST SCSFLG BNE PDEXIT MOV #DD$COD*400+377,R4 MOV DDCQE,R5 CALL @$ELPTR .ENDC PDEXIT: .DRFIN DD .SBTTL FORK ROUTINE FORK: MOV (SP)+,FKFLG MOV R0,-(SP) MOV R1,-(SP) MOV R2,-(SP) MOV R3,-(SP) MOV FKFLG,-(SP) JSR PC,@(SP)+ MOV (SP)+,R3 MOV (SP)+,R2 MOV (SP)+,R1 MOV (SP)+,R0 RTS PC .SBTTL DDABRT - ABORT ENTRY DDABRT::BIC #1,@TIVECA BIC #1,@TOVECA .MTPS #340 BIC #CS$INT,@TICSRA BIS #CS$INT,@TOCSRA CLR (PC)+ 5$: .BLKW 10$: MOV #R$INIT,R5 CALL OUTCHR DECB 5$ BEQ 15$ TSTB @TICSRA BPL 10$ CALL TXINIT 15$: BR PDEXIT .SBTTL STARIO - START I/O CODE .ENABL LSB STARIO::CLR PK$UNT MOV DDCQE,R3 MOVB Q$UNIT(R3),R0 BIC #^C<7>,R0 ASR R0 .IF EQ DDT$O BNE 10$ .ENDC BCC 1$ INC PK$UNT 1$: .IF NE DDT$O SET$L1: MOV #DD$CSR,R3 SET$L2: MOV #DD$VEC+2,R2 .ASSUME .-DDSTRT LE 1000 ASR R0 BNE 10$ BCC 2$ SET$L3: MOV #DD$CS2,R3 SET$L4: MOV #DD$VC2+2,R2 .ASSUME .-DDSTRT LE 1000 2$: .ADDR #TICSRA,R1 CMP R3,@R1 BEQ 4$ MOV #4,R0 3$: MOV R3,(R1)+ TST (R3)+ SOB R0,3$ MOV R2,(R1)+ CMP (R2)+,(R2)+ MOV R2,@R1 4$: .ENDC DRETRY = .+2 MOV #DDCNT,I$ERCT .ASSUME .-DDSTRT LE 1000 CLR RETIO TST I$ABRT BNE RETRY .ADDR #ABORT,R1 BR GO RETRY: MOV DDCQE,R3 TST RETIO BEQ 7$ ADD #Q$WCNT,R3 MOV @R3,R1 BPL 5$ NEG R1 5$: ASL R1 SUB I$BYTC,R1 ROR R1 CLRB R1 MOV R1,R2 TST @R3 BPL 6$ NEG R1 6$: SUB R1,@R3 .IF EQ MMG$T .ASSUME Q$WCNT-2 EQ Q$BUFF ADD R2,-(R3) ADD R2,@R3 .ASSUME Q$BUFF-2 EQ Q$FUNC TST -(R3) .IFF MOV R2,R1 ASHC #-5,R1 ADD R1,Q$PAR-Q$WCNT(R3) .ASSUME Q$WCNT-4 EQ Q$FUNC CMP -(R3),-(R3) .ENDC SWAB R2 .ASSUME Q$FUNC-2 EQ Q$BLKN ADD R2,-(R3) 7$: MOV #R$$RED,PK$OPC CLRB PK$SSQ CLR PK$SSQ+1 MOV Q$WCNT(R3),R1 BPL 8$ MOVB #R$$WRT,PK$OPC NEG R1 8$: ASL R1 BNE 9$ MOVB #R$$POS,PK$OPC 9$: MOV Q$BUFF(R3),I$ADRS .IF NE MMG$T MOV Q$PAR(R3),I$PAR .ENDC MOV R1,I$BYTC MOV R1,PK$BCT MOV @R3,PK$RCD .ADDR #TXGO,R1 GO: MOV R1,I$INTR BIS #CS$INT,@TOCSRA TST (SP)+ 10$: RETURN .DSABL LSB .SBTTL TXGO - START TRANSFER FROM INTERRUPT LEVEL TXGO: CALL FORK MOV #R$MSG,PK$FLG MOV #R$MSIZ,R2 .ADDR #PK$OPC,R1 CALL SNDPKT 1$: CMPB PK$OPC,#R$$WRT BNE 2$ JSR R5,RCVPKT .WORD R$CONT 2$: MOV I$ADRS,R1 MOV I$BYTC,R2 BEQ TXEND CMP R2,#R$DSIZ BLOS 3$ MOV #R$DSIZ,R2 3$: CMPB PK$OPC,#R$$WRT BNE 4$ MOVB #R$DATA,PK$FLG CALL SNDPKT CMP I$BYTC,#R$DSIZ BLOS TXEND JSR R5,RCVPKT .WORD R$CONT BR 5$ 4$: JSR R5,RCVPKT .WORD R$DATA 5$: .IF EQ MMG$T ADD #R$DSIZ,I$ADRS .IFF ADD #2,I$PAR .ENDC SUB #R$DSIZ,I$BYTC BHI 2$ CLR I$BYTC .SBTTL TXEND - READ THE END PACKET AFTER A TRANSFER TXEND: .ADDR #I$MBFR,R1 MOV #R$MSIZ,R2 JSR R5,RCVPKT .WORD R$MSG .SBTTL ERROR - ANALYZE AN END PACKET ERROR: CMPB PK$FLG,#R$MSG BNE ABORTR CMPB I$MOPC,#R$$END BNE ABORTR TSTB I$MSUC .IF EQ ERL$G BPL CPLRTN .IFF BEQ CPLRTN BLT FATAL MOV I$ERCT,R2 CALL LOGERR BR CPLRTN .ENDC FATAL: TST FKFLG BNE 1$ CALL FORK .IF NE ERL$G CLR R2 CALL LOGERR .ENDC 1$: SEC CPLRTN: BIC R4,R4 BIC #CS$INT,@TICSRA BIC #CS$INT,@TOCSRA JMP COMPLT .SBTTL ABORT - COMMUNICATIONS ERROR ABORTR: MOV SP,(PC)+ RETIO: .WORD 0 ABORT: CALL TXINIT CLR I$ABRT TST I$ERCT BLE FATAL INC I$ABRT MOV R3,-(SP) MOV R2,-(SP) MOV R1,-(SP) MOV R0,-(SP) CALL 9$ MOV (SP)+,R0 MOV (SP)+,R1 MOV (SP)+,R2 MOV (SP)+,R3 RETURN 9$: CALL RETRY TST (SP)+ MOV (SP)+,R0 MOV (SP)+,R1 MOV (SP)+,R2 MOV (SP)+,R3 BR FATAL .IF NE ERL$G .SBTTL LOGERR - SET UP AND CALL ERROR LOGGER LOGERR: MOV R2,R4 BIS #DD$COD*400,R4 MOV DRETRY,R3 SWAB R3 ADD #DDNREG,R3 .ADDR #I$LCHR,R2 MOV DDCQE,R5 CALL @$ELPTR CLR I$LCHR RETURN .ENDC .SBTTL TXINIT - INIT THE TU58 TXINIT: BIC #CS$INT,@TOCSRA BIC #CS$INT,@TICSRA MOV (SP)+,I$SUBR 1$: .IF NE ERL$G TST I$ABRT BEQ 2$ TST FKFLG BNE 3$ CALL FORK 3$: MOV I$ERCT,R2 CALL LOGERR 2$: .ENDC .MTPS #340 MOV #177777,@TOBFRA BIS #,@TOCSRA CALL OUTRTN MOV #177777,R5 CALL OUTCHR BIC #CS$BRK,@TOCSRA MOV #R$INIT,R5 CALL OUTCHR MOV #R$INIT,R5 CALL OUTCHR BIC #CS$INT,@TOCSRA TST @TIBFRA CALL INIRTN MOV @TIBFRA,PK$FLG BIC #CS$INT,@TICSRA DEC I$ERCT BLE 9$ CMPB PK$FLG,#R$CONT BNE 1$ 9$: CALLR @I$SUBR .SBTTL SNDPKT - SEND RADIAL SERIAL PACKET SNDPKT: MOV (SP)+,I$SUBR MOV R1,I$MADR MOVB R2,PK$MBC MOV PK$FLG,PK$CKS .MTPS #340 MOVB PK$FLG,@TOBFRA BIS #CS$INT,@TOCSRA CALL OUTRTN MOVB PK$MBC,R5 CLRB I$TDAT+1 BIS #1,@TOVECA CALL OUTCHR 2$: .IF NE MMG$T MOV @#KISAR1,-(SP) MOV I$PAR,@#KISAR1 .ENDC MOVB @I$MADR,@TOBFRA MOVB @I$MADR,I$TDAT .IF NE MMG$T MOV (SP)+,@#KISAR1 .ENDC INC I$MADR ADD I$TDAT,PK$CKS ADC PK$CKS SWAB PK$CKS DECB PK$MBC BEQ 3$ RETURN 3$: BIC #1,@TOVECA ADD #4$-2$,I$INTR RETURN 4$: MOVB PK$CKS,R5 CALL OUTCHR MOVB PK$CKS+1,R5 CALL OUTCHR BIC #CS$INT,@TOCSRA PKTRTN: CALL FORK CALLR @I$SUBR .SBTTL RCVPKT - RECEIVE A RADIAL SERIAL PACKET RCVPKT: MOV (R5)+,I$EFLG MOV R5,I$SUBR MOV (SP)+,R5 MOV R1,I$MADR .MTPS #340 CALL INIRTN MOV @TIBFRA,R4 BMI 6$ MOVB R4,PK$FLG CMPB R4,I$EFLG BEQ 2$ CMPB R4,#R$MSG BNE 6$ .ADDR #I$MBFR,-(SP) MOV (SP)+,I$MADR 2$: CMPB R4,#R$CONT BEQ PKTRTN BIS #1,@TIVECA CALL INPRTN 1$: MOV @TIBFRA,R4 BMI 8$ MOVB R4,PK$MBC MOV PK$FLG,PK$CKS ADD #4$-1$,I$INTR 3$: RETURN 4$: MOV @TIBFRA,R4 BMI 8$ .IF NE MMG$T MOV @#KISAR1,-(SP) MOV I$PAR,@#KISAR1 .ENDC MOVB R4,@I$MADR .IF NE MMG$T MOV (SP)+,@#KISAR1 .ENDC INC I$MADR BIC #^C<377>,R4 ADD PK$CKS,R4 ADC R4 SWAB R4 MOV R4,PK$CKS DECB PK$MBC BNE 3$ BIC #1,@TIVECA ADD #7$-4$,I$INTR RETURN 7$: MOV @TIBFRA,R4 BMI 6$ MOVB R4,I$TDAT CALL INPRTN MOV @TIBFRA,R4 BMI 6$ MOVB R4,I$TDAT+1 BIC #CS$INT,@TICSRA CMP I$TDAT,PK$CKS BNE 5$ CMPB PK$FLG,I$EFLG BEQ PKTRTN JMP ERROR 6$: .IF NE ERL$G MOV R4,I$LCHR .ENDC 5$: JMP ABORTR 8$: .IF NE ERL$G MOV R4,I$LCHR .ENDC BIC #1,@TIVECA .ADDR #ABORTR,-(SP) MOV (SP)+,I$INTR RETURN .SBTTL DATA AREA I$ABRT: .WORD 0 I$ADRS: .WORD 0 I$BYTC: .WORD 0 I$INTR: .WORD 0 I$ERCT: .WORD 0 I$MADR: .WORD 0 I$TDAT: .WORD 0 I$SUBR: .WORD 0 .IF NE ERL$G I$LCHR: .WORD 0 .ENDC I$EFLG: .WORD 0 I$MBFR: I$MOPC: .BYTE 0 I$MSUC: .BYTE 0 .BYTE 0,0,0,0,0,0,0,0 .IF NE MMG$T I$PAR: .WORD 0 .ENDC PK$FLG: .BYTE 0 PK$MBC: .BYTE 0 PK$OPC: .BYTE 0 PK$MOD: .BYTE 0 PK$UNT: .BYTE 0 PK$SSQ: .BYTE 0,0,0 PK$BCT: .BYTE 0,0 PK$RCD: .BYTE 0,0 PK$CKS: .BYTE 0,0 .SBTTL BOOTSTRAP READ ROUTINE .DRBOT DD,BOOT1,READ . = DDBOOT+40 BOOT1: JMP @#BOOT-DDBOOT . = DDBOOT+210 READ: MOV #DDCNT,RTRCNT MOV @#B$DEVU,DDUNIT ASL R1 MOV R0,DDBLK MOV R1,DDBTCT BRESTR: MOV R2,-(SP) MOV (PC)+,R0 BOTCSR: .WORD DD$CSR+4 BIS #CS$BRK,@R0 MOV (PC)+,R3 .WORD 177777 CALL BCHROS CONRD1: TSTB @R0 BPL CONRD1 BIC #CS$BRK,@R0 MOV (PC)+,R3 .BYTE R$INIT,R$INIT CALL BCHROS TST -2(R0) CALL BICHR CMPB R3,#R$CONT BNE BFATAL MOV #B$CHK-DDBOOT,R4 CLR @R4 MOV #B$PKT-DDBOOT,R5 1$: MOV (R5)+,R3 ADD R3,@R4 ADC @R4 CALL BCHROS CMP R5,R4 BLOS 1$ BRDPKT: CALL BICHP2 MOVB R3,R4 RORB R4 MOV R1,-(SP) CMPB R1,#R$DATA BNE BEND 2$: CALL @R5 MOV R1,(R2)+ ADD R1,@SP ADC @SP DECB R4 BGT 2$ CALL (R5) CMP R1,(SP)+ BNE BFATAL BR BRDPKT BEND: CALL (R5) TSTB R3 BMI BOTH 1$: ADD R1,@SP ADC @SP CALL (R5) SOB R4,1$ CMP R1,(SP)+ BNE BFATAL MOV (SP)+,R2 CLC RETURN BOTH: TST (SP)+ BFATAL: MOV (SP)+,R2 DEC RTRCNT BNE BRESTR BR BIOERR .SBTTL BYTE INPUT ROUTINES (BOOT) BICHP2: MOV PC,R5 CLR R1 CALL @PC BICHR: TSTB -4(R0) BPL BICHR MOVB -2(R0),R3 BISB R3,R1 SWAB R1 RETURN .SBTTL BYTE OUTPUT ROUTINES (BOOT) BCHROS: CALL @PC 1$: TSTB @R0 BPL 1$ MOVB R3,2(R0) SWAB R3 RETURN B$PKT: .BYTE R$MSG,R$MSIZ,R$$RED,0 DDUNIT: .WORD 0 .BYTE 0,0 DDBTCT: .WORD 0 DDBLK: .WORD 0 B$CHK: .WORD 0 RTRCNT: .WORD 0 . = DDBOOT+606 BOOT: MOV #10000,SP MOV R0,@#B$DEVU MOV R0,-(SP) MOV #2,R0 MOV #<4*400>,R1 MOV #1000,R2 CALL READ MOV #READ-DDBOOT,@#B$READ MOV #B$DNAM,@#B$DEVN MOV (SP)+,@#B$DEVU JMP @#B$BOOT .DREND DD .END .MCALL .MODULE .MODULE DM,VERSION=15,COMMENT=,AUDIT=YES ; ; COPYRIGHT (c) 1984,1985,1986,1987 BY ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, ; MASSACHUSETTS. ALL RIGHTS RESERVED. ; ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED ; ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE ; INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER ; COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY ; OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY ; TRANSFERRED. ; ; ; THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE ; AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT ; CORPORATION. ; ; ; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS ; SOFTWARE ON EQUIPMENT THAT IS NOT SUPPLIED BY DIGITAL. ; .SBTTL CONDITIONAL ASSEMBLY SUMMARY .SBTTL MACROS AND DEFINITIONS .MCALL .DRDEF, .ASSUME, .BR .ADDR SYSPTR =: 54 CONFG2 =: 370 PROS$ =: 020000 P1EXT =: 432 .READ =: 375 .WRITE =: 375 ..READ =: 010 ..WRIT =: 011 SYSCHN =: 17 .IIF NDF RK6$S, RK6$S=0 RK6$B =: 1 RK6$S =: 1 DMDSI6 =: 410.*3.*22. DMDSI7 =: 814.*3.*22. .DRDEF DM,23,FILST$++VARSZ$,DMDSI6,177440,210 .DRPTR .DREST CLASS=DVC.DK,MOD=DVM.DM,REPLACE=RTABLE .IF NE RK6$B .DRSPF <377> .DRSPF <376> .DRSPF <374> .DRSPF <373> .ENDC; NE RK6$B .IIF NDF EIS$I EIS$I = MMG$T .IIF EQ EIS$I .MCALL SOB RETRY =: 8. SPFUNB =: 100000 SPERR =: 077400 SPHARD =: 000200 SPRCAL =: 000010 SPOFF =: 000004 SPRETY =: 000002 SPECC =: 000001 SPREAD =: 377 SPWRIT =: 376 SPREP =: 374 SPDSIZ =: 373 DMNREG =: 13. DMNRG1 =: 7. DMNRG2 =: 4. RKCS1 =: DM$CSR RKWC =: DM$CSR+2 RKBA =: DM$CSR+4 RKDA =: DM$CSR+6 RKCS2 =: DM$CSR+10 RKDS =: DM$CSR+12 RKER =: DM$CSR+14 RKASOF =: DM$CSR+16 RKDC =: DM$CSR+20 RKECPS =: DM$CSR+30 RKECPT =: DM$CSR+32 CERR =: 100000 DI =: 040000 SPAR =: 020000 CDT =: 002000 CTO =: 004000 RDY =: 000200 IE =: 000100 GO =: 000001 DLT =: 100000 WCE =: 040000 UPE =: 020000 NED =: 010000 NEM =: 004000 PGE =: 002000 MDS =: 001000 UFE =: 000400 SCLR =: 000040 DDT =: 000400 VV =: 000100 DROT =: 000040 DCLO =: 000020 ACLO =: 000010 OFST =: 000004 DCK =: 100000 UNS =: 040000 OPI =: 020000 DTE =: 010000 WLE =: 004000 IDAE =: 002000 COE =: 001000 HVRC =: 000400 BSE =: 000200 ECH =: 000100 DTYE =: 000040 FMTE =: 000020 DRPAR =: 000010 NXF =: 000004 SKI =: 000002 ILF =: 000001 PCKACK =: 2 DRVCLR =: 4 RECAL =: 12 SETOFF =: 14 READAT =: 20 WRITE =: 22 .SBTTL INSTALLATION CODE .DRINS DM BR 10$ .ASSUME . EQ INSSYS BR 20$ 10$: MOV @#SYSPTR,R0 BIT #PROS$,CONFG2(R0) BNE 30$ 20$: TST (PC)+ 30$: SEC RETURN O.SYWL: MOV @SP,R0 INC R0 CMPB #BR/400,(R0)+ BNE O.BAD MOV R0,@SP BR O.BAD RTABLE: .BYTE 1,44.,5.,3.,22.,0 .Assume . LE 400,MESSAGE=<;Install code too big> .SBTTL SET OPTIONS .DRSET CSR, 160000, O.CSR, OCT .DRSET VECTOR, 500, O.VEC, OCT .DRSET RETRY, 127., O.RTRY, NUM .IF NE ERL$G .DRSET SUCCES, -1, O.SUCC, NO .ENDC BTCSR = ++1000 O.CSR: CMP R0,R3 BLO O.BAD MOV R0,INSCSR MOV R0,DISCSR .ADDR #BAREA+4,R1 .ADDR #1000,R2 MOV R2,(R1) MOV #BTCSR/1000,-(R1) TST -(R1) MOV R0,R3 ADD #RKCS2-RKCS1,R3 MOV R1,R0 EMT .READ BCS O.BAD MOV R3,(R2) MOV R1,R0 .ASSUME ..READ+1 EQ ..WRIT INCB 1(R0) EMT .WRITE BCS O.SYWL MOV R1,R0 .ASSUME ..WRIT-1 EQ ..READ DECB 1(R0) MOV #1,2(R0) EMT .READ BCS O.BAD MOV R3,DMCSR O.GOOD: TST (PC)+ O.BAD: SEC RETURN O.VEC: CMP R0,R3 BHIS O.BAD BIT #3,R0 BNE O.BAD MOV R0,DMSTRT BR O.GOOD O.RTRY: CMP R0,R3 BHI O.BAD MOV R0,DRETRY BNE O.GOOD BR O.BAD BAREA: .BYTE SYSCHN,..READ .BLKW .BLKW .WORD 256. .WORD 0 .IF NE ERL$G O.SUCC: MOV #0,R3 N.SUCC: MOV R3,SCSFLG .ASSUME O.SUCC+4 EQ N.SUCC BR O.GOOD .ENDC .Assume . LE 1000,MESSAGE=<;Set code too big> .SBTTL DRIVER ENTRY .DRBEG DM .ENABL LSB .IF NE MMG$T MOV @#SYSPTR,R5 MOV P1EXT(R5),(PC)+ $P1EXT: .BLKW 1 .ENDC DMBEGN: MOV DMCQE,R5 CMPB Q$FUNC(R5),#SPDSIZ BLT DMEXIJ CMPB Q$FUNC(R5),#SPREP+1 BEQ DMEXIJ MOV (PC)+,R4 DMCSR: .WORD RKCS2 .Assume . LE DMSTRT+1000,MESSAGE=<;Set code object not in block 1> MOVB Q$UNIT(R5),R0 BIC #^C<7>,R0 MOV R0,(R4) MOV #GO,RKCS1-RKCS2(R4) 1$: BIT #RDY!CERR,RKCS1-RKCS2(R4) BEQ 1$ MOV RKDS-RKCS2(R4),R1 BIC #^C,R1 ASL R1 ASL R1 MOV #DMDSIZ,R2 MOV R1,(PC)+ DMTYPE: .WORD 0 BEQ 2$ MOV #DMDSI7,R2 2$: MOV #CERR,RKCS1-RKCS2(R4) MOV R0,(R4) MOV R1,RKCS1-RKCS2(R4) BIS #DRVCLR!GO,RKCS1-RKCS2(R4) 3$: BIT #RDY!CERR,RKCS1-RKCS2(R4) BEQ 3$ TST RKCS1-RKCS2(R4) .ASSUME CERR EQ 100000 BPL 4$ ADD #RKCS1-RKCS2,R4 JMP DMHERR 4$: CMPB Q$FUNC(R5),#SPDSIZ BNE 5$ MOV R2,SPFUN .IF NE RK6$B .IF NE MMG$T MOV Q$PAR(R5),SPPAR .ENDC;NE MMG$T .ENDC;NE RK6$B MOV Q$BUFF(R5),SPBUFA MOV #SCLR,(R4) JMP DMSPEX 5$: .IF NE RK6$B CLR (PC)+ BADBLK: .BYTE 0 .BYTE 0 CMPB Q$FUNC(R5),#SPREP BEQ 6$ BR 7$ BLK1RD: INCB BADBLK 6$: INCB BADBLK .ADDR #BBUF,R3 MOV R3,BADD JSR R3,STBQUE .WORD 64. .WORD 1 .ENDC 7$: MOV #READAT+GO+IE,DMFUNC BIS DMTYPE,DMFUNC .IF NE RK6$B .IF NE MMG$T MOV Q$PAR(R5),(PC)+ SPPAR: .WORD 0 .ENDC;NE MMG$T MOV #SPFUNB,SPFUN CMPB Q$FUNC(R5),#SPWRIT BHI DMSPFA BEQ DMWRIT CLR (PC)+ SPFUN: .WORD 0 .ENDC;NE RK6$B TST Q$WCNT(R5) BNE 8$ DMEXIJ: JMP DMEXIT 8$: BPL 9$ NEG Q$WCNT(R5) BIS #WRITE,DMFUNC 9$: MOV Q$WCNT(R5),R1 ADD #255.,R1 CLRB R1 SWAB R1 ADD (R5),R1 CMP R2,R1 BHIS DMRETY JMP DMHENL DMWRIT: BIS #WRITE,DMFUNC DMSPFA: MOV Q$BUFF(R5),(PC)+ SPBUFA: .WORD 0 ADD #2,Q$BUFF(R5) .IF NE MMG$T CMP Q$BUFF(R5),#40000 BLO DMRETY SUB #20000,Q$BUFF(R5) ADD #200,Q$PAR(R5) .ENDC DMRETY: MOV (PC)+,(PC)+ DRETRY: .WORD RETRY .Assume . LE DMSTRT+1000,MESSAGE=<;Set code object not in block 1> RETCNT: .WORD 0 DMRSET: CALL DMROFF .DSABL LSB DMSET: MOV DMCSR,R4 MOV (R5)+,R3 .ASSUME Q$BLKN+2 EQ Q$FUNC TSTB (R5)+ .ASSUME Q$FUNC+1 EQ Q$UNIT MOVB (R5)+,R0 BIC #^C<7>,R0 4$: BIT #VV,RKDS-RKCS2(R4) BNE 1$ MOV #-1,BADRB1 1$: MOV #SCLR,@R4 MOV R0,@R4 MOV DMTYPE,RKCS1-RKCS2(R4) BIS #PCKACK+GO,RKCS1-RKCS2(R4) MOV R0,(PC)+ DMUNIT: .WORD 0 CMP R0,BADRB1 BEQ 5$ MOV #-1,BADRB1 5$: JSR R0,DIV .WORD 3.*22. MOV R2,R1 JSR R0,DIV .WORD 22. SWAB R2 BISB R3,R2 3$: BIT #CERR!RDY,RKCS1-RKCS2(R4) BEQ 3$ 4$: MOV R1,RKDC-RKCS2(R4) MOV R2,-(R4) .IF EQ MMG$T BUSADD: MOV (R5)+,-(R4) .IFF .IF NE RK6$B BUSADD: TSTB BADBLK BEQ 1$ MOV (R5)+,-(R4) BR 2$ .ENDC 1$: CALL @$MPPTR MOV (SP)+,-(R4) ASL (SP) ASL (SP) ASL (SP) ASL (SP) BIC #1400,DMFUNC BIS (SP),DMFUNC BIT #36000,(SP)+ BEQ 2$ MOV DMCQE,R5 JMP DMHENL .ENDC .ASSUME Q$BUFF+2 EQ Q$WCNT 2$: MOV (R5)+,-(R4) NEG @R4 BEQ DMDONJ MOV (PC)+,-(R4) DMFUNC: .WORD 0 DMWAIT: RETURN DMDONJ: JMP DMDONE .IF NE ERL$G SCSFLG: .WORD 0 .Assume . LE DMSTRT+1000,MESSAGE=<;Set code object not in block 1> .ENDC .SBTTL INTERRUPT SERVICE ENTRY .ENABL LSB .DRAST DM,5 MOV DMCQE,R5 TST BADBLK BEQ 3$ MOV SAVCQE,R5 3$: MOV DMCSR,R4 ADD #RKCS1-RKCS2,R4 BIT #READAT&WRITE,@R4 BNE DMRDWR .FORK DMFBLK BIT #CERR!DI,@R4 BEQ DMWAIT DMSETP: BPL DMST1 DMCERR: CLR R1 RECHK: BIC #^C,R1 NEG R1 DECB RETCNT BLE DMHERJ .IF NE RK6$S BIS #SPRETY,SPFUN .ENDC BCS 2$ DMST1: JMP DMSET 2$: MOV #SCLR,@DMCSR MOV DMUNIT,@DMCSR .IF NE RK6$S BIS #SPRCAL,SPFUN .ENDC MOV DMTYPE,@R4 BIS #IE!RECAL!GO,@R4 CALL DMROFF BR DMWAIT .DSABL LSB DMRDWR: TST @R4 .IF NE ERL$G BMI 1$ .FORK DMFBLK BR DMDONJ .IFF BPL DMDONJ .ENDC 1$: .FORK DMFBLK MOV DMCSR,R3 MOV RKER-RKCS1(R4),R1 .IF NE RK6$B TST SPFUN BEQ USERR BIT #BSE,R1 BEQ USERR BIS #SPHARD,SPFUN BR DMHENJ .ENDC USERR: BIT #WLE!COE,R1 BNE DMHERJ BIT #NED!NEM,(R3) BEQ HARDCK DMHERJ: JMP DMHERR HARDCK: BIT #NXF!ILF,R1 BEQ USERR1 DMHENJ: JMP DMHENL USERR1: BIT #PGE,@R3 BNE DMHENJ .IF NE ERL$G BIT #BSE,R1 BNE LOGERE CALL LOGERR LOGERE: .ENDC BIT #UNS+DTYE+FMTE,R1 BNE DMHERJ TST @R3 BMI SUBDIV BIT #BSE!DCK!OPI!HVRC!ECH!SKI,R1 BEQ DMCERR .ENABL LSB SUBDIV: MOV RKWC-RKCS1(R4),R0 ADD Q$WCNT(R5),R0 MOV R0,R2 BEQ BSECON BIT #BSE!HVRC!OPI!SKI,R1 BNE 2$ DEC R0 2$: BIC #377,R0 TST R1 BPL BSECON BIT #ECH,R1 BNE BSECON MOV R2,-(SP) CALL ECC .IF NE RK6$S BIS #SPECC,SPFUN .ENDC MOV (SP)+,R0 CLR R1 BSECON: SUB R0,Q$WCNT(R5) BEQ DMDONE .IF EQ MMG$T ADD R0,Q$BUFF(R5) ADD R0,Q$BUFF(R5) .ENDC SWAB R0 .ASSUME Q$BLKN EQ 0 ADD R0,@R5 .IF NE MMG$T ASL R0 ASL R0 ASL R0 ADD R0,Q$PAR(R5) .ENDC .IF NE RK6$B BIT #BSE!HVRC,R1 BEQ NOBSE TST (PC)+ BADRB1: .WORD -1 BPL 3$ MOV DMFUNC,SAVFUN JMP BLK1RD BADCON: MOV SAVFUN,DMFUNC 3$: .ADDR #BBUF,R2 5$: TST (R2) BEQ NOBSE .ASSUME Q$BLKN EQ 0 CMP (R5),(R2)+ BEQ 6$ TST (R2)+ BR 5$ 6$: MOV (R2),NEWBLK MOV Q$BUFF(R5),BADD .IF NE MMG$T MOV Q$PAR(R5),BPAR .ENDC MOV Q$WCNT(R5),NEWWC CMP Q$WCNT(R5),#256. BLOS 10$ MOV #256.,NEWWC 10$: JSR R3,STBQUE NEWWC: .WORD 256. NEWBLK: .WORD 0 INCB BADBLK+1 DMRSEJ: JMP DMRSET .ENDC .DSABL LSB NOBSE: TST R0 BNE DMRSEJ BIT #HVRC!ECH,R1 BEQ RECHKJ DECB OFFCNT BGT DMSETJ ADD #2,OFFPTR MOV @OFFPTR,R0 MOVB R0,OFFCNT BMI DMHERR .IF NE RK6$S BIS #SPOFF,SPFUN .ENDC CLRB R0 SWAB R0 MOV #SCLR,@R3 MOV DMUNIT,@R3 MOV R0,RKASOF-RKCS1(R4) MOV DMTYPE,@R4 BIS #IE!SETOFF!GO,@R4 RETURN RECHKJ: JMP RECHK DMSETJ: JMP DMSET DMHERR: .IF NE ERL$G CALL LOGERR .ENDC .ASSUME Q$CSW EQ -2 DMHENL: BIS #HDERR$,@-(R5) BIS #CERR,@R4 .IF NE RK6$S BIS #SPERR,SPFUN .ENDC BR DMRRST DMDONE: .IF NE RK6$B TST BADBLK BEQ DMCOMP .IF EQ ERL$G .FORK DMFBLK .ENDC MOV DMCQE,R5 CMP BADBLK,#2 BLO DMCOMP BHI 1$ CLR BADBLK MOV DMUNIT,BADRB1 JMP BADCON 1$: CLR BADBLK MOV NEWWC,R0 CLR R1 JMP BSECON .ENDC DMCOMP: .IF NE ERL$G BIT #,DMFUNC BEQ DMEL3 NEG Q$WCNT(R5) DMEL3: TST SCSFLG BNE DMRRST MOV #DM$COD*400+377,R4 MOV DMCQE,R5 CALL @$ELPTR MOV DMCSR,R4 ADD #RKCS1-RKCS2,R4 .ENDC DMRRST: CLR @R4 .IF NE RK6$B TST SPFUN BPL DMEXIT DMSPEX: MOV SPBUFA,R5 .IF NE MMG$T MOV DMCQE,R4 MOV R5,Q$BUFF(R4) MOV SPPAR,Q$PAR(R4) MOV SPFUN,-(SP) CALL @$PTWRD .IFF MOV SPFUN,(R5) .ENDC .ENDC DMEXIT: .DRFIN DM DMROFF: CLR (PC)+ OFFCNT: .WORD 0 .ADDR #OFFTAB-2,-(SP) MOV (SP)+,(PC)+ OFFPTR: .WORD 0 RETURN DIV: MOV R3,R2 CLR R3 MOV #16.,-(SP) 1$: ASL R2 ROL R3 CMP @R0,R3 BHI 2$ SUB @R0,R3 INC R2 2$: DEC @SP BNE 1$ CMP (SP)+,(R0)+ RTS R0 ECC: MOV RKECPS-RKCS1(R4),R2 DEC R2 MOV R2,-(SP) BIC #17,@SP BIC @SP,R2 ASR @SP ASR @SP ASR @SP ASR @SP ADD (SP)+,R0 MOV RKECPT-RKCS1(R4),R3 CLR R1 BR 2$ 1$: ASL R3 ROL R1 2$: DEC R2 BGE 1$ CALL @PC CMP R0,Q$WCNT(R5) BHIS ECCDON MOV R0,R2 .IF NE MMG$T ASH #-6+1,R2 ADD Q$PAR(R5),R2 MOV R2,3$ MOV R0,R2 BIC #^C<37>,R2 .ENDC ASL R2 ADD Q$BUFF(R5),R2 .IF NE MMG$T JSR R0,@$P1EXT .WORD 3$-. .ENDC MOV @R2,-(SP) BIC R3,@R2 BIC (SP)+,R3 BIS R3,@R2 .IF NE MMG$T 3$: .WORD 0 .ENDC MOV R1,R3 INC R0 ECCDON: RETURN .IF NE ERL$G .SBTTL LOGERR - REPORTS TO ERROR LOGGER LOGERR: .ADDR #DMRBUF,R1 MOV R1,R2 MOV DMCSR,R3 ADD #RKCS1-RKCS2,R3 MOV #DMNRG1,R4 DMRREG: MOV (R3)+,(R1)+ SOB R4,DMRREG MOV (R3)+,-(SP) BIT #OFST,-6(R3) BEQ 1$ MOV @OFFPTR,@SP CLRB @SP SWAB @SP 1$: MOV (SP)+,(R1)+ MOV (R3)+,(R1)+ MOV #DMNRG2,R4 ADD #6,R3 DMRRG1: MOV (R3)+,(R1)+ DEC R4 BNE DMRRG1 MOV DRETRY,R3 SWAB R3 ADD #DMNREG,R3 MOVB RETCNT,R4 ADD #DM$COD*400,R4 BIT #,DMFUNC BEQ DMEL1 NEG Q$WCNT(R5) DMEL1: CALL @$ELPTR BIT #,DMFUNC BEQ DMEL2 NEG Q$WCNT(R5) DMEL2: MOV DMCSR,R3 MOV R3,R4 ADD #RKCS1-RKCS2,R4 MOV RKER-RKCS1(R4),R1 RETURN .ENDC .IF NE RK6$B BQUE: .WORD -1 BBLK: .WORD -1 .BYTE 0 BUNT: .BYTE -1 BADD: .WORD -1 BWCT: .WORD -1 .IF NE MMG$T .WORD 0 BPAR: .WORD -1 .WORD 0,0 .ENDC BBUF: .WORD 0 .BLKW 63. .WORD 0 STBQUE: .ADDR #BWCT,R2 MOV (R3)+,(R2) TST -(R2) MOVB Q$UNIT(R5),-(R2) TSTB -(R2) MOV (R3)+,-(R2) .ASSUME Q$BLKN-2 EQ Q$CSW MOV -(R5),-2(R2) MOV R2,(PC)+ SAVCQE: .WORD 0 MOV R2,R5 RTS R3 SAVFUN: .WORD 0 .ENDC .WORD -1 OFFTAB: .BYTE 16, 0 .BYTE 2, 20 .BYTE 2, 220 .BYTE 2, 40 .BYTE 2, 240 .BYTE 2, 60 .BYTE 2, 260 .BYTE 0, 0 .WORD -1 DMFBLK: .WORD 0,0,0,0 ECCBAD: .WORD 0 .IF NE ERL$G DMRBUF: .BLKW DMNREG .ENDC .SBTTL BOOTSTRAP DRIVER .DRBOT DM,BOOT1,READ . = DMBOOT+40 BOOT1: JMP @#BOOT-DMBOOT . = DMBOOT+210 READ: MOV #<3.*22.>,R3 MOV #-1,R4 MOV R4,R5 1$: INC R4 SUB R3,R0 BCC 1$ ADD R3,R0 MOV #22.,R3 2$: INC R5 SUB R3,R0 BCC 2$ ADD R3,R0 SWAB R5 BIS R5,R0 MOV BOTCSR,R5 BIT #400,RKDS-RKCS2(R5) BEQ 3$ BIS #2000,RDFCN 3$: MOV R4,RKDC-RKCS2(R5) MOV R0,-(R5) MOV R2,-(R5) MOV R1,-(R5) NEG @R5 MOV (PC)+,-(R5) RDFCN: .WORD 21 4$: BIT #100200,@R5 BEQ 4$ BMI BIOERR CLC RETURN . = DMBOOT+604 BOOT: MOV #10000,SP MOV @(PC)+,-(SP) BOTCSR: .WORD RKCS2 BIC #^C7,@SP MOV #2,R0 MOV #<4*400>,R1 MOV #1000,R2 CALL READ MOV #READ-DMBOOT,@#B$READ MOV #B$DNAM,@#B$DEVN MOV (SP)+,@#B$DEVU JMP @#B$BOOT .DREND DM .END .MCALL .MODULE .MODULE DP,VERSION=08,COMMENT=,AUDIT=YES ; COPYRIGHT (c) 1984,1985,1986 BY ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. ; ALL RIGHTS RESERVED. ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED ; ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE ; INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER ; COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY ; OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY ; TRANSFERRED. ; ; THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE ; AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT ; CORPORATION. ; ; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS ; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL. .SBTTL CONDITIONAL ASSEMBLY SUMMARY .SBTTL MACROS AND DEFINITIONS .MCALL .DRDEF .ADDR .ASSUME .IIF NDF RP0$3, RP0$3 == 0 .DRDEF DP,21,FILST$,40000.,176710,254 .DRPTR .DREST CLASS=DVC.DK .IIF NDF EIS$I EIS$I=MMG$T .IIF EQ EIS$I .MCALL SOB RPCNT =: 10. RPNREG =: 12. RPDS =: DP$CSR RPER =: RPDS+2 RPCS =: RPDS+4 RPWC =: RPDS+6 RPBA =: RPDS+10 RPCA =: RPDS+12 RPDA =: RPDS+14 RPM1 =: RPDS+16 RPM2 =: RPDS+20 RPM3 =: RPDS+22 SUCA =: RPDS+24 SILO =: RPDS+26 CS.GO =: 1 CS.WRT =: 2 CS.RD =: 4 CS.WTC =: 6 CS.SEK =: 10 CS.WTN =: 12 CS.HOM =: 14 CS.RDN =: 16 CS.MEM =: 60 CS.INT =: 100 CS.RDY =: 200 CS.DRV =: 3400 CS.HDR =: 4000 CS.MOD =: 10000 CS.AIE =: 20000 CS.HER =: 40000 CS.ERR =: 100000 DS.ATT =: 377 DS.WTP =: 400 DS.FUS =: 1000 DS.SUW =: 2000 DS.SIN =: 4000 DS.HNF =: 10000 DS.RP3 =: 20000 DS.ONL =: 40000 DS.RDY =: 100000 SYSPTR =: 54 CONFG2 =: 370 PROS$ =: 020000 .SBTTL INSTALLATION CODE .DRINS DP BR 10$ .ASSUME . EQ INSSYS BR 20$ 10$: MOV @#SYSPTR,R0 BIT #PROS$,CONFG2(R0) BNE 30$ 20$: TST (PC)+ 30$: SEC RETURN .Assume . LE 400,MESSAGE=<;Install area too big> .SBTTL DRIVER ENTRY .DRBEG DP MOV #RPCNT,(PC)+ RPTRY: .WORD 0 RPAGN: CLR @#RPCS MOV #400,@#RPCS CLR @#RPCS MOV #400,@#RPCS MOV @DPCQE,R5 CMP #DPDSIZ,R5 BLOS RPERRJ JSR R1,DIV .WORD 10. MOV R2,R4 MOV R3,R5 JSR R1,DIV .WORD 20. SWAB R2 BIS R2,R4 MOV DPCQE,R5 TST (R5)+ .ASSUME Q$BLKN+2 EQ Q$UNIT-1 MOV (R5)+,-(SP) .ASSUME Q$UNIT-1+2 EQ Q$BUFF BIT #4*400,@SP RP23: .IF EQ RP0$3 BR L1 .IFF BEQ L1 .ENDC ADD #200.,R3 BIC #4*400,@SP L1: BIC #174377,@SP CMP R3,#202. BLE L5 BIC #3400,@#RPCS BIS (SP),@#RPCS BIT #DS.RP3,@#RPDS BNE L5 ADD #6,SP RPERRJ: BR RPERR L5: MOV #RPDA,R2 MOV R4,@R2 MOV R3,-(R2) .IF EQ MMG$T MOV (R5)+,-(R2) .IFF JSR PC,@$MPPTR MOV (SP)+,-(R2) MOV (SP)+,R1 BIT #1700,R1 BNE RPERR .ENDC MOV #CS.INT+CS.WRT+CS.GO,R3 .ASSUME Q$BUFF+2 EQ Q$WCNT MOV @R5,-(R2) BEQ 3$ BMI 2$ NEG @R2 ADD #CS.RD-CS.WRT,R3 2$: BIS (SP)+,R3 .IF NE MMG$T BIS R1,R3 .ENDC MOV R3,-(R2) RETURN 3$: ADD #CS.SEK-CS.WRT,R3 BR 2$ .SBTTL INTERRUPT SERVICE ENTRY POINT .DRAST DP,5,RPABRT MOV #RPCS,R4 BIC #CS.AIE+CS.INT,@R4 MOVB #DS.ATT,-4(R4) CLRB -4(R4) TSTB RPTRY+1 BGT RPHOME TST @R4 BPL RPDONE .IF NE ERL$G BIT #136006,@#RPER BNE RPERR .ENDC DECB RPTRY BGT RPFORK TSTB RPTRY+1 BMI RPERR INCB RPTRY+1 BIS #CS.AIE,@R4 MOVB #CS.HOM+CS.INT+CS.GO,@R4 RTS PC RPHOME: TST @R4 BMI RPERR MOV #177412,RPTRY RPFORK: .FORK DPFBLK .IF NE ERL$G CALL RPERLG CALL @$ELPTR .ENDC JMP RPAGN RPERR: MOV DPCQE,R4 .ASSUME Q$BLKN-2 EQ Q$CSW BIS #HDERR$,@-(R4) RPABRT: MOV #1,@#RPCS CLR DPFBLK+2 .IF NE ERL$G TSTB RPTRY BNE RPEXIT CALL RPERLG BR RPLOG RPDONE: MOV #DP$COD*400+377,R4 RPLOG: MOV DPCQE,R5 .FORK DPFBLK CALL @$ELPTR .IFF RPDONE: .ENDC RPEXIT: .DRFIN DP DPFBLK: .WORD 0,0,0,0 .IF NE ERL$G RPRBUF: .BLKW RPNREG .ENDC .IF NE ERL$G RPERLG: .ADDR #RPRBUF,R5 MOV R5,R2 MOV #DP$CSR,R3 MOV #RPNREG,R4 RPRREG: MOV (R3)+,(R5)+ SOB R4,RPRREG MOV #RPNREG,R3 ADD #RPCNT*400,R3 MOV DPCQE,R5 MOVB RPTRY,R4 ADD #DP$COD*400,R4 RETURN .ENDC DIV: CLR R3 CLR R2 TST R5 BEQ 4$ COM R3 1$: ROL R5 BCC 1$ 2$: ROL R2 CMP R2,@R1 BLO 3$ SUB @R1,R2 3$: ROL R3 ASL R5 BNE 2$ COM R3 4$: TST (R1)+ RTS R1 .SBTTL BOOTSTRAP DRIVER .DRBOT DP,BOOT1,READ . = DPBOOT+40 BOOT1: JMP @#BOOT-DPBOOT . = DPBOOT+210 READ: MOV R0,R3 JSR R2,DIVIDE .WORD 10. MOV R4,-(SP) MOV R5,R3 JSR R2,DIVIDE .WORD 20. SWAB R4 BIS (SP)+,R4 MOV #RPDA,R3 MOV R4,@R3 MOV R5,-(R3) MOV R2,-(R3) MOV R1,-(R3) NEG @R3 BIC #^C,-(R3) BIS #CS.RD+CS.GO,@R3 1$: TSTB @R3 BPL 1$ TST @R3 BMI BIOERR MOVB #DS.ATT,@#DP$CSR CLRB @#DP$CSR RETURN DIVIDE: CLR R5 CLR R4 TST R3 BEQ 4$ COM R5 1$: ROL R3 BCC 1$ 2$: ROL R4 CMP R4,@R2 BLO 3$ SUB @R2,R4 3$: ROL R5 ASL R3 BNE 2$ COM R5 4$: TST (R2)+ RTS R2 . = DPBOOT+602 BOOT: MOV #10000,SP MOV @#RPCS,-(SP) BIC #^C,@SP SWAB @SP MOV #2,R0 MOV #<4*400>,R1 MOV #1000,R2 CALL READ MOV #READ-DPBOOT,@#B$READ MOV #B$DNAM,@#B$DEVN MOV (SP)+,@#B$DEVU JMP @#B$BOOT .DREND DP .END .MCALL .MODULE .MODULE DS,VERSION=06,COMMENT=,AUDIT=YES ; COPYRIGHT (c) 1984,1985,1986 BY ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. ; ALL RIGHTS RESERVED. ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED ; ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE ; INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER ; COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY ; OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY ; TRANSFERRED. ; ; THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE ; AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT ; CORPORATION. ; ; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS ; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL. .SBTTL CONDITIONAL ASSEMBLY SUMMARY .SBTTL MACROS AND DEFINITIONS .MCALL .DRDEF .ADDR .ASSUME .IIF NDF RJS0$3, RJS0$3 == 1 .IIF NE RJS0$3, RJS0$3=1 .DRDEF DS,16,FILST$,2000*<2-RJS0$3>,172040,204 .DRPTR .DREST CLASS=DVC.DK RSCS2 =: DS$CSR+10 RSER =: DS$CSR+14 RSDT =: DS$CSR+26 RSNREG =: 12. RSCNT =: 8. .SBTTL CONTROLLER REGISTER DEFINITIONS FNNOP =: 00*2 FNCLR =: 04*2 FNSCH =: 14*2 FNWCK =: 24*2 FNWRT =: 30*2 FNRED =: 34*2 CSSC =: 100000 CSTRE =: 40000 CSMCPE =: 20000 CSDVA =: 4000 CSPSEL =: 2000 CSA17 =: 1000 CSA16 =: 400 CSRDY =: 200 CSIE =: 100 CSGO =: 1 C2DLT =: 100000 C2WCE =: 40000 C2PE =: 20000 C2NED =: 10000 C2NEM =: 4000 C2PGE =: 2000 C2MXF =: 1000 C2MDPE =: 400 C2OR =: 200 C2IR =: 100 C2CLR =: 40 C2PAT =: 20 C2BAI =: 10 DSATA =: 100000 DSERR =: 40000 DSPIP =: 20000 DSMOL =: 10000 DSWRL =: 4000 DSLBT =: 2000 DSDPR =: 400 DSDRY =: 200 ERDCK =: 100000 ERUNS =: 40000 EROPI =: 20000 ERDTE =: 10000 ERWLE =: 4000 ERIAE =: 2000 ERAO =: 1000 ERPAR =: 10 ERRMR =: 4 ERILR =: 2 ERILF =: 1 DTRS04 =: 2 DTINTL =: 1 SYSPTR =: 54 CONFG2 =: 370 PROS$ =: 020000 .SBTTL INSTALLATION CODE .DRINS DS BR 10$ .ASSUME . EQ INSSYS BR 20$ 10$: MOV @#SYSPTR,R0 BIT #PROS$,CONFG2(R0) BNE 30$ 20$: TST (PC)+ 30$: SEC RETURN .Assume . LE 400,MESSAGE=<;Install area overflow> .SBTTL DRIVER ENTRY .ENABL LSB .DRBEG DS MOV #RSCNT,(PC)+ RSTRY: .WORD 0 RSINIT: MOV DSCQE,R5 MOV (R5)+,R3 .ASSUME Q$BLKN+2 EQ Q$FUNC MOV (R5)+,-(SP) SWAB @SP BIC #^C<7>,@SP MOV #RSCS2,R4 MOV #C2CLR,@R4 MOV (SP)+,@R4 MOV #1,(PC)+ RSTYPE: .WORD 0 BIT #DTRS04,@#RSDT BNE 1$ MOV #3,RSTYPE ASL R3 BCS RSERR 1$: CMP #2048.,R3 BLOS RSERR ASL R3 MOV R3,-(R4) .IF EQ MMG$T .ASSUME Q$FUNC+2 EQ Q$BUFF MOV (R5)+,-(R4) .IFF CALL @$MPPTR MOV (SP)+,-(R4) MOV (SP)+,R2 BIT #1700,R2 BNE RSERR ASH #4,R2 .ENDC .ASSUME Q$BUFF+2 EQ Q$WCNT MOV @R5,R5 RSFIX: MOV #CSIE!FNWRT!CSGO,R3 MOV R5,-(R4) BEQ RSEXIT BMI 2$ NEG @R4 MOV #CSIE!FNRED!CSGO,R3 2$: .IF NE MMG$T BIS R2,R3 .ENDC MOV R3,-(R4) RETURN .DSABL LSB .SBTTL INTERRUPT SERVICE ENTRY POINT .ENABL LSB .DRAST DS,5 .FORK RSFBLK MOV #RSCS2,R4 MOV DSCQE,R5 TST @#DS$CSR BMI 1$ TST Q$WCNT(R5) BPL RSDONE BIT RSTYPE,-(R4) BEQ RSDONE .ADDR #RSZERO,R3 MOV R3,-(R4) MOV #-1,R5 .IF NE MMG$T CLR R2 .ENDC BR RSFIX 1$: DEC RSTRY BLE RSFATL BIT #C2NED!C2NEM,@R4 BNE RSFATL BIT #ERUNS!ERWLE!ERIAE!ERAO!ERRMR!ERILR!ERILF,@#RSER .IF EQ ERL$G BEQ RSINIT RSFATL: .IFF BEQ 2$ RSFATL: CLR RSTRY 2$: .ADDR #RSRBUF,R2 MOV R2,R1 MOV #RSCNT*400+RSNREG,R3 MOV R3,R4 MOV #DS$CSR,R0 3$: MOV (R0)+,(R1)+ DECB R4 BNE 3$ MOV #DS$COD*400,R4 BISB RSTRY,R4 CALL @$ELPTR TSTB RSTRY BGT RSINIT .ENDC RSERR: MOV DSCQE,R4 .ASSUME Q$BLKN-2 EQ Q$CSW BIS #HDERR$,@-(R4) MOV #C2CLR,@#RSCS2 .IF NE ERL$G BR RSEXIT RSDONE: MOV #DS$COD*400+377,R4 CALL @$ELPTR .IFF RSDONE: .ENDC RSEXIT: .DRFIN DS .DSABL LSB RSZERO: .WORD 0 RSFBLK: .WORD 0,0,0,0 .IF NE ERL$G RSRBUF: .BLKW RSNREG .ENDC .SBTTL BOOTSTRAP DRIVER .DRBOT DS,BOOT1,READ . = DSBOOT+40 BOOT1: JMP @#BOOT-DSBOOT . = DSBOOT+210 READ: MOV R0,R4 MOV #RSCS2,R5 MOV @R5,-(SP) MOV #C2CLR,@R5 BIT #DTRS04,16(R5) BNE 1$ ASL R4 1$: ASL R4 BIC #^C<7>,@SP MOV (SP)+,@R5 MOV R4,-(R5) MOV R2,-(R5) MOV R1,-(R5) NEG @R5 MOV #FNRED!CSGO,-(R5) 2$: BIT #CSSC!CSRDY,@R5 BEQ 2$ BMI BIOERR CLC RETURN . =DSBOOT+604 BOOT: MOV #10000,SP MOV @#RSCS2,-(SP) BIC #^C7,@SP MOV #2,R0 MOV #<4*400>,R1 MOV #1000,R2 CALL READ MOV #READ-DSBOOT,@#B$READ MOV #B$DNAM,@#B$DEVN MOV (SP)+,@#B$DEVU JMP @#B$BOOT .DREND DS .END .MCALL .MODULE .MODULE DT,VERSION=06,COMMENT=,AUDIT=YES ; COPYRIGHT (c) 1984,1985,1986 BY ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. ; ALL RIGHTS RESERVED. ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED ; ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE ; INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER ; COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY ; OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY ; TRANSFERRED. ; ; THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE ; AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT ; CORPORATION. ; ; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS ; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL. .SBTTL CONDITIONAL ASSEMBLY SUMMARY .SBTTL MACROS AND DEFINITIONS SYSPTR =: 54 CONFG2 =: 370 PROS$ =: 020000 .MCALL .DRDEF .ASSUME .DRDEF DT,1,FILST$,578.,177340,214 .DRPTR .DREST CLASS=DVC.DK TCST =: DT$CSR TCCM =: TCST+2 TCWC =: TCCM+2 TCBA =: TCWC+2 TCDT =: TCBA+2 DTCNT =: 8. DTNREG =: 5 .SBTTL INSTALLATION CODE .DRINS DT BR 10$ .ASSUME . EQ INSSYS BR 20$ 10$: MOV @#SYSPTR,R0 BIT #PROS$,CONFG2(R0) BNE 30$ 20$: TST (PC)+ 30$: SEC RETURN .Assume . LE 400,MESSAGE=<;Install area overflow> .SBTTL DRIVER ENTRY .DRBEG DT MOV #DTCNT,(PC)+ DTTRY: .WORD 0 CLR @#TCCM BR DTCMN .IF NE ERL$G DTSTPJ: JMP DTSTOP .DRAST DT,6,DTSTPJ .IFF .DRAST DT,6,DTSTOP .ENDC DTCMN: MOV R0,-(SP) MOV DTCQE,R5 MOV #TCCM,R4 MOV (R5)+,-(SP) MOV (R5)+,R0 CMP (SP),#DTDSIZ BHIS HERROR BIC #^C<3400>,R0 BIT #100100,(R4) BMI DTERR .IF NE ERL$G BNE 1$ JMP RETRY .IFF BEQ RETRY .ENDC 1$: BIT #2,(R4) BEQ DTDONE CMP @#TCDT,BWANT BEQ BLKFND DIRECT: BLE FORWARD REVERSE:BIS #4000,R0 SUB #2,(SP) BR FORWARD FORW1: BIS #10000,R0 FORWARD:BIS #103,R0 MOV (SP)+,BWANT RETRNI: MOV R0,(R4) MOV (SP)+,R0 RTS PC ENDZR: BIT #4000,(R4) BEQ REVERSE BLKFND: BIT #4000,(R4) BNE FORWARD BIS #10115,R0 .IF EQ MMG$T MOV (R5)+,@#TCBA .IFF JSR PC,@$MPPTR MOV (SP)+,@#TCBA MOV R0,(PC)+ 10$: .BLKW MOV (SP)+,R0 BIT #1700,R0 BNE HERROR BIS 10$,R0 .ENDC MOV (R5),(SP) BMI 1$ BEQ DTDONE NEG (SP) BIC #10,R0 1$: MOV (SP)+,@#TCWC BR RETRNI DTERR: BIT #104000,@#TCST BPL NOTEZ BIT #2,(R4) BNE ENDZR NOTEZ: .IF NE ERL$G BIT #114400,@#TCST BEQ 2$ CLR DTTRY BR HERROR 2$: MOVB #11,@#TCCM TST (SP)+ MOV (SP)+,R0 .FORK DTFBLK MOV PC,R5 ADD #DTRBUF-.,R5 MOV R5,R2 MOV #DT$CSR,R3 MOV #DTNREG,R4 DTRREG: MOV (R3)+,(R5)+ DEC R4 BNE DTRREG MOV #DTNREG,R3 ADD #DTCNT*400,R3 MOV DTCQE,R5 MOV DTTRY,R4 DEC R4 ADD #DT$COD*400,R4 JSR PC,@$ELPTR MOV #TCCM,R4 MOV DTCQE,R5 MOV R0,-(SP) MOV (R5)+,-(SP) MOV (R5)+,R0 BIC #^C<3400>,R0 1$: .ENDC DEC DTTRY BGT RETRY HERROR: MOV DTCQE,R5 BIS #HDERR$,@-(R5) DTDONE: TST (SP)+ MOV (SP)+,R0 .IF NE ERL$G TST DTTRY BEQ DTSTOP MOVB #11,@#TCCM .FORK DTFBLK MOV #DT$COD*400+377,R4 MOV DTCQE,R5 JSR PC,@$ELPTR BR DTEXIT .ENDC DTSTOP: MOVB #11,@#TCCM .IF NE ERL$G CLR DTFBLK+2 .ENDC DTEXIT: .DRFIN DT RETRY: TSTB @#TCST BPL 10$ JMP FORW1 10$: ADD #4,BWANT CMP (PC)+,(SP) BWANT: .WORD 0 JMP DIRECT .IF NE ERL$G DTFBLK: .WORD 0,0,0,0 DTRBUF: .BLKW DTNREG .ENDC .SBTTL BOOTSTRAP DRIVER .DRBOT DT,BOOT1,READ . = DTBOOT+40 BOOT1: JMP @#BOOT-DTBOOT . = DTBOOT+210 READ: MOV #TCCM,R4 MOV #TCDT,R3 1$: MOV R0,R5 SUB #2,R5 MOV #4003,@R4 2$: BIT #100200,@R4 BEQ 2$ BMI 6$ CMP R5,@R3 BLT 1$ 3$: MOV #3,@R4 4$: BIT #100200,@R4 BEQ 4$ BMI 6$ CMP R0,@R3 BGT 3$ BLT 1$ MOV R2,-(R3) NEG R1 MOV R1,-(R3) MOV #5,@R4 5$: BIT #100200,@R4 BEQ 5$ BMI BIOERR CLR @R4 RTS PC 6$: TST @#DT$CSR BPL BIOERR BIT #4000,@R4 BNE 3$ BR 1$ . = DTBOOT+602 BOOT: MOV #10000,SP MOV @#TCCM,-(SP) BIC #^C<3400>,@SP SWAB @SP MOV #2,R0 MOV #<4*400>,R1 MOV #1000,R2 JSR PC,READ MOV #READ-DTBOOT,@#B$READ MOV #B$DNAM,@#B$DEVN MOV (SP)+,@#B$DEVU JMP @#B$BOOT .DREND DT .END .MCALL .MODULE .MODULE DU,VERSION=66,COMMENT=,AUDIT=NO ; COPYRIGHT (c) 1984,1985, 1986 BY ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. ; ALL RIGHTS RESERVED. ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED ; ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE ; INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER ; COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY ; OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY ; TRANSFERRED. ; ; THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE ; AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT ; CORPORATION. ; ; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS ; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL. .SBTTL CONDITIONAL ASSEMBLY SUMMARY .SBTTL Functional description .SBTTL Design Overview .SBTTL CONDITIONALS .MCALL .ASSUME,.ADDR,.BR, .PRINT .LIST MEB .IIF NDF DU$BOO, DU$BOO == 0 .IIF NDF DU$BBR, DU$BBR == 0 .IIF NDF ERL$G, ERL$G == 0 .IIF NDF DU$ERL, DU$ERL == 0 .IIF NDF MMG$T, MMG$T == 0 .IIF NDF DU$INITS DU$UNITS = 8. .Assume DU$UNITS EQ 8., .IIF NDF DU$PORTS, DU$PORTS = 1 .IIF LE DU$PORTS-1, DU$PORTS = 1 .IIF EQ DU$PORTS-1, DU$BOO = 0 DU$BBR = DU$BBR & MMG$T .IIF NDF DU$NAM, DU$NAM = <^RDU > .IF EQ MMG$T B$DNAM =: DU$NAM .IFF B$DNAM =: DU$NAM+<^R X> .ENDC .list me $1=0 .REPT DU$UNITS .IRP Y,\$1 .IIF NDF DU$U'Y DU$U'Y = $1 .IIF NDF DU$O'Y DU$O'Y = 0 .Assume DU$O'Y LE DU$PORTS .Assume DU$O'Y GE 0 .IIF NDF DU$A'Y DU$A'Y = 0 $1=$1+1 .ENDR .ENDR .nlist me .DUGEN =: DU$PORTS!! .DUUNI =: DU$UNI .AUDIT .DU,.DUGEN,.DUUNI .SBTTL MSCP PROTOCOL DEFINITIONS P.CRF =: 0 P.UNIT =: 4 P.OPCD =: 10 P.MOD =: 12 P.BCNT =: 14 P.BUFF =: 20 P.LBN =: 34 P.PART =: 36 P.CSIZ =: 60 P.OTRF =: 14 P.UNFL =: 16 P.DVPM =: 34 P.RBN =: 14 P.VRSN =: 14 P.CNTF =: 16 P.HTMO =: 20 TO.MIN = 0 P.TIME =: 24 P.CRF =: 0 P.UNIT =: 4 P.OPCD =: 10 P.FLGS =: 11 P.STS =: 12 P.BCNT =: 14 P.FBBK =: 34 P.OTRF =: 14 P.CMST =: 20 P.MLUN =: 14 P.UNFL =: 16 P.UNTI =: 24 P.TRCK =: 44 P.GRP =: 46 P.CYL =: 50 P.RCTS =: 54 P.RBNS =: 56 P.RCTC =: 57 P.MLUN =: 14 P.UNFL =: 16 P.UNTI =: 24 P.MEDI =: 34 P.UNSZ =: 44 P.VSER =: 50 P.VRSN =: 14 P.CNTF =: 16 P.CTMO =: 20 P.CNTI =: 24 P.MSIZ =: 60 OP.NIL =: 0 OP.ABO =: 1 OP.GCS =: 2 OP.GUS =: 3 OP.SCC =: 4 OP.AVL =: 10 OP.ONL =: 11 OP.SUC =: 12 OP.DAP =: 13 OP.ACC =: 20 OP.ERS =: 22 OP.RPL =: 24 OP.CMP =: 40 OP.RD =: 41 OP.WR =: 42 OP.SEX =: 7 OP.END =: 200 OP.AVA =: 100 OP.DUP =: 101 OP.ACP =: 102 MD.CMP =: 40000 MD.EXP =: 100000 MD.ERR =: 10000 MD.SEC =: 1000 MD.SER =: 400 MD.ALL =: 2 MD.SPD =: 1 MD.NXU =: 2000 MD.RIP =: 1 MD.IMP =: 2 MD.SWP =: 4 MD.PRI =: 1 EF.BBR =: 200 EF.BBU =: 100 EF.LOG =: 40 UF.CMR =: 1 UF.CMW =: 2 UF.576 =: 4 UF.RMV =: 200 UF.WPH =: 20000 UF.WPS =: 10000 UF.BBR =: 100000 CF.ATN =: 200 CF.MSC =: 100 CF.OTH =: 40 CF.THS =: 20 CF.576 =: 1 ST.MSK =: 37 ST.SUC =: 0 ST.INV =: 1 ST.OFF =: 3 ST.AVL =: 4 ST.PRO =: 6 ST.DAT =: 10 ST.DRV =: 13 ST.SUB =: 40 L.CRF =: 0 L.UNIT =: 4 L.SEQ =: 6 L.FMT =: 10 L.FLGS =: 11 L.EVNT =: 12 L.CNTI =: 14 L.CSVR =: 24 L.CHVR =: 25 L.MLUN =: 26 L.UNTI =: 30 L.USVR =: 40 L.UHVR =: 41 L.VSER =: 44 FM.CNT =: 0 FM.BAD =: 1 FM.DSK =: 2 FM.SDI =: 3 LF.SUC =: 200 LF.CON =: 100 LF.SNR =: 1 L.BADR =: 4 L.LVL =: 42 L.RTRY =: 43 L.VSER =: 44 L.HDCD =: 50 L.HDCD =: 50 L.SDI =: 54 .SBTTL UDA PORT DEFINITIONS OWN =: 100000 FLAG =: 40000 ISTEP1 =: 4000 ISTEP2 =: 10000 ISTEP3 =: 20000 ISTEP4 =: 40000 IERROR =: 100000 IE =: 200 STEP =: 200 GO =: 1 PC.AIP =: 0 PC.ASA =: 2 PC.STEP =: 4 PC.VEC =: 6 PC.ESZ =: 10 BB.STS =: 0 BB.MAX =: 2 BB.RCT =: 6 BB.TRK =: 10 BB.RBN =: 12 BB.COP =: 13 BB.SIZ =: 14 .SBTTL DRIVER DEFINITIONS NRETRY =: 8. VT.ESZ =: 6 ILG.V =: 4 INS.V =: 10 KISAR1 =: 172342 BLK =: 1000 BLK0 =: 0 IN.TMO =: 200 IN.ONL =: 100000 IOP.NR =: 177777 SYSPTR =: 54 SYNCH =: 324 SYSPTR =: 54 MEMPTR =: 430 CORPTX =: 4 FSIZE =: 0 FADDR =: 2 P1EXT =: 432 CVAPHY =: -16 FINDGR =: -12 XALLOC =: -6 BLKMOV =: -2 CONFG2 =: 370 QBUS$ =: 000100 GR.SIZ =: 0 GR.ADR =: 2 GR.STA =: 4 GR.PVT =: 100000 GR.NRF =: 000040 GR.NAM =: 6 GR.ESZ =: 10. BEGREL =: 20000 ENDREL =: 37776 PGSIZ =: 20000 SP.RIO =: 377 SP.WIO =: 376 SP.VSZ =: 373 SP.DAT =: 372 SP.BYP =: 371 SP.MUC =: 360 SPFUNB =: 100000 SPERR =: 077400 SPFERR =: 040000 SPBBR =: 000200 SPECC =: 000001 UT.UNIT =: 0 UT.PART =: 2 UT.PORT =: 3 UT.ESZ =: 4 .SBTTL DRDEF - definition .MCALL .DRDEF, .MFPS, .MTPS .SYNCH .DRDEF DU,50,FILST$!SPFUN$!VARSZ$,0,172150,154 .IF EQ MMG$T .DRPTR FETCH=ONCE,LOAD=ONCE .DREST CLASS=DVC.DK .IFF .DRPTR FETCH=ONCE,LOAD=ONCE .DREST CLASS=DVC.DK .ENDC .DRSPF SP.RIO .DRSPF SP.WIO .DRSPF SP.VSZ .DRSPF SP.DAT .DRSPF .IIF NDF DU$ALT DU$ALT = 176150 .IIF NDF DU$CS1, DU$CS1=DU$CSR-04 .IIF NDF DU$CS2, DU$CS2=DU$CSR-10 .IIF NDF DU$CS3, DU$CS3=DU$CSR-14 .IIF NDF DU$VC1, DU$VC1=DU$VEC-04 .IIF NDF DU$VC2, DU$VC2=DU$VEC-10 .IIF NDF DU$VC3, DU$VC3=DU$VEC-14 .IF NE MMG$T .SAVE .PSECT DUDVR .PSECT SETOVR .PSECT DUBOOT .PSECT DUX DUXBAS:: .RESTORE .IFF .PSECT DUDVR .PSECT SETOVR .PSECT DUBOOT .ENDC .SBTTL MACRO DEFINITIONS .MACRO MSCP OPCODE JSR R5,GETCBF .WORD OPCODE .ENDM .MACRO DO THIS,THEN,THAT JSR R5,COORD .WORD THAT-.,THIS-. .ENDM .MACRO PUSH LIST .IRP XX, MOV XX,-(SP) .ENDM .ENDM PUSH .MACRO POP LIST .IRP XX, MOV (SP)+,XX .ENDM .ENDM POP DUR.Cnt = 0 DUX.Cnt = 0 .Macro $Rel Loc Value Base .....1 = . . = Loc .If IDN DUX.Cnt = DUX.Cnt+1 .Irp x <\DUX.Cnt> DUX'x: .Word Value-DUXBase+BEGREL .EndR . = .....1 .MExit .EndC; IDN .If IDN DUR.Cnt = DUR.Cnt+1 .Irp x <\DUR.Cnt> DUR'x: .Word Value-DUBase .EndR . = .....1 .MExit .EndC; IDN .Error .EndM $Rel .MACRO DUXPSECT .IF NE MMG$T .SAVE .PSECT DUX .ENDC .ENDM DUXPSECT .MACRO DUPSECT .IIF NE MMG$T .RESTORE .ENDM DUPSECT .MACRO .P1EXT NEWPAR,?LOC MOV NEWPAR,LOC JSR R0,@$P1EXT .WORD LOC-. .MACRO .P1END LOC: .WORD 0 .ENDM .ENDM .P1EXT .MACRO .HP1EX NEWPAR,?LOC MOV NEWPAR,LOC JSR R0,@H$P1EX .WORD LOC-. .MACRO .HP1EN LOC: .WORD 0 .ENDM .ENDM .HP1EX .SBTTL INSTALLATION CODE .ASECT . = 0 REF0:: . = 120 .IF EQ DU$PORTS-1 .DRINS DU .IFF .IF EQ DU$PORTS-2 .DRINS DU, .IFF .IF EQ DU$PORTS-3 .DRINS DU, .IFF .DRINS DU, .ENDC .ENDC .ENDC BR DATAIN BR SYSTIN DATAIN: .IF NE MMG$T MOV @#SYSPTR,R4 MOV MEMPTR(R4),R0 ADD R4,R0 MOV CORPTX(R0),R5 ADD R4,R5 20$: CMP #-1,(R5)+ BNE 20$ 30$: CMP #-1,@R5 BEQ I.BAD TST @R5 BEQ 40$ ADD #GR.ESZ,R5 BR 30$ 40$: MOV P1EXT(R4),R0 MOV #MEMDUX,R2 CALL XALLOC(R0) BCS I.BAD MOV R2,(R5)+ MOV R1,(R5)+ MOV #GR.PVT,(R5)+ MOV #DU$NAM,(R5)+ MOV #<^R$>,@R5 .DSABL LSB .ENDC SYSTIN: .IF EQ DU$BOO CLR R0 MFPT CMP R0,#4 BNE I.GOO TST @#DU$ALT .IIF EQ MMG$T NOP BCS I.BAD .ENDC I.GOO: TST (PC)+ I.BAD: SEC RTS PC .SBTTL SET code dispatch tables. .ENABL LSB OV.UT: MOV #SET.UT/2,R2 BR 10$ OV.CSR: MOV #SET.CSR/2,R2 BR 10$ OV.VEC: MOV #SET.VEC/2,R2 BR 10$ OV.RET: MOV #SET.RET/2,R2 10$: BR GETOVR .DSABL LSB .ASSUME . LE 400 .SBTTL SET CODE TABLES .DRSET UNIT,UT.UNIT+1,XOV.UT,NUM .DRSET PART,UT.PART+1,XOV.UT,NUM .DRSET PORT,UT.PORT+1,XOV.UT,NUM .DRSET CSR,<0*2+1>,XOV.CS,OCT .DRSET VECTOR,<0*2+1>,XOV.VE,OCT .DRSET CSR0,<0*2+1>,XOV.CS,OCT .DRSET VEC0,<0*2+1>,XOV.VE,OCT .IF NE DU$PORTS-1 .DRSET CSR1,<1*2+1>,XOV.CS,OCT .DRSET VEC1,<1*2+1>,XOV.VE,OCT .IF NE DU$PORTS-2 .DRSET CSR2,<2*2+1>,XOV.CS,OCT .DRSET VEC2,<2*2+1>,XOV.VE,OCT .IF NE DU$PORTS-3 .DRSET CSR3,<3*2+1>,XOV.CS,OCT .DRSET VEC3,<3*2+1>,XOV.VE,OCT .ENDC .ENDC .ENDC .DRSET RETRY,127.,XOV.RE,NUM .IF NE ERL$G .DRSET SUCCES,-1,OV.SUC,NO .ENDC XOV.UT: BR OV.UT XOV.CS: BR OV.CSR XOV.VE: BR OV.VEC XOV.RE: BR OV.RET .IF NE ERL$G OV.SUC: CLR R2 BR ACNO OV.NO: MOV #4/2,R2 ACNO: ADD #SET.SUC/2,R2 BR GETOVR .ENDC .ASSUME . LE <1000-144> .SBTTL GETOVR - Get Overlay SET code routine from disk .ENABL LSB . = 1000 - 144 GETOVR: SWAB R2 MOVB R2,REABLK CLRB R2 .ASSUME BLK0 EQ 0 JSR R0,10$ REAFUN: .BYTE 17,10 REABLK: .BLKW 1 REABUF: .BLKW 1 .WORD VALWCT .WORD 0 10$: .ADDR #BLK0,R5,PUSH MOV R5,REABUF MOV (SP)+,R5 VALWCT =: ./2 OVRSIZ =: . EMT 375 MOV (SP)+,R0 BCS SET.NOR SWAB R2 ASL R2 .ADDR #BLK0,R2,ADD JMP @R2 .DSABL LSB .SBTTL GETBK0 - Read block zero - resident routine .ENABL LSB GETBK0: JSR R0,10$ RDZERO: .BYTE 17,10 .WORD BLK0 RDBUF: .BLKW 1 RDWC: .WORD VALWCT .WORD 0 10$: .ADDR #BLK0,R3 MOV R3,RDBUF EMT 375 MOV (SP)+,R0 BCS SET.NOR SET.EX: TST R2 BEQ SET.NOR DEC R2 BEQ SET.ERR ADD #2,(SP) SET.ERR:SEC SET.NOR:RTS PC .DSABL LSB SET.END: OSIZ ==: SET.END - GETOVR .ASSUME . LE 1000 .SBTTL DATA ALLOCATION .ENABLE LC,LSB .DRBEG DU DUBASE =: DUSTRT + 6 BR ACROSS STATU$::.WORD 0 ACROSS: MOV DUCQE,R5 .IF NE MMG$T MOV @#KISAR1,R1 .P1EXT P1HIGH JMP @#BEGIN $REL .-2 BEGIN DUX .P1END .IFF JMP BEGIN .ENDC .DSABL LSB .IF NE DU$PORTS-1 .DRVTB DU,DU$VEC,DUINT .DRVTB ,DU$VC1,DUINT .IF NE DU$PORTS-2 .DRVTB ,DU$VC2,DUINT .IF NE DU$PORTS-3 .DRVTB ,DU$VC3,DUINT .ENDC .ENDC .ENDC UDAIP:: .WORD DU$CSR UDASA:: .WORD DU$CSR+2 ISTEP: .WORD 0 INISEQ: .WORD 0 INILST: .BYTE DU$VEC/4!IE .BYTE 0*10+0+STEP MRPTR: .WORD 0 .WORD 0 .WORD GO INTRID: .BLKW 2 MRING: .WORD 0,0 CRING: .WORD 0,0 .IF NE ERL$G $SUCS: .WORD 0 .ENDC $RETRY: .WORD NRETRY .IF NE MMG$T PHYSH: .WORD 0 PHYSL: .WORD 0 .ENDC .UTTAB: .WORD 0 DUTAB: .RAD50 "DU " .Word DU$UNITS UTTAB: .ASSUME UT.UNIT EQ 0 .ASSUME UT.PART EQ 2 .ASSUME UT.PORT EQ 3 $1=0 .REPT DU$UNITS .IRP Y,\$1 .WORD DU$U'Y .BYTE DU$A'Y .BYTE DU$O'Y $1=$1+1 .ENDR .ENDR .IF NE DU$PORTS-1 .PCTAB: .WORD 0 PCTAB: .ASSUME PC.AIP EQ 0 .ASSUME PC.ASA EQ 2 .ASSUME PC.STEP EQ 4 .ASSUME PC.VEC EQ 6 .WORD DU$CSR,DU$CSR+2 .WORD 0,DU$VEC/4!IE .WORD DU$CS1,DU$CS1+2 .WORD 0,DU$VC1/4!IE .IF NE DU$PORTS-2 .WORD DU$CS2,DU$CS2+2 .WORD 0,DU$VC2/4!IE .IF NE DU$PORTS-3 .WORD DU$CS3,DU$CS3+2 .WORD 0,DU$VC3/4!IE .ASSUME DU$PORTS LE 4 .ENDC .ENDC .ENDC LOWDATA ==: . - UDAIP .ASSUME . LE DUSTRT+1000 DUXPSECT .IF NE MMG$T XUDAIP::.WORD DU$CSR XUDASA::.WORD DU$CSR+2 XISTEP: .WORD 0 XINISE: .WORD 0 XINILS: .BYTE DU$VEC/4!IE .BYTE 0*10+0+STEP XMRPTR: .WORD 0 .WORD 0 .WORD GO XINTRI: .BLKW 2 XMRING: .WORD 0,0 XCRING: .WORD 0,0 .IF NE ERL$G X$SUCS: .WORD 0 .ENDC X$RETR: .WORD NRETRY XPHYSH: .WORD 0 XPHYSL: .WORD 0 X.UTTA: .WORD 0 XDUTAB: .RAD50 "DU " .WORD DU$UNITS XUTTAB: $1=0 .REPT DU$UNITS .IRP Y,\$1 .WORD DU$U'Y .BYTE DU$A'Y .BYTE DU$O'Y $1=$1+1 .ENDR .ENDR .IF NE DU$PORTS-1 X.PCTA: .WORD 0 XPCTAB: .WORD DU$CSR,DU$CSR+2 .WORD 0,DU$VEC/4!IE .WORD DU$CS1,DU$CS1+2 .WORD 0,DU$VC1/4!IE .IF NE DU$PORTS-2 .WORD DU$CS2,DU$CS2+2 .WORD 0,DU$VC2/4!IE .IF NE DU$PORTS-3 .WORD DU$CS3,DU$CS3+2 .WORD 0,DU$VC3/4!IE .ENDC .ENDC .ENDC .ENDC LN.CMD: .WORD P.CSIZ VC.CMD: .WORD 0 CBUFF: .BLKB P.CSIZ LN.RSP: .WORD 0 VC.RSP: .WORD 0 MBUFF: .BLKB P.MSIZ DUPSECT .IF NE MMG$T P1HIGH: .WORD 0 $P1EXT: .WORD 0 .ENDC DUXPSECT RETRY: .WORD 0 VOLSIZE:.WORD 0,0 NEXT: .WORD 0 .IF NE MMG$T P1LOW: .WORD 0 .IF NE ERL$G H$ELPT: .WORD 0 .ENDC H$PTWR: .WORD 0 H$MPPT: .WORD 0 H$GTBY: .WORD 0 H$P1EX: .WORD 0 H$CQE: .WORD 0 .ENDC .IF NE DU$PORTS-1 ACTPORT:.WORD -1 .ENDC INTEOP: .WORD 0 .IF NE DU$BBR BBRON: .WORD 0 .ENDC DUPSECT DUFBLK: .WORD 0,0,0,0 .IF NE ERL$G ERLBUF: .BLKB P.MSIZ .ENDC DUXPSECT .IF NE DU$BBR .IF NE DU$PORTS ACTBBR: .WORD 0 BBRTAB: .ASSUME BB.STS EQ 0 .ASSUME BB.MAX EQ 2 .ASSUME BB.RCT EQ 6 .ASSUME BB.TRK EQ 10 .ASSUME BB.RBN EQ 12 .ASSUME BB.COP EQ 13 .WORD 0 .BLKW 5 .IF NE DU$PORTS-1 .WORD 0 .BLKW 5 .IF NE DU$PORTS-2 .WORD 0 .BLKW 5 .IF NE DU$PORTS-3 .WORD 0 .BLKW 5 .ASSUME DU$PORTS LE 4 .ENDC .ENDC .ENDC .ENDC .SBTTL BBR data structures and definitions LBN: .BLKW 400 SEC0: .BLKW 400 VSN0 =: 0 VSN1 =: VSN0+2 VSN2 =: VSN1+2 VSN3 =: VSN2+2 RCTFLG ==: VSN3+2 RF.WB=:1 RF.FE=:200 RF.BR=:20000 RF.P2=:40000 RF.P1=:100000 RLBNL=: RCTFLG+4 RLBNH=: RLBNL+2 URBNL=: RLBNH+2 URBNH=: URBNL+2 RRBNL=: URBNH+2 RRBNH=: RRBNL+2 CID0=: RRBNH+2 CID1=: CID0+2 CID2=: CID1+2 CID3=: CID2+2 CIN0=: CID3+2 CIN1=: CIN0+2 RCTBF: .BLKW 400 RCTB1: .BLKW 400 XFRSZ: .BLKW 1 LBNH: .BLKW 1 LBNL: .BLKW 1 RPLBL: .BLKW 1 RPLBH: .BLKW 1 DSKBF: .BLKW 1 IOMOD: .BLKW 1 UNIT: .BLKW 1 IOFUN: .BLKW 1 DF.SEC =: 010000 DF.ALL =: 020000 DF.UNU =: 040000 DF.NUL =: 100000 OOPS: .BLKW 1 USTAT: .BLKW 1 US.OLP =: 1 IOST: .BLKW 2 DPHYSL: .BLKW 1 DPHYSH: .BLKW 1 BBRECU: .BLKW 1 BLBNL: .BLKW 1 BLBNH: .BLKW 1 PLBNL: .BLKW 1 PLBNH: .BLKW 1 PLBNO: .BLKW 1 RCTSZ: .BLKW 1 TRKSZ: .BLKW 1 RBNPT: .BLKB 1 RCTCP: .BLKB 1 MXLBN: .BLKW 2 NRBNL: .BLKW 1 NRBNH: .BLKW 1 NLBNL: .BLKW 1 NLBNH: .BLKW 1 NLBNO: .BLKW 1 ORBNL: .BLKW 1 ORBNH: .BLKW 1 OLBNL: .BLKW 1 OLBNH: .BLKW 1 OLBNO: .BLKW 1 OLDSTA: .BLKW 1 WRKSIZ ==: OLDSTA+2-XFRSZ INTFLG::.BLKW 1 BIT0 =: 1 BIT1 =: 2 BIT2 =: 4 BIT3 =: 10 BIT4 =: 20 BIT5 =: 40 BIT6 =: 100 BIT7 =: 200 .NLIST BEX MSG1: .ASCIZ /?DU-E-REPLACE COMMAND FAILURE/ MSG2: .ASCIZ /?DU-E-SOFTWARE WRITE PROTECTING VOLUME/ CRLF: .ASCII <15><12> .LIST BEX .EVEN .ENDC .SBTTL ********************************** .SBTTL EXECUTABLE CODE BEGINS * .SBTTL ********************************** BEGIN:: .IF EQ MMG$T MOV $RETRY,RETRY .IFF MOV 2(SP),SP ADD #6,SP MOV R5,H$CQE MOV R1,P1LOW MOV X$RETRY,RETRY .ENDC CLR INTEOP .IF NE DU$BBR CLR BBRON .ENDC CMPB Q$FUNC(R5),#SP.DAT BNE 10$ JMP DOTAB 10$: MOVB Q$UNIT(R5),R3 BIC #^C<7>,R3 ASL R3 ASL R3 .ASSUME UT.ESZ EQ 4 .IF EQ MMG$T .ADDR #UTTAB,R3,ADD MOV R3,.UTTAB .IFF ADD #XUTTAB,R3 $REL .-2 XUTTAB DUX MOV R3,X.UTTAB .ENDC .IF NE DU$PORTS-1 MOVB UT.PORT(R3),R2 BPL 30$ JMP DUHERR 30$: MOV R2,R3 ASL R2 ASL R2 ASL R2 .ASSUME PC.ESZ EQ 10 .IF EQ MMG$T .ADDR #PCTAB,R2,ADD MOV R2,.PCTAB .IFF ADD #XPCTAB,R2 $REL .-2 XPCTAB DUX MOV R2,X.PCTAB .ENDC CMP R3,ACTPORT BEQ NOSW MOV R3,ACTPORT .IF EQ MMG$T .ADDR #UDAIP,R4 .IFF MOV #XUDAIP,R4 $REL .-2 XUDAIP DUX .ENDC MOV (R2)+,(R4)+ .ASSUME PC.AIP EQ 0 MOV (R2)+,(R4)+ .ASSUME PC.ASA EQ 2 MOV (R2)+,(R4)+ .ASSUME PC.STEP EQ 4 .IF EQ MMG$T MOVB (R2),INILST .ASSUME PC.VEC EQ 6 .IFF MOVB (R2),XINILST .ENDC .ENDC NOSW: .IF NE DU$BBR .IF NE DU$PORTS-1 MOV ACTPORT,R1 .IFF CLR R1 .ENDC ASL R1 ASL R1 MOV R1,-(SP) ASL R1 ASL R1 SUB (SP)+,R1 .ASSUME BB.SIZ EQ 14 ADD #BBRTAB,R1 $REL .-2 BBRTAB DUX MOV R1,ACTBBR .ENDC .BR START .SBTTL PORT INITIALIZATION CODE .ENABL LSB START: CLR R5 .IF EQ MMG$T TST ISTEP .IFF TST XISTEP .ENDC BPL INIT .IF EQ MMG$T BIT #,@UDASA .IFF MOV #XUDASA+2,R5 $REL .-2 XUDASA+2 DUX BIT #,@-(R5) .ENDC BNE INIT JMP DISPAT INIT: MOV #,INITFL DEC RETRY BGE 10$ HARDEX: JMP DUHERR 10$: .IF NE MMG$T MOV #XUDAIP,R5 $REL .-2 XUDAIP DUX MOV R5,@(R5) MOV #XISTEP,R4 $REL .-2 XISTEP DUX .IFF MOV R5,@UDAIP .ADDR #ISTEP,R4 .ENDC MOV #ISTEP1,(R4)+ MOV R4,@R4 .IF EQ MMG$T CMP (R4)+,(R4)+ MOV R4,@R4 ADD #MRING-MRPTR,@R4 .ENDC INISTP: .IF EQ MMG$T .ADDR #UDASA,R4 .IFF MOV #XUDASA,R4 $REL .-2 XUDASA DUX .ENDC MOV @(R4)+,R5 BMI INIT BIT R5,@R4 BEQ INISTP ASL (R4)+ ADD #2,(R4)+ .IF NE MMG$T MOV #XUDASA+2,R5 $REL .-2 XUDASA+2 DUX MOV @-(R4),@-(R5) .IFF MOV @-(R4),@UDASA .ENDC TST -(R4) .ASSUME ISTEP4*2 EQ 100000 .IF EQ DU$PORTS-1 BMI START .IFF BPL 1$ .IF NE MMG$T MOV X.PCTAB,R5 .IFF MOV .PCTAB,R5 .ENDC MOV (R4),PC.STEP(R5) BR START .ENDC 1$: .IF NE MMG$T HRET: .HP1EX P1LOW JMP @#LRET1 $REL .-2 LRET1 DUR .HP1EN DUPSECT LRET1: MOV 2(SP),SP ADD #6,SP .ENDC RTS PC .DSABL LSB .SBTTL FUNCTION DISPATCH AREA .ENABL LSB DUXPSECT DISPAT: ASLB (PC)+ .ASSUME IN.TMO EQ 200 INITFL: .WORD 0 BCC 4$ DO SETTMO,THEN,4$ 4$: .IF EQ MMG$T MOV DUCQE,R5 .IFF MOV H$CQE,R5 .ENDC TST (R5)+ .ASSUME Q$FUNC EQ 2 CMPB @R5,#SP.MUC BEQ 7$ CMPB @R5,#SP.BYP BNE 8$ 7$: MOVB #SP.MUC,@R5 CMP #1,-(R5) .ASSUME Q$BLKN EQ 0 BNE 5$ 8$: ASL INITFL .ASSUME IN.ONL EQ 100000 BCC 5$ BRINON: .IF EQ DU$BBR DO TRYONL,THEN,DISPAT .IFF DO TRYONL,THEN,GETUS .ENDC 5$: .IF EQ MMG$T MOV DUCQE,R5 .IFF MOV H$CQE,R5 .ENDC MOVB Q$FUNC(R5),R4 BNE 10$ .IF EQ ERL$G .IF NE MMG$T CALL BUSCHK BCS HARDEX .ENDC DO IOXFER,THEN,DUEXIT .IFF .IF NE MMG$T CALL BUSCHK BCS HARDEX .ENDC DO IOXFER,THEN,LOGIT .ENDC 10$: CMPB R4,#SP.MUC BNE 20$ DO BYPASS,THEN,DUEXIT 20$: CMPB R4,#SP.VSZ BNE 45$ DO ONLINE,THEN,GETSIZ 45$: CMPB R4,#SP.WIO BLT NOFUN BHI 50$ NEG Q$WCNT(R5) 50$: MOV #SPFUNB,(PC)+ SPCIO: .WORD 0 .IF NE MMG$T MOV Q$PAR(R5),(PC)+ SPPAR: .WORD 0 .ENDC MOV Q$BUFF(R5),(PC)+ SPBUFA: .WORD 0 ADD #2,Q$BUFF(R5) .IF NE MMG$T CMP Q$BUFF(R5),#40000 BLO 55$ SUB #20000,Q$BUFF(R5) ADD #200,Q$PAR(R5) 55$: CALL BUSCHK BCS HARDEX .ENDC DO IOXFER,THEN,DUEXIT NOFUN: JMP DUEXIT HINIST: BR INISTP .DSABL LSB .SBTTL COORD - Coordination routine for handler COORD: MOV R5,R4 ADD (R5)+,R4 MOV R4,NEXT MOV R5,R4 ADD (R5)+,R4 MOV (SP)+,R5 JSR PC,@R4 .BR POLL .SBTTL POLL - This routine starts the controller! POLL: .IF EQ MMG$T BIS #OWN,CRING+2 MOV @UDAIP,R5 BIS #,MRING+2 .IFF BIS #OWN,XCRING+2 MOV #XUDAIP,R5 $REL .-2 XUDAIP DUX MOV @(R5),R5 BIS #,XMRING+2 .ENDC .IF EQ MMG$T RTS PC .IFF JMP HRET .ENDC .SBTTL INTERRUPT ENTRY POINT .ENABL LSB DUPSECT .DRAST DU,5 .IF NE MMG$T .P1EXT P1HIGH CALL @#INTEX $REL .-2 INTEX DUX .P1END JMP FORKIT .ENDC DUXPSECT .IF NE MMG$T INTEX: CLR XINTRID CLR XINTRID+2 RETURN DUPSECT FORKIT: .FORK DUFBLK MOV @#KISAR1,R1 .P1EXT P1HIGH JMP @#INTEX2 $REL .-2 INTEX2 DUX .P1END DUXPSECT INTEX2: MOV 2(SP),SP ADD #6,SP MOV R1,P1LOW TST XISTEP .IFF CLR INTRID CLR INTRID+2 .FORK DUFBLK TST ISTEP .ENDC BGT HINIST .IF EQ MMG$T BIT #,@UDASA .IFF MOV #XUDASA+2,R5 $REL .-2 XUDASA+2 DUX BIT #,@-(R5) .ENDC BEQ 47$ JMP INIT 47$: .IF NE DU$BBR TST BBRON BPL 60$ JMP CONBBR .ENDC 60$: TST INTEOP BMI 44$ BNE 10$ 50$: .IF EQ MMG$T MOV DUCQE,R5 .IFF MOV H$CQE,R5 .ENDC CMPB #SP.MUC,Q$FUNC(R5) BNE 10$ CMP #1,(R5) BNE 44$ 30$: .IF NE MMG$T MOV Q$PAR(R5),R1 MOV Q$BUFF(R5),R5 ADD #<4>,R5 CLR R2 .HP1EX R1 BISB P.FLGS(R5),R2 MOV P.STS(R5),R1 .HP1EN BR 4040$ .ENDC 10$: .IF NE MMG$T MOV #MBUFF,R5 $REL .-2 MBUFF DUX .IFF MOV MRING,R5 .IFTF CLR R2 BISB P.FLGS(R5),R2 MOV P.STS(R5),R1 .IFF MOV R1,STATU$ .IFT 4040$: .HP1EX P1LOW MOV R1,@#STATU$ $REL .-2 STATU$ DUR .HP1EN .ENDC 40$: .IF NE DU$BBR BITB R2,#EF.BBR BEQ NOBBR JMP BBFND NOBBR: .ENDC BIC #^C,R1 .ASSUME ST.SUC EQ 0 TST R1 .ASSUME ST.SUC EQ 0 BNE 20$ 44$: CLR INTEOP JMP @NEXT 20$: CMP R1,#ST.AVL .IF EQ ERL$G BNE DUHERR .IFF BEQ 48$ JMP BADIO 48$: .ENDC HSTART: .IIF NE ERL$G, CALL ERRLOG DEC RETRY BLE DUHERR JMP BRINON .DSABL LSB .SBTTL NORMAL AND STANDARD EXITS DUHERR: TST SPCIO BEQ 10$ CALL SPCERR 10$: .IF EQ MMG$T MOV DUCQE,R5 .IFF MOV H$CQE,R5 .ENDC BIS #HDERR$,@-(R5) .BR DUEXIT .ENABL LSB DUEXIT: TST SPCIO BEQ 10$ CALL SPCEXI 10$: .IF NE MMG$T .HP1EX P1LOW JMP @#LRET2 $REL .-2 LRET2 DUR .HP1EN DUPSECT LRET2: MOV 2(SP),SP ADD #6,SP .ENDC .DRFIN DU .DSABL LSB .SBTTL SPCEXI - SPECIAL ABSOLUTE READ/WRITE EXITS .ENABL LSB DUXPSECT SPCERR: BITB #EF.BBR,R2 BEQ 20$ BIS #SPBBR,SPCIO BR SPCEXI 20$: CMPB #ST.DAT,R1 BNE 10$ BIS #SPFERR,SPCIO BR SPCEXI 10$: BIS #SPERR,SPCIO SPCEXI: MOV SPBUFA,R2 .IF NE MMG$T MOV H$CQE,R4 MOV R2,Q$BUFF(R4) MOV SPPAR,Q$PAR(R4) MOV SPCIO,-(SP) CALL @H$PTWR .IFF MOV SPCIO,(R2) .ENDC CLR SPCIO RTS PC .DSABL LSB .SBTTL SETTMO - Sets 'host timeout' period SETTMO: MOVB #IOP.NR,INTEOP MSCP OP.SCC MOV #TO.MIN*60.,P.HTMO(R4) RTS PC .SBTTL ONLINE - Do online request for retry or sizing TRYONL: MOV #IOP.NR,INTEOP ONLINE: MSCP OP.ONL RTS PC .IF NE DU$BBR .SBTTL IGETUS - Do a GET UNIT STATUS request IGETUS: MOV #IOP.NR,INTEOP MSCP OP.GUS RTS PC .ENDC .SBTTL SUBROUTINE TO INITIALIZE FOR I/O TRANSFERS IOXFER: MSCP OP.RD MOV (R5),R1 MOV R1,P.LBN(R4) .IF EQ MMG$T MOV Q$BUFF(R5),P.BUFF(R4) .IFF ADD #Q$BUFF,R5 CALL @H$MPPT MOV (SP)+,P.BUFF(R4) MOV (SP)+,R0 ASH #-4,R0 MOVB R0,P.BUFF+2(R4) MOV H$CQE,R5 .ENDC TST SPCIO BEQ 30$ SUB #2,Q$BUFF(R5) 30$: MOV Q$WCNT(R5),R0 BPL 1$ NEG R0 INCB P.OPCD(R4) .ASSUME OP.WR EQ OP.RD+1 1$: MOV R0,-(SP) ADD #255.,R0 CLRB R0 SWAB R0 ADD R0,R1 BCC 2$ TST R1 BEQ 2$ SUB R1,R0 SWAB R0 TST (SP)+ BIS #HDERR$,@-(R5) BR 3$ 2$: MOV (SP)+,R0 3$: ASL R0 MOV R0,P.BCNT(R4) .IF EQ MMG$T MOV .UTTAB,R5 .IFF MOV X.UTTAB,R5 .ENDC MOVB UT.PART(R5),P.PART(R4) RTS PC .IF NE MMG$T .SBTTL BUSCHK - Check DMA limits for a given bus .ENABL LSB BUSCHK: MOV R5,-(SP) MOV @#SYSPTR,R3 BIT #QBUS$,CONFG2(R3) BNE 20$ MOV H$CQE,R5 ADD #Q$BUFF,R5 CALL @H$MPPT MOV (SP)+,R1 MOV (SP)+,R2 ASH #-4,R2 MOV (R5)+,-(SP) BPL 10$ NEG (SP) 10$: ASL (SP) ADD (SP)+,R1 ADC R2 BIC #<^B11>,R2 BNE 30$ 20$: TST (PC)+ 30$: SEC MOV (SP)+,R5 RETURN .DSABL LSB .ENDC .IF NE ERL$G .SBTTL ERROR LOGGING SUPPORT ROUTINES LOGIT: .IF EQ MMG$T TST $SUCS .IFF TST X$SUCS .ENDC BNE 44$ CLR RETRY MOV #400,RETRY JSR PC,ERRLOG 44$: JMP DUEXIT BADIO: MOV #1,RETRY JSR PC,ERRLOG JMP DUHERR ERRLOG: .IF EQ MMG$T .ADDR #MBUFF,R2 .IFF MOV @#KISAR1,R1 MOV #MBUFF,R2 $REL .-2 MBUFF DUX MOV #ERLBUF,R4 $REL .-2 ERLBUF DUR MOV R4,R3 BIC #^C<77>,R4 ADD #BEGREL,R4 ASH #-6,R3 BIC #^C<1777>,R3 MOV #P.MSIZ/2,R5 MOV H$P1EX,R0 CALL BLKMOV(R0) MOV #ERLBUF,R2 $REL .-2 ERLBUF DUR .ENDC ADD #P.UNIT,R2 .IF EQ MMG$T MOV DUCQE,R5 .IFF MOV H$CQE,R5 .ENDC MOV RETRY,R4 ADD #DU$COD*400-1,R4 MOV #NRETRY*400+20.,R3 .IF EQ MMG$T CALL @$ELPTR .IFF CALL @H$ELPT .ENDC RTS PC .ENDC .SBTTL ROUTINE TO RETURN THE VOLUME SIZE (SPFUN 373) GETSIZ: MOV P.UNSZ(R5),VOLSIZE MOV P.UNSZ+2(R5),VOLSIZE+2 .BR SNDSIZ SNDSIZ: .IF EQ MMG$T MOV DUCQE,R4 MOV .UTTAB,R5 .IFF MOV H$CQE,R4 MOV X.UTTAB,R5 .ENDC MOV VOLSIZE,-(SP) BNE 5$ DEC (SP) 5$: TST VOLSIZE+2 BEQ 10$ CMPB UT.PART(R5),VOLSIZ+2 BGE 10$ MOV #177777,(SP) 10$: .IF NE MMG$T JSR PC,@H$PTWR .IFF MOV (SP)+,@Q$BUFF(R4) .ENDC JMP DUEXIT .SBTTL SUBROUTINE TO INITIALIZE MSCP COMMAND BUFFER GETCBF: MOV R0,-(SP) MOV R1,-(SP) .IF EQ MMG$T .ADDR #MBUFF,R4 MOV R4,MRING CLR MRING+2 .IFF MOV XPHYSL,R0 MOV XPHYSH,R1 ADD #MBUFF-DUXBASE,R0 ADC R1 MOV R0,XMRING MOV R1,XMRING+2 MOV #MBUFF,R4 $REL .-2 MBUFF DUX .IFTF MOV #P.CSIZ/2,-(SP) .ASSUME MBUFF EQ CBUFF+P.CSIZ+4 1$: CLR -(R4) DEC (SP) BPL 1$ SUB (SP)+,-(R4) MOV #60,-4(R4) MOV #60,P.CSIZ(R4) .IFT MOV R4,CRING CLR CRING+2 .IFF MOV XPHYSL,R0 MOV XPHYSH,R1 ADD #CBUFF-DUXBASE,R0 ADC R1 MOV R0,XCRING MOV R1,XCRING+2 .IFTF MOV (R5)+,P.OPCD(R4) .IFT MOV @.UTTAB,P.UNIT(R4) .ASSUME UT.UNIT EQ 0 .IFF MOV #X.UTTAB+2,R1 $REL .-2 X.UTTAB+2 DUX MOV @-(R1),P.UNIT(R4) .IFTF MOV (SP)+,R1 MOV (SP)+,R0 RTS R5 .ENDC .SBTTL SUBROUTINE TO BYPASS RT-11 AND ISSUE MSCP DIRECTLY .ENABL LSB BYPASS: ADD #Q$BUFF-Q$BLKN,R5 .IF EQ MMG$T MOV (R5)+,R4 CLR R0 .IFF CALL @H$MPPT MOV (SP)+,R4 MOV (SP)+,R0 ASH #-4,R0 .ENDC ADD #4,R4 ADC R0 .IF EQ MMG$T MOV R4,MRING MOV R0,MRING+2 .IFF MOV R4,XMRING MOV R0,XMRING+2 .ENDC .IF EQ MMG$T BNE 30$ .ENDC ADD #P.MSIZ+4,R4 ADC R0 .IF EQ MMG$T MOV R4,CRING MOV R0,CRING+2 .IFF MOV R4,XCRING MOV R0,XCRING+2 .ENDC .IF EQ MMG$T BNE 30$ .ENDC MOV (R5),R0 BEQ 20$ .IF EQ MMG$T CLR R1 MOV R0,R2 .IFF MOV H$P1EX,R1 CALL CVAPHY(R1) .ENDC MOV Q$BUFF-Q$WCNT(R5),R4 ADD #<4+P.MSIZ+4>+P.BUFF,R4 .IF NE MMG$T MOV Q$PAR-Q$WCNT(R5),10$ JSR R0,@H$P1EX .WORD 10$-. .ENDC MOV R2,(R4)+ MOV R1,(R4)+ .IF NE MMG$T 10$: .BLKW .ENDC 20$: RTS PC .IF EQ MMG$T 30$: TST (SP)+ JMP DUHERR .ENDC .DSABL LSB .SBTTL ROUTINE TO RETURN THE UNIT TRANSLATION TABLE .ENABL LSB DOTAB: MOV R0,-(SP) MOV #UT.ESZ/2*8.+2,R0 MOV R5,R4 .IF EQ MMG$T .ADDR #DUTAB,R5 .IFF MOV #XDUTAB,R5 $REL .-2 XDUTAB DUX .ENDC TST Q$WCNT(R4) BMI 20$ 10$: .IF EQ MMG$T MOV (R5)+,@Q$BUFF(R4) ADD #2,Q$BUFF(R4) .IFF MOV (R5)+,-(SP) CALL @H$PTWRD .ENDC DEC R0 BGT 10$ BR 40$ 20$: ASL R0 .IF EQ MMG$T 30$: MOVB @Q$BUFF(R4),(R5)+ INC Q$BUFF(R4) .IFF 30$: JSR PC,@H$GTBY MOVB (SP)+,(R5)+ .ENDC DEC R0 BGT 30$ 40$: MOV (SP)+,R0 JMP DUEXIT .DSABL LSB .IF NE DU$BBR .SBTTL GETUS - Save information necessary for BBR support GETUS: MOV #MBUFF,R5 $REL .-2 MBUFF DUX MOV ACTBBR,R1 MOV P.UNFL(R5),(R1)+ BPL 10$ JMP DISPAT 10$: MOV P.UNSZ(R5),(R1)+ .ASSUME BB.MAX EQ 2 MOV P.UNSZ+2(R5),(R1)+ DO IGETUS,THEN,SAVUS SAVUS: MOV #MBUFF,R5 $REL .-2 MBUFF DUX MOV ACTBBR,R1 ADD #BB.RCT,R1 MOV P.RCTS(R5),(R1)+ .ASSUME BB.RCT EQ 6 MOV P.TRCK(R5),(R1)+ .ASSUME BB.TRK EQ 10 MOV P.RBNS(R5),@R1 .ASSUME BB.RBN EQ 12 .ASSUME BB.COP EQ 13 BIT #UF.WPH,P.UNFL(R5) BEQ ONLBBR JMP DISPAT .ENDC .IF NE DU$BBR .SBTTL BBR - Host Bad Block Replacement Main Entry points .ENABL LSB BBFND: CLR BBRECU MOV ACTBBR,R2 TST @R2 BMI 20$ CALL CLRWRK .IF EQ MMG$T MOV DUCQE,R5 .IFF MOV H$CQE,R5 .ENDC CMPB #SP.MUC,Q$FUNC(R5) BNE 77$ .IF NE MMG$T MOV Q$PAR(R5),R1 MOV Q$BUFF(R5),R5 ADD #<4>,R5 .HP1EX R1 MOV P.FBBK(R5),R3 MOV P.FBBK+2(R5),R4 .HP1EN MOV R3,BLBNL MOV R4,BLBNH BR 88$ .ENDC 77$: MOV MBUFF+P.FBBK,BLBNL MOV MBUFF+P.FBBK+2,BLBNH 88$: .HP1EX P1LOW MOV @#STATU$,R1 $REL .-2 STATU$ DUR .HP1EN MOV R1,OLDSTA DO IGETUS,THEN,CKWRTP CKWRTP: MOV ACTBBR,R2 MOV MBUFF+P.UNFL,R5 MOV OLDSTA,R4 BIT #UF.WPH,R5 BEQ CONBBR MOV R4,R1 20$: JMP NOBBR ONLBBR: MOV ACTBBR,R2 CALL CLRWRK BIS #US.OLP,USTAT .BR CONBBR CONBBR: MOV SP,(PC)+ SAVESP: .WORD 0 CALL RCONTX 10$: CLR BBRECU BR DOBBR .DSABL LSB CLRWRK: MOV #XFRSZ,R3 $REL .-2 XFRSZ DUX MOV #WRKSIZ,R4 ASR R4 10$: CLR (R3)+ DEC R4 BNE 10$ RTS PC DOBBR: MOV #SEC0,DSKBF $REL .-4 SEC0 DUX MOV BB.MAX(R2),LBNL MOV BB.MAX+2(R2),LBNH CALL MULRD BCC 20$ JMP STEP18 20$: BIT #US.OLP,USTAT BEQ READIT .ENABL LSB MOV #SEC0,R0 $REL .-2 SEC0 DUX ADD #RCTFLG,R0 CALL INTEGA 21$: BIT #,(R0) BEQ 35$ MOV 4(R0),BLBNL MOV 6(R0),BLBNH MOV BB.MAX(R2),LBNL MOV BB.MAX+2(R2),LBNH ADD #1,LBNL ADC LBNH MOV #MD.CMP,IOMOD MOV #LBN,DSKBF $REL .-4 LBN DUX CALL MULRD BIT #RF.P1,(R0) BEQ 30$ JMP ALLOUT 30$: CALL P2REC BIS #BIT4,INTFLG JMP RCTUPD 35$: JMP STEP18 40$: .BR READIT .DSABL LSB READIT: .ENABL LSB MOV #4,R4 30$: MOV #LBN,R3 $REL .-2 LBN DUX MOV R3,DSKBF MOV #256.,R0 10$: CLR (R3)+ DEC R0 BNE 10$ MOV BLBNL,LBNL MOV BLBNH,LBNH MOV #OP.RD,IOFUN MOV #MD.CMP,IOMOD BIS #BIT1,INTFLG CALL DSKIO BCS 15$ BIC #BIT1,INTFLG BR 20$ 15$: CMP #ST.DAT,IOST+2 BEQ 20$ 17$: DEC R4 BNE 30$ 20$: MOV BB.MAX(R2),LBNL MOV BB.MAX+2(R2),LBNH ADD #1,LBNL ADC LBNH MOV #MD.CMP,IOMOD CALL MULWT BCC PHASE1 JMP STEP18 .DSABL LSB PHASE1: MOV #SEC0,DSKBF $REL .-4 SEC0 DUX MOV BB.MAX(R2),LBNL MOV BB.MAX+2(R2),LBNH 5$: CALL MULRD BCC 10$ JMP STEP18 10$: BIS #RF.P1,SEC0+RCTFLG MOV #MD.CMP,IOMOD BIC #RF.FE,SEC0+RCTFLG BIT #BIT1,INTFLG BEQ 12$ BIS #RF.FE,SEC0+RCTFLG BIC #BIT1,INTFLG 12$: MOV #SEC0,R0 $REL .-2 SEC0 DUX ADD #RCTFLG,R0 CMP (R0)+,(R0)+ MOV BLBNL,(R0)+ MOV BLBNH,(R0)+ MOV #SEC0,DSKBF $REL .-4 SEC0 DUX MOV BB.MAX(R2),LBNL MOV BB.MAX+2(R2),LBNH CALL MULWT BCC ALLOUT JMP STEP17 .ENABL LSB ALLOUT: MOV #8.,R5 BIC #BIT3,INTFLG RTEST: MOV #4,R4 10$: MOV #RCTBF,DSKBF $REL .-4 RCTBF DUX MOV #OP.RD,IOFUN MOV #,IOMOD MOV BLBNL,LBNL MOV BLBNH,LBNH CALL DSKIO TST IOST+2 BNE 11$ .ASSUME ST.SUC EQ 0 BIT #100000,IOST BEQ 12$ BIS #BIT3,INTFLG BR SCAN 11$: CMP #ST.DAT,IOST+2 BEQ 12$ BIS #BIT3,INTFLG BR SCAN 12$: DEC R4 BNE 10$ RWTEST: MOV #OP.WR,IOFUN MOV #LBN,DSKBF $REL .-4 LBN DUX MOV #,IOMOD CALL DSKIO BCC 13$ BIS #BIT3,INTFLG BR SCAN 13$: MOV #4,R4 20$: MOV #OP.RD,IOFUN MOV #RCTBF,DSKBF $REL .-4 RCTBF DUX MOV #,IOMOD CALL DSKIO TST IOST+2 BNE 21$ .ASSUME ST.SUC EQ 0 BIT #100000,IOST BEQ 22$ BIS #BIT3,INTFLG BR SCAN 21$: CMP #ST.DAT,IOST+2 BEQ 22$ BIS #BIT3,INTFLG BR SCAN 22$: DEC R4 BNE 20$ TSTPAT: MOV #256.,R4 MOV #RCTBF,R0 $REL .-2 RCTBF DUX MOV #LBN,R3 $REL .-2 LBN DUX 30$: MOV (R3)+,@R0 COM (R0)+ DEC R4 BNE 30$ MOV #OP.WR,IOFUN MOV #,IOMOD MOV #RCTBF,DSKBF $REL .-4 RCTBF DUX CALL DSKIO BCS SCAN MOV #4,R4 40$: MOV #,IOMOD MOV #OP.RD,IOFUN MOV #RCTBF,DSKBF $REL .-4 RCTBF DUX CALL DSKIO TST IOST+2 BNE 41$ BIS #BIT3,INTFLG BR SCAN 41$: CMP #ST.DAT,IOST+2 BEQ 42$ BIS #BIT3,INTFLG BR SCAN 42$: DEC R4 BNE 40$ DEC R5 BNE RWTEST BR SCAN .DSABL LSB .ENABL LSB SCAN: CALL WTSAV BCC 11$ BIS #BIT3,INTFLG BR STEP9 11$: MOV BLBNL,LBNL MOV BLBNH,LBNH MOV #RCTBF,DSKBF $REL .-4 RCTBF,DUX MOV #OP.RD,IOFUN CLR IOMOD BIS #BIT5,INTFLG CALL DSKIO TST IOST+2 BEQ 3$ CMP #ST.DAT,IOST+2 BNE 5$ BIT #RF.FE,SEC0+RCTFLG BEQ 5$ 3$: PUSH MOV #400,R0 MOV #LBN,R1 $REL .-2 LBN DUX MOV #RCTBF,R2 $REL .-2 RCTBF DUX 4$: CMP (R1)+,(R2)+ BNE 6$ DEC R0 BNE 4$ BIC #BIT5,INTFLG 6$: POP 5$: BIT #,INTFLG BEQ 7$ BIC #,INTFLG BR STEP9 7$: JMP RESDAT STEP9: SCAN1: CMP #2,BBRECU BNE 8$ 12$: JMP STEP16 8$: INC BBRECU CALL HASH CALL SRCH BCS 12$ .BR PHASE2 .DSABL LSB PHASE2: BIC #RF.P1,SEC0+RCTFLG BIS #RF.P2,SEC0+RCTFLG MOV #SEC0,R0 $REL .-2 SEC0 DUX ADD #URBNL,R0 MOV NRBNL,(R0)+ MOV NRBNH,(R0)+ MOV ORBNL,(R0)+ MOV ORBNH,(R0) TST ORBNL BNE 10$ TST ORBNH BEQ 20$ 10$: BIS #RF.BR,SEC0+RCTFLG 20$: MOV #SEC0,DSKBF $REL .-4 SEC0 DUX MOV BB.MAX(R2),LBNL MOV BB.MAX+2(R2),LBNH MOV #MD.CMP,IOMOD CALL MULWT BCC RCTUPD JMP STEP16 RCTUPD: CALL NEWBF MOV #MD.CMP,IOMOD CALL MULRD BCS 25$ MOV R0,R3 ADD NLBNO,R3 MOV BLBNL,(R3)+ MOV BLBNH,(R3) BIC #170000,(R3) BIS #DF.ALL,(R3) CMP PLBNO,NLBNO BNE 10$ CMP PLBNL,NLBNL BNE 10$ CMP PLBNH,NLBNH BEQ 15$ 10$: BIS #DF.SEC,(R3) 15$: BIT #RF.BR,SEC0+RCTFLG BEQ 40$ CMP OLBNL,NLBNL BNE 20$ CMP OLBNH,NLBNH BEQ 30$ 20$: CALL OLDBF MOV R0,DSKBF CALL MULRD 25$: BCC 30$ JMP STEP16 30$: MOV R0,R3 ADD OLBNO,R3 MOV #DF.UNU,2(R3) CLR (R3) MOV R0,DSKBF MOV #MD.CMP,IOMOD CALL MULWT BCC 35$ JMP STEP15 35$: CMP OLBNL,NLBNL BNE 40$ CMP OLBNH,NLBNH BEQ REPLBN 40$: CALL NEWBF MOV R0,DSKBF MOV #MD.CMP,IOMOD CALL MULWT BCC REPLBN JMP STEP15 .ENABL LSB REPLBN: MOV #OP.RPL,IOFUN MOV NRBNH,RPLBH MOV NRBNL,RPLBL MOV BLBNH,LBNH MOV BLBNL,LBNL CLR IOMOD CMP PLBNO,NLBNO BNE 10$ CMP PLBNL,NLBNL BNE 10$ CMP PLBNH,NLBNH BNE 10$ MOV #MD.PRI,IOMOD 10$: CALL GENIO BCC 11$ JMP 15$ 11$: BIT #BIT4,INTFLG BEQ 12$ BIC #BIT4,INTFLG JMP 20$ 12$: MOV #OP.RD,IOFUN MOV #RCTBF,DSKBF $REL .-4 RCTBF DUX CLR IOMOD CALL DSKIO BCC 15$ CMP IOST+2,#ST.DAT BEQ 20$ JMP SCAN1 15$: MOV BLBNL,LBNL MOV BLBNH,LBNH CALL WTSAV MSCP OP.SUC MOV R4,R2 MOV #IOP.NR,INTEOP DO SETSWP,THEN,SINK SINK: CLR R1 .HP1EX P1LOW JMP @#LOWONE $REL .-2 LOWONE DUR .HP1EN DUPSECT LOWONE: MOV 2(SP),SP ADD #6,SP CLR SYNBLK+2 .ADDR #SYNBLK,R4 MOV @#SYSPTR,R5 JSR R5,@SYNCH(R5) NOP MOV R0,R1 JSR R2,SAVE25 .P1EXT P1HIGH JMP @#HIONE $REL .-2 HIONE DUX .P1END SYNBLK: .WORD 0,0,0,0,2,-1,0 SAVE25: MOV R3,-(SP) MOV R4,-(SP) MOV R5,-(SP) CALL @R2 MOV (SP)+,R5 MOV (SP)+,R4 MOV (SP)+,R3 MOV (SP)+,R2 RETURN DUXPSECT HIONE: MOV 2(SP),SP ADD #6,SP CMP #2,R1 BNE 17$ MOV #MSG1,R0 $REL .-2 MSG1 DUX .PRINT MOV #CRLF,R0 $REL .-2 CRLF DUX .PRINT MOV #MSG2,R0 $REL .-2 MSG2 DUX .PRINT MOV #CRLF,R0 $REL .-2 CRLF DUX .PRINT 17$: JMP STEP18 SETSWP: MOV R2,R4 BIS #MD.SWP,P.MOD(R4) BIS #UF.WPS,P.UNFL(R4) RTS PC 20$: MOV #OP.WR,IOFUN MOV #LBN,DSKBF $REL .-4 LBN DUX CLR IOMOD BIT #RF.FE,SEC0+RCTFLG BEQ 30$ MOV #MD.ERR,IOMOD 30$: CALL DSKIO BCC 31$ JMP SCAN1 31$: MOV #OP.RD,IOFUN MOV #RCTB1,DSKBF $REL .-4 RCTB1 DUX MOV #MD.CMP,IOMOD CALL DSKIO .ASSUME ST.SUC EQ 0 TST IOST+2 BNE 40$ BIT #100000,IOST BEQ 44$ JMP SCAN1 40$: CMP #ST.DAT,IOST+2 BEQ 42$ JMP SCAN1 42$: BIT #RF.FE,SEC0+RCTFLG BNE 44$ JMP SCAN1 44$: BIC #BIT6,INTFLG PUSH MOV #400,R0 MOV #LBN,R1 $REL .-2 LBN DUX MOV #RCTB1,R2 $REL .-2 RCTB1 DUX 45$: CMP (R1)+,(R2)+ BNE 46$ DEC R0 BNE 45$ BIS #BIT6,INTFLG 46$: POP BIT #BIT6,INTFLG BNE 47$ JMP SCAN1 47$: .BR RESDAT .DSABL LSB RESDAT: CALL FFINSZ BCC STEP14 BR STEP17 STEP14: JMP DUEXIT STEP15: CALL UNALL BCC STEP16 STEP16: CALL WTSAV BCC STEP17 STEP17: CALL FFINSZ BCC STEP18 STEP18: BIT #US.OLP,USTAT BNE 10$ CLR USTAT CLR OOPS CLR INTFLG JMP DUHERR 10$: JMP START .ENDC .IF NE DU$BBR .SBTTL BBRSUB - BBR subroutines .SBTTL DSKIO - INITIATE DISK I/O ROUTINE DSKIO:: MOV #512.,XFRSZ GENIO: PUSH MOV XPHYSL,R4 MOV XPHYSH,R5 MOV DSKBF,R0 SUB #BEGREL,R0 ADD R0,R4 ADC R5 MOV R4,DPHYSL MOV R5,DPHYSH MSCP OP.NIL MOV #X.UTTAB+2,R1 $REL .-2 X.UTTAB+2 DUX MOV @-(R1),P.UNIT(R4) MOV IOFUN,P.OPCD(R4) MOV IOMOD,P.MOD(R4) CMP #OP.RPL,P.OPCD(R4) BEQ 20$ MOV LBNH,P.LBN+2(R4) MOV LBNL,P.LBN(R4) MOV XFRSZ,P.BCNT(R4) MOV DPHYSH,P.BUFF+2(R4) MOV DPHYSL,P.BUFF(R4) BR 30$ 20$: MOV RPLBH,P.RBN+2(R4) MOV RPLBL,P.RBN(R4) MOV LBNH,P.LBN+2(R4) MOV LBNL,P.LBN(R4) 30$: CALL SCONTX MOV #MBUFF,R4 $REL .-2 MBUFF DUX MOV P.STS(R4),-(SP) MOVB P.FLGS(R4),-(SP) BIT #MD.ERR,IOMOD BEQ 35$ BIC #ST.DAT,2(SP) 35$: CLC MOVB (SP)+,IOST+1 MOV (SP),IOST+2 BIC #^C,(SP) MOVB (SP)+,IOST BEQ 50$ 40$: SEC 50$: MOV #0,IOMOD POP RETURN .ENDC .IF NE DU$BBR .SBTTL FFINSZ - UPDATE TABLE SECTOR 0 TO SHOW RCT IS FINISHED FFINSZ:: MOV #SEC0,R3 $REL .-2 SEC0 DUX ADD #RCTFLG,R3 MOV #8.,R4 10$: CLR (R3)+ DEC R4 BNE 10$ MOV #SEC0,DSKBF $REL .-4 SEC0 DUX MOV BB.MAX+2(R2),LBNH MOV BB.MAX(R2),LBNL MOV #MD.CMP,IOMOD CALL MULWT RETURN .SBTTL HASH - PRIMARY REPLACEMENT CONTROL TABLE HASH ALGORITHM HASH:: PUSH MOV R1,R4 MOV R2,R5 MOV BB.TRK(R5),R0 MOV BLBNH,R1 MOV BLBNL,R2 CALL DDIV MOV R2,R3 MOV R1,R2 CLR R0 BISB BB.RBN(R5),R0 CALL DMUL MOV R1,R2 MOV R0,R1 MOV #128.,R0 CALL DDIV ADD BB.MAX(R5),R2 ADC R1 ADD BB.MAX+2(R5),R1 ADD #2,R2 ADC R1 MOV R2,PLBNL MOV R1,PLBNH ASL R0 ASL R0 MOV R0,PLBNO POP RETURN .SBTTL MULRD - PERFORM MULTIPLE-COPY READ FROM DISK MULRD:: PUSH PUSH MOV ACTBBR,R2 MOV BB.RCT(R2),R4 CLR R0 BISB BB.COP(R2),R0 MOV #OP.RD,IOFUN 10$: MOV IOMOD,-(SP) CALL DSKIO MOV (SP)+,IOMOD BCC 30$ ADD R4,LBNL ADC LBNH DEC R0 BNE 10$ SEC 30$: POP POP RETURN .SBTTL MULWT - PERFORM MULTIPLE-COPY WRITE TO DISK MULWT:: PUSH PUSH MOV BB.RCT(R2),R3 CLR R0 BISB BB.COP(R2),R0 MOV R0,R4 MOV #OP.WR,IOFUN 10$: MOV IOMOD,-(SP) CALL DSKIO MOV (SP)+,IOMOD BCC 20$ CMPB IOST,#ST.DAT BNE 25$ BIS #MD.ERR,IOMOD CALL DSKIO 19$: DEC R4 20$: ADD R3,LBNL ADC LBNH DEC R0 BNE 10$ TST R4 BNE 30$ 25$: SEC 30$: POP POP RETURN .SBTTL NEWBF - SET QIO PARAMETERS FOR NEW RBN .SBTTL OLDBF - SET QIO PARAMETERS FOR OLD RBN .ENABL LSB NEWBF:: MOV #RCTBF,R0 $REL .-2 RCTBF DUX MOV NLBNL,LBNL MOV NLBNH,LBNH BR 10$ OLDBF:: MOV #RCTB1,R0 $REL .-2 RCTB1 DUX MOV OLBNL,LBNL MOV OLBNH,LBNH 10$: MOV R0,DSKBF RETURN .DSABL LSB .SBTTL P1REC - RESTORE DATA FOR PHASE 1 RECOVERY .SBTTL P2REC - RESTORE DATA FOR PHASE 2 RECOVERY P2REC:: PUSH CALL HASH ADD #8.,R0 MOV #NRBNL,R3 $REL .-2 NRBNL DUX MOV (R0),(R3)+ MOV (R0)+,R2 MOV (R0),(R3)+ MOV (R0)+,R1 PUSH CALL RBNDIV POP MOV (R0),(R3)+ MOV (R0)+,R2 MOV (R0),(R3)+ MOV (R0)+,R1 BNE 10$ TST R2 BEQ 20$ 10$: CALL RBNDIV 20$: POP RETURN RBNDIV: MOV #128.,R0 CALL DDIV MOV R2,(R3)+ MOV R1,(R3)+ ASH #2,R0 MOV R0,(R3)+ MOV ACTBBR,R5 ADD BB.MAX(R5),-6(R3) ADC -4(R3) ADD BB.MAX+2(R5),-4(R3) ADD #2,-6(R3) ADC -4(R3) RETURN .SBTTL SRCH - REPLACEMENT CONTROL TABLE SEARCH ALGORITHM SRCH:: PUSH CLR ORBNL CLR ORBNH CLR R0 MOV PLBNO,R4 ASR R4 ASR R4 MOV #RCTBF,DSKBF $REL .-4 RCTBF DUX MOV PLBNL,LBNL MOV PLBNH,LBNH SNEXT: CLR IOMOD CALL MULRD BCS SXIT CLR R2 STEST: MOV R4,R1 ADD R2,R1 BLT SBMP CMP R1,#127. BGT SBMP ASL R1 ASL R1 TST RCTBF+2(R1) $REL .-2 RCTBF+2 DUX BNE SALL0 MOV #NRBNL,R3 $REL .-2 NRBNL DUX CALL SRBN CLC BR SXIT SALL0: BIT #DF.ALL,RCTBF+2(R1) $REL .-2 RCTBF+2 DUX BEQ SNULL MOV RCTBF+2(R1),R3 $REL .-2 RCTBF+2 DUX BIC #,R3 CMP BLBNH,R3 BNE SNULL CMP BLBNL,RCTBF(R1) $REL .-2 RCTBF DUX BNE SNULL MOV #ORBNL,R3 $REL .-2 ORBNL DUX BIS #RF.BR,SEC0+RCTFLG CALL SRBN BR SBMP SNULL: TST RCTBF+2(R1) $REL .-2 RCTBF+2 DUX BPL SBMP TST R0 SEC BNE SXIT INC R0 MOV ACTBBR,R4 MOV BB.MAX(R4),LBNL MOV BB.MAX+2(R4),LBNH ADD #2,LBNL ADC LBNH CLR R4 BR SNEXT SBMP: NEG R2 BMI STEST INC R2 CMP R2,#128. BLT STEST CLR R4 ADD #1,LBNL ADC LBNH BR SNEXT SRBN: PUSH ; SAVE REGISTERS MOV LBNL,R3 MOV LBNH,R2 MOV ACTBBR,R0 SUB BB.MAX(R0),R3 SBC R2 SUB BB.MAX+2(R0),R2 SUB #2,R3 SBC R2 MOV #128.,R0 CALL DMUL MOV 10(SP),R2 ASR R2 ASR R2 ADD R2,R1 ADC R0 MOV 4(SP),R3 MOV R1,(R3)+ MOV R0,(R3)+ MOV LBNL,(R3)+ MOV LBNH,(R3)+ ASL R2 ASL R2 MOV R2,(R3) SXIT: POP ; RESTORE REGISTERS RETURN .SBTTL UNALL - MARK RBN UNALLOCATED UNALL:: PUSH CALL NEWBF MOV R0,DSKBF MOV #MD.CMP,IOMOD CALL MULRD MOV R0,R5 ADD NLBNO,R5 CLR (R5) CLR 2(R5) MOV #MD.CMP,IOMOD CALL MULWT BIT #RF.BR,SEC0+RCTFLG BEQ 30$ CALL OLDBF MOV R0,DSKBF MOV #MD.CMP,IOMOD CALL MULRD MOV R0,R5 ADD OLBNO,R5 MOV BLBNL,(R5)+ MOV BLBNH,(R5) BIS #DF.ALL,(R5) CMP PLBNO,OLBNO BNE 10$ CMP PLBNL,NLBNL BNE 10$ CMP PLBNH,NLBNH BEQ 20$ 10$: BIS #DF.SEC,(R5) 20$: MOV #MD.CMP,IOMOD CALL MULWT 30$: POP RETURN .SBTTL WTSAV - WRITE SAVED DATA BACK OUT TO DISK WTSAV:: CLR IOMOD MOV BLBNL,LBNL MOV BLBNH,LBNH MOV #OP.WR,IOFUN BIT #RF.FE,SEC0+RCTFLG BEQ 10$ BIS #MD.ERR,IOMOD 10$: MOV #LBN,DSKBF $REL .-4 LBN DUX CALL DSKIO RETURN .SBTTL DDIV - DOUBLE PRECISION DIVIDE ROUTINE DDIV:: MOV R3,-(SP) MOV #32.,R3 MOV R0,-(SP) CLR R0 10$: ASL R2 ROL R1 ROL R0 CMP R0,(SP) BLO 20$ SUB (SP),R0 INC R2 20$: SOB R3,10$ TST (SP)+ MOV (SP)+,R3 RETURN .SBTTL DMUL - DOUBLE PRECISION MULTIPLY DMUL:: MOV R0,-(SP) CLR R0 CLR R1 10$: TST (SP) BEQ 30$ ROR (SP) BCC 20$ ADD R3,R1 ADC R0 ADD R2,R0 20$: ASL R3 ROL R2 BR 10$ 30$: TST (SP)+ RETURN .ENDC .IF NE DU$BBR .SBTTL RCONTX - Restore the context before the interrupt. .ENABL LSB RCONTX: MOV (SP)+,(PC)+ RBACK: .WORD 0 CLR BBRON MOV #CONTEXT,R5 $REL .-2 CONTEXT DUX MOV (R5)+,R0 BEQ 20$ CLR CONTEXT MOV -(R0),R4 MOV -(R0),R3 MOV -(R0),R2 MOV -(R0),R1 10$: MOV -(R0),-(SP) CMP R0,R5 BNE 10$ JMP @(SP)+ 20$: JMP @RBACK .DSABL LSB .ENDC .IF NE DU$BBR .SBTTL SCONTX - Save the context - GO START COMMAND! .ENABL LSB SCONTX: MOV #CONTEXT,R0 $REL .-2 CONTEXT DUX ADD #2,R0 MOV (SP)+,(R0)+ 10$: MOV (SP)+,(R0)+ CMP SP,SAVESP BNE 10$ MOV R1,(R0)+ MOV R2,(R0)+ MOV R3,(R0)+ MOV R4,(R0)+ MOV R0,CONTEXT MOV #-1,BBRON JMP POLL CONTEXT:.WORD 0 .REPT 60 .WORD 125252 .ENDR .DSABL LSB .ENDC .IF NE DU$BBR .SBTTL INTEGA - INTEGRITY CHECKS ON RCT BLOCK 0 .ENABL LSB INTEGA: PUSH MOV (R0),R1 BIC #,R1 TST R1 BNE 300$ TST 2.(R0) BNE 300$ BIT #RF.P1,(R0) BEQ 100$ BIT #RF.P2,(R0) BNE 300$ BIT #RF.BR,(R0) BNE 300$ TST 8.(R0) BNE 300$ TST 10.(R0) BNE 300$ TST 12.(R0) BNE 300$ TST 14.(R0) BNE 300$ TST 4.(R0) BNE 20$ TST 6.(R0) BEQ 300$ 20$: CMP 6.(R0),BB.MAX+2(R2) BHI 300$ BEQ 75$ BR 140$ 75$: CMP 4.(R0),BB.MAX(R2) BHI 300$ BR 140$ 100$: BIT #RF.P2,(R0) BEQ 115$ TST 4.(R0) BNE 105$ TST 6.(R0) BEQ 300$ 105$: CMP 6.(R0),BB.MAX+2(R2) BHI 300$ BEQ 107$ BR 109$ 107$: CMP 4.(R0),BB.MAX(R2) BHI 300$ 109$: BIT #RF.BR,(R0) BNE 120$ 110$: TST 12.(R0) BNE 300$ TST 14.(R0) BNE 300$ BR 140$ 115$: TST 4.(R0) BNE 300$ TST 6.(R0) BNE 300$ TST 8.(R0) BNE 300$ TST 10.(R0) BNE 300$ TST 12.(R0) BNE 300$ TST 14.(R0) BNE 300$ BR 140$ 120$: TST 12.(R0) BNE 140$ TST 14.(R0) BEQ 300$ 140$: POP RETURN 300$: POP CALL FFINSZ SEC RETURN .DSABL LSB .ENDC .IF NE MMG$T DUXEND:: DUXSIZ ==: DUXEND - DUXBAS .IF EQ DU$BBR .ASSUME . LE DUXBAS+<10000> .IFF .ASSUME . LE DUXBAS+<20000> .ENDC .ENDC DUPSECT .SBTTL BOOTSTRAP DRIVER .DRBOT DU,BOOT1,READ,CONTROL= . = DUBOOT+40 BOOT1: JMP @#BOOT-DUBOOT .IF NE DU$BOO .SBTTL LOACSR - load IP register from tables .ENABL LSB . = DUBOOT + 14 LOACSR: MOV BUNIT,R3 ASL R3 ASL R3 BR 100$ . = DUBOOT + 44 100$: ADD #PD.POR-DUBOOT,R3 MOV (R3)+,MUNIT MOV @R3,R3 ASL R3 BR 200$ . = DUBOOT + 70 200$: ADD #PD.CSR-DUBOOT,R3 BR 300$ . = DUBOOT + 104 300$: MOV @R3,BDUAIP RTS PC .DSABL LSB .ENDC . = DUBOOT+120 READ: TST HRDBOT BEQ READA MOV @#B$DEVU,(PC)+ BUNIT: .WORD 0 READA: .IF NE DU$BOO ASR #1 BCC 10$ JSR PC,LOACSR .ENDC 10$: MOV #NRETRY,BRETRY ASL R1 ASR #1 BCC READ1 .IF EQ DU$BOO JSR PC,ALTCHK .ENDC BINIT: DEC (PC)+ BRETRY: .WORD 0 BLT BIOELK MOV BDUAIP,R5 MOV R4,(R5)+ MOV #ISTEP1,R3 MOV #BINLST-DUBOOT,R4 1$: TST @R5 BMI BINIT BIT @R5,R3 BEQ 1$ MOV (R4)+,@R5 ASL R3 BPL 1$ CMP (R4)+,(R4)+ MOV R4,BCRING MOV R4,BMRING JSR R0,BGTBUF .WORD OP.ONL JSR PC,BDOIO .BR READ1 READ1: JSR R0,BGTBUF .WORD OP.RD MOV R0,P.LBN(R4) MOV R1,P.BCNT(R4) MOV R2,P.BUFF(R4) .BR BDOIO .ENABL LSB BDOIO: MOV BDUAIP,R3 1$: MOV #BCRING+2-DUBOOT,R4 MOV #OWN,@R4 MOV (R3)+,R5 2$: TST @R3 BMI 4$ TST @R4 BMI 2$ TST -(R4) MOV #OWN,-(R4) 3$: TST @R3 BMI 4$ TST @R4 BMI 3$ TSTB BBUFF+P.STS BIOELK: BNE BIOERR RTS PC 4$: TST (SP)+ BR BINIT .DSABL LSB BGTBUF: MOV #BBUFF-DUBOOT+P.MSIZ,R4 1$: CLR -(R4) CMP R4,#BBUFF-DUBOOT BHI 1$ MOV #P.MSIZ,-4(R4) MOV (R0)+,P.OPCD(R4) .IF EQ DU$BOO MOV BUNIT,P.UNIT(R4) .IFF MOV MUNIT,P.UNIT(R4) .ENDC RTS R0 .SBTTL BOOTSTRAP IMPURE AREA BINLST: .BYTE 0 .BYTE 0*10+0+STEP .WORD BMRING-DUBOOT .WORD 0 .WORD GO BLN: .WORD 0 BVC: .WORD 0 BBUFF: .BLKB P.MSIZ .WORD 0,0 BMRING: .WORD 0,0 BCRING: .WORD 0,0 .SBTTL ALTCHK - ALTERNATE CSR CHECK FOR FALCONS BDUAIP: .WORD DU$CSR .IF NE DU$BOO MUNIT: .WORD 0 .ENDC .IF EQ DU$BOO ALTCHK: MOV R0,-(SP) MOV @#INS.V,-(SP) MOV PC,R0 ADD #BT.INS-.,R0 MOV R0,@#INS.V CLR R0 MFPT CMP R0,#4 BNE 999$ MOV #DU$ALT,BDUAIP 999$: MOV (SP)+,@#INS.V MOV (SP)+,R0 RTS PC BT.INS: BIS #1,2(SP) RTI .ENDC .IF NE DU$BOO PD.POR: $1=0 .REPT DU$UNIT .IRP Y,\$1 .WORD DU$U'Y,DU$O'Y .ENDR $1=$1+1 .ENDR PD.CSR: .WORD DU$CSR .IF NE DU$PORTS-1 .WORD DU$CS1 .IF NE DU$PORTS-2 .WORD DU$CS2 .IF NE DU$PORTS-3 .WORD DU$CS3 .ENDC .ENDC .ENDC .ENDC .SBTTL BOOTSTRAP PRIMARY ROUTINE BOOT: MOV #10000,SP MOV R0,-(SP) BIC #^C<7>,@SP MOV (SP),BUNIT MOV #2,R0 MOV #<4*400>,R1 MOV #1000,R2 CLR (PC)+ HRDBOT: .WORD 1 JSR PC,READ MOV #READ-DUBOOT,@#B$READ MOV #B$DNAM,@#B$DEVN MOV (SP)+,@#B$DEVU JMP @#B$BOOT .DREND DU .SBTTL OVR1 - Set code overlay number 1 .PSECT SETOVR OVRBK0: BIAS ==: VALUE: .WORD 0 OFFSET: .WORD 0 .IF NE DU$BOO OFF2TA = 8.*2*2 .ENDC .SBTTL SET UNIT, PORT, PARTITION, SUCCESS AND RETRY SET.UT: DEC R3 CMP R0,#255. BHI HLP1 CMP R3,#UT.PORT BNE 10$ CMP R0,#DU$PORTS-1 BHI HLP1 10$: BIC #100000,R1 ASL R1 ASL R1 .IF NE DU$BOO MOV R1,OFFSET .ENDC .ASSUME UT.ESZ EQ 4 .ADDR #UTTAB+BIAS,R1,ADD ADD R3,R1 MOVB R0,(R1) .IF NE DU$BOO MOV R0,VALUE CMP R3,#UT.PORT BNE 20$ ADD #2,OFFSET BR 30$ 20$: CMP R3,#UT.UNIT BNE S.NOR 30$: MOV #PD.POR/1000,R3 CALL CORWRT BCS S.IGN ADD OFFSET,R2 MOV VALUE,(R2) CALL CORREA BCS S.IGN BR S.NOR .IFF BR S.NOR .ENDC .IF NE ERL$G SET.SUC: CLR R3 NOP MOV R3,$SUCS+BIAS BR S.NOR .ENDC SET.RET: CMP R0,R3 HLP1: BHI S.ERR MOV R0,$RETRY+BIAS BEQ S.ERR BR S.NOR .SBTTL SET CSR SET.CSR: CMP R0,#160000 BLO S.ERR MOV R0,VALUE MOV R3,OFFSET MOV #BLK0,R3 CALL CORWRT BCS S.IGN DEC OFFSET BNE 10$ MOV VALUE,INSCSR+BIAS+1000 10$: MOV OFFSET,R0 NEG R0 .ADDR #DISCSR+BIAS+1000,R0,ADD MOV VALUE,(R0) MOV #BLK0,R3 CALL CORREA BCS S.IGN MOV OFFSET,R3 .IF NE DU$BOO ADD #OFF2TA,OFFSET .ENDC .IF NE DU$PORTS-1 ASL R3 ASL R3 .ASSUME PC.ESZ EQ 10 .ADDR #PCTAB+BIAS,R1 ADD R3,R1 .IFF .ADDR #UDAIP+BIAS,R1 .ENDC MOV VALUE,(R1)+ .ASSUME PC.AIP EQ 0 MOV VALUE,@R1 .ASSUME PC.ASA EQ 2 ADD #2,@R1 .IF NE DU$PORTS-1 .IF EQ DU$BOO TST R3 .ASSUME PC.AIP EQ 0. BNE S.NOR .ENDC .ENDC .IF EQ DU$BOO MOV #BDUAIP/1000,R3 .IFF MOV #PD.POR/1000,R3 .ENDC CALL CORWRT BCS S.IGN .IF EQ DU$BOO MOV VALUE,(R2) .IFF ADD OFFSET,R2 MOV VALUE,(R2) .ENDC CALL CORREA BCS S.IGN BR S.NOR .SBTTL SET VECTOR(S) SET.VEC: CMP R0,#500 BHIS S.ERR .IF NE DU$PORTS-1 .ADDR #DU$VTB+BIAS,R1 DEC R3 MOV R3,-(SP) ASL R3 ADD (SP),R3 .ASSUME VT.ESZ EQ 6 ADD R3,R1 .IFF .ADDR #DUSTRT+BIAS,R1 .ENDC MOV R0,@R1 .IF NE DU$PORTS-1 ADD (SP)+,R1 .ASSUME PC.ESZ EQ 10 ADD #PCTAB-DU$VTB+PC.VEC,R1 .ASSUME VT.ESZ+2 EQ PC.ESZ .IFF .ADDR #INILST+BIAS,R1 .ENDC ASR R0 ASR R0 BIS #IE,R0 MOVB R0,@R1 BR S.NOR .SBTTL ADIOS - Common exit point for overlayed code S.NOR: CLR R2 S.IGN: CMP (PC)+,(PC)+ S.ERR: MOV #1,R2 JMP GETBK0+BIAS .SBTTL CORE - Sub/Coroutine for core reads/writes BAREA: .BYTE 17,11 .BLKW .BLKW .WORD 256. .WORD 0 CORWRT: .ADDR #BAREA+4,R1 .ADDR #1000+BIAS,R2 MOV R2,(R1) MOV #1,-(R1) TST -(R1) MOV R1,R0 EMT 375 BCS C2.ERR MOV R1,R0 DECB 1(R0) MOV R3,2(R0) EMT 375 BCS C.ERR BR C.NOR CORREA: MOV R1,R0 INCB 1(R0) MOV R3,2(R0) EMT 375 BCS C2.ERR MOV R1,R0 DECB 1(R0) MOV #1,2(R0) EMT 375 BCS C.ERR INCB 1(R1) BR C.NOR C2.ERR: MOV #2,R2 BR C.NOR C.ERR: MOV #1,R2 C.NOR: RTS PC .ASSUME <.-OVRBK0> LE OVRSIZ .SBTTL SPCDRPTR - SPecial DRPTR codes. . = OVRBK0 + BLK OVRBK1: .SBTTL ONCE - Load/Fetch once only code. ONCE:: MOV R2,SSLOT MOV R4,SRDRTN MOV R5,SENTRY MOV @R5,R3 .IF EQ DU$BOO CALL FALCON .ENDC .IF NE DU$PORTS-1 CALL CKPORT .ENDC .IF NE MMG$T .ENABL LSB MOV @#SYSPTR,R4 MOV P1EXT(R4),R4 .ADDR #DUNAME,R5 CALL FINDGR(R4) BCS GETGBL MOV GR.ADR(R1),P1HIGH-DUBASE(R3) MOV P1HIGH-DUBASE(R3),R1 BR 50$ .IIF EQ DU$BBR MEMDUX =: 100 .IIF NE DU$BBR MEMDUX =: 200 GETGBL: MOV @#SYSPTR,R4 MOV MEMPTR(R4),R0 ADD R4,R0 MOV CORPTX(R0),R5 ADD R4,R5 20$: CMP #-1,(R5)+ BNE 20$ 30$: CMP #-1,@R5 BEQ D.BAD TST @R5 BEQ 40$ ADD #GR.ESZ,R5 BR 30$ 40$: MOV P1EXT(R4),R0 MOV #MEMDUX,R2 MOV R3,-(SP) CALL XALLOC(R0) MOV (SP)+,R3 BCS D.BAD MOV R2,(R5)+ MOV R1,(R5)+ MOV R1,P1HIGH-DUBASE(R3) MOV #GR.PVT,(R5)+ MOV #DU$NAM,(R5)+ MOV #<^R$>,@R5 50$: CLR R0 ASHC #6,R0 MOV R0,PHYSH-DUBASE(R3) MOV R1,PHYSL-DUBASE(R3) CALL UPDUX BCS D.BAD .DSABL LSB .ENDC D.GOO: TST (PC)+ D.BAD: SEC RETURN DUNAME: .WORD DU$NAM .RAD50 /$ / SENTRY: .WORD 0 SSLOT: .WORD 0 SRDRTN: .WORD 0 .IF NE MMG$T .SBTTL UPDUX - Move psect DUX to high memory .ENABL LSB UPDUX:: MOV #XMRING,R2 $REL .-2 XMRING DUX SUB #BEGREL,R2 ADD R2,R1 ADC R0 MOV R1,MRPTR-DUBASE(R3) MOV R0,MRPTR+2-DUBASE(R3) MOV @#KISAR1,-(SP) MOV P1HIGH-DUBASE(R3),@#KISAR1 MOV SENTRY,R2 MOV SSLOT,R0 ASL R0 ADD R2,R0 ADD #2,R0 MOV @R0,R0 DEC R0 MOV #20000,R5 ADD #DUXBAS/1000,R0 MOV #DUXSIZ,R4 30$: CMP R4,#BLK BGT 40$ MOV R4,R1 BR 44$ 40$: MOV #BLK,R1 44$: ASR R1 .ADDR #ONCBUF,R2 MOV R1,-(SP) CALL @SRDRTN MOV (SP)+,R1 BCS 100$ CALL STORUP SUB #BLK,R4 BLE 45$ INC R0 BR 30$ 45$: MOV #LN.CMD,R1 $REL .-2 LN.CMD DUX MOV #P.CSIZ+4,R2 60$: CLR (R1)+ DEC R2 BNE 60$ .ADDR #DUR.LST,R0 10$: MOV (R0)+,R1 BEQ 20$ ADD R3,@R1 BR 10$ 20$: MOV #20000,R5 MOV @#KISAR1,R1 MOV (SP),@#KISAR1 MOV $MPPTR-DUBASE(R3),-(SP) MOV $PTWRD-DUBASE(R3),-(SP) MOV $GTBYT-DUBASE(R3),-(SP) .IF NE ERL$G MOV $ELPTR-DUBASE(R3),-(SP) .ENDC MOV @#SYSPTR,R2 MOV P1EXT(R2),-(SP) MOV (SP),$P1EXT-DUBASE(R3) MOV R1,@#KISAR1 MOV (SP)+,H$P1EX-DUXBAS(R5) .IF NE ERL$G MOV (SP)+,H$ELPT-DUXBAS(R5) .ENDC MOV (SP)+,H$GTBY-DUXBAS(R5) MOV (SP)+,H$PTWR-DUXBAS(R5) MOV (SP)+,H$MPPT-DUXBAS(R5) .ADDR #ONCBUF,R0 MOV (SP),@#KISAR1 MOV #UDAIP-DUBASE,R2 ADD R3,R2 MOV #LOWDATA,R4 ADD R4,R0 ASR R4 80$: MOV (R2)+,-(R0) SOB R4,80$ MOV R1,@#KISAR1 MOV #LOWDATA,R4 MOV #XUDAIP,R2 $REL .-2 XUDAIP DUX ADD R4,R2 ASR R4 90$: MOV (R0)+,-(R2) SOB R4,90$ 100$: MOV (SP)+,@#KISAR1 RTS PC .DSABL LSB .ENDC .IF NE MMG$T DUR.DID = 1 DUR.LST: .REPT DUR.CNT .Irp x <\DUR.DID> .WORD DUR'x $REL .-2 DUR'x DUX .ENDR DUR.DID = DUR.DID+1 .ENDR .WORD 000000 .EVEN .ENDC STORUP: MOV R2,-(SP) 10$: MOV (R2)+,(R5)+ DEC R1 BNE 10$ MOV (SP)+,R2 RTS PC FBLOC:: .ASSUME . LE OVRBK1+<1*BLK> . = OVRBK1+<1*BLK> ONCBUF:: .IF NE DU$PORTS-1 .SBTTL CKPORT - Check for installed ports CKPORT: .MFPS .MTPS #340 MOV @#INS.V,-(SP) .ADDR #DU.INS,R5 MOV R5,@#ILG.V INPOR1: MOV PCTAB+-DUBASE(R3),R1 CLC MOV @R1,R0 BCC INPOR2 MOV #1,R4 CALL PORTUP INPOR2: .IF NE DU$PORTS-2 MOV PCTAB+-DUBASE(R3),R1 CLC MOV @R1,R0 BCC INPOR3 MOV #2,R4 CALL PORTUP INPOR3: .IF NE DU$PORTS-3 MOV PCTAB+-DUBASE(R3),R1 CLC MOV @R1,R0 BCC NOPOR MOV #3,R4 CALL PORTUP NOPOR: .ENDC .ENDC MOV (SP)+,@#ILG.V .MTPS RTS PC PORTUP: MOV #UTTAB-DUBASE,R1 ADD R3,R1 MOV #8.,R0 10$: CMPB R4,UT.PORT(R1) BNE 20$ BISB #200,UT.PORT(R1) 20$: DEC R0 BEQ 30$ ADD #UT.ESZ,R1 BR 10$ 30$: RTS PC .ENDC .IF EQ DU$BOO .SBTTL FALCON - Check if we are on a falcon .IFTF DU.INS: BIS #1,2(SP) RTI .IFT FALCON: .MFPS .MTPS #340 MOV R0,-(SP) MOV @#INS.V,-(SP) .ADDR #DU.INS,R5 MOV R5,@#INS.V CLR R0 MFPT CMP R0,#4 BNE 10$ .IF EQ DU$PORTS-1 MOV #DU$ALT,UDAIP-DUBASE(R3) MOV #DU$ALT+2,UDASA-DUBASE(R3) .IFF MOV #DU$ALT,PCTAB-DUBASE(R3) MOV #DU$ALT+2,PCTAB+2-DUBASE(R3) .ENDC 10$: MOV (SP)+,@#INS.V MOV (SP)+,R0 .MTPS RTS PC .ENDC ONCEND:: .ASSUME . LE OVRBK1+<2*BLK> . = OVRBK1 + <2*BLK> .END .MCALL .MODULE .MODULE DW,VERSION=30,COMMENT=,AUDIT=YES ; COPYRIGHT (c) 1984,1985,1986 BY ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. ; ALL RIGHTS RESERVED. ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED ; ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE ; INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER ; COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY ; OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY ; TRANSFERRED. ; ; THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE ; AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT ; CORPORATION. ; ; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS ; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL. .SBTTL Conditional assembly summary .REM % The DW handler is formally designated the Martin B. Gentry Commemorative Handler in recognition of their mutual reduction of excessive avoirdupois. % .PSECT DWDVR .PSECT SETOVR .PSECT DWBOOT .SBTTL DESCRIPTION .ENABL LC .SBTTL USAGE .SBTTL MACRO DEFINITIONS .MACRO MAXVAL BITS, VAL VAL = 1 .REPT BITS VAL = VAL * 2 .ENDR .ENDM .MACRO BITMSK ARG, CMASK, BITS .IIF EQ ARG, .ERROR N = ARG MASK = 1 BITS = 0 FLAG = 0 .REPT 16 .IF EQ FLAG MASK = MASK * 2 BITS = BITS + 1 N = N / 2 .IF EQ N FLAG = 1 .ENDC .ENDC .ENDR CMASK = ^C .ENDM .MACRO $TYPE$ CODE,HEADS,TOTCYL,RSIZE,USIZE,HASIZ,LASIZ,USIZ,?L1 L1: .WORD CODE .WORD HEADS .WORD TOTCYL .WORD LASIZ .WORD USIZ TSIZE=.-L1 .ENDM .SBTTL PRIMARY DECLARATIONS PC$CSR =: 174000 PC$VEC =: 300 PC$IC1 =: 173206 PC$IC2 =: 173212 MMUSR0 =: 177572 MMUSR3 =: 172516 .IRPC X <01234567> KISAR'X =: 172340+<2*X> KISDR'X =: 172300+<2*X> .ENDR AP$ACF=: 077406 PROCFG =: 37776 CTI =: -10. SLOT0 =: -14. PC$PRI =: 4 DW$ID =: 401 DW$SEC =: 16. SECIDMX =: 5 SRFIDMX =: 3 CYLIDMX =: 10. MAXVAL SECIDMX, MAXSEC MAXVAL SRFIDMX, MAXSRF MAXVAL CYLIDMX, MAXCYL .IIF GT .ERROR .SBTTL BLOCK LAYOUT ON THE RD50C DISK .SBTTL PREAMBLE SECTION .MCALL .DRDEF, .ASSUME, .ADDR .BR .CKXX .CKXX .DRDEF DW,53,FILST$!SPFUN$!VARSZ$,0,0,0 .DRPTR FETCH=FETCH,LOAD=FETCH .DREST CLASS=DVC.DK .DRSPF <373> .DRSPF <376> .DRSPF <377> .SBTTL CONSTANT DEFINITIONS SYSPTR =: 54 P1EXT =: 432 GETVEC =: 436 $GTVEC=:0 $GTCSR=:2 $GTSLT=:4 DWTYPE =: 440 TYP50 =: 1. TYP51 =: 2. TYP31 =: 3. TYP52C =: 4. TYP52Q =: 5. TYP52A =: 6. TYP53 =: 7. TYP32 =: 8. DPT.BT =: 12 ICOPND =: PC$IC1 ICDRQ =: PC$IC2 DWID =: 0 DWERR =: 4 DWPRE =: 4 DWREV =: 6 DWSEC =: 6 DWBUF =: 10 DWCYL =: 12 DWHEAD =: 14 DWST2 =: 16 DWCMD =: 16 DWSTAT =: 20 DWINIT =: 20 .IF NE ERL$G ERLRGS =: 6 .ENDC EDWM =: 0400 ERTR0 =: 01000 ERABO =: 02000 ERIDNF =: 10000 ERICRC =: 20000 EDWCRC =: 40000 BITMSK DW$SEC-1,SECMSK,SECBIT BITMSK MAXSEC-1,MXSECM,MXSECB .IIF NE .ERROR BITMSK MAXSRF-1,MXSRFM,MXSRFB .IIF NE .ERROR BITMSK MAXCYL-1,MXCYLM,MXCYLB .IIF NE .ERROR S2ERR =: 400 S2DRQ =: 4000 S2SEK =: 10000 S2WRF =: 20000 S2DWY =: 40000 CMREST =: 20 CMREAD =: 40 CMWRIT =: 60 CMFORM =: 120 STOPND =: 1 STDRQ =: 200 STDCAP =: 400 STBUSY =: 100000 STINIT =: 10 RETRYS =: 8. WREQ =: 100000 AREQ =: 200 RREQ =: 1 RDAWRT =: 1 .SBTTL INSTALLATION VERIFICATION ROUTINE .DRINS -DW .ENABL LSB BR 10$ MOV #DW$ID,-(SP) CALL @R3 BR 20$ 10$: NOP MOV #DW$ID,-(SP) MOV @#SYSPTR,R0 CALL @GETVEC(R0) 20$: MOV (SP)+,R1 MOV INSCSR,R0 BNE 30$ BCS 50$ BR 40$ 30$: TST @R0 NOP BCS 50$ CMP @R0,#DW$ID BNE 50$ 40$: I.GOOD: TST (PC)+ I.BAD: 50$: SEC RETURN .ENABLE LSB FINDRV: .ADDR #DEVNAM,R0 .ADDR #DAREA,-(SP) EMT 342 BCS I.BAD MOV DAREA+4,R1 BEQ I.BAD BR I.GOOD DAREA: .BLKW 4 DEVNAM: .RAD50 /DW / I.SLOT: CMPB (R3)+,(R3)+ BIC R3,CLRIRR BIC R3,CLRIMR BIC R3,SETIMR BIS R1,CLRIRR BIS R1,CLRIMR BIS R1,SETIMR CLRB DWTYPE(R2) RETURN .ASSUME . LE 400,MESSAGE=<;Install area overflow> .DSABL LSB .SBTTL HANDLER SET OPTIONS .DRSET RETRY, 127., O.RTRY, NUM .IF NE ERL$G .DRSET SUCCES, -1, O.SUCC, NO .ENDC .DRSET WRITE,1,O.WP,NO .DRSET WCHECK,1,SETW,NO .DRSET SLOT,5,SETSLT,NUM .SBTTL HANDLER MODIFICATION ROUTINES O.RTRY: CMP R0,R3 BHI O.BAD MOV R0,DRETRY BNE O.GOOD BR O.BAD .IF NE ERL$G O.SUCC: MOV #0,R3 N.SUCC: MOV R3,SCSFLG .ASSUME O.SUCC+4 EQ N.SUCC BR O.GOOD .ENDC .ENABLE LSB O.WP: NOP TST (PC)+ SEC ROL (PC)+ O.WPF: .WORD 0 BIC #<^C1>,O.WPF MOVB R1,R0 BNE O.BAD MOV R0,-(SP) .ADDR #DWWPRO,R0,ADD MOVB O.WPF,@R0 CALL FINDRV MOV (SP)+,R0 BCS O.GOOD CMP @#SYSPTR,R1 BHI 10$ MOV #100000,DWW1-DWLQE(R1) 10$: ADD #DWWPRO-DWLQE,R1 ADD R0,R1 MOVB O.WPF,@R1 O.GOOD: TST (PC)+ O.BAD: SEC RETURN .DSABLE LSB .ENABLE LSB SETW: BR 10$ . = SETW+4 CLR DWWCHK BR 20$ 10$: MOV #-1,DWWCHK 20$: CLC RETURN .DSABLE LSB .ENABLE LSB SETSLT: MOV @#SYSPTR,R2 INC R2 CMP R0,R3 BGT O.BAD CMP R0,#-1 BEQ 10$ TST R0 BMI O.BAD MOV R0,R1 ASH #7,R0 ADD #PC$CSR,R0 BR 20$ 10$: CLR R0 DEC R2 20$: MOV R0,DWCSR MOV R0,INSCSR BEQ 30$ MOV #>/2.-1+^o100000,DWSTRT MOV R1,R0 ASH #3,R0 ADD #PC$VEC,R0 MOV R0,XW$VTB+0 CMP (R0)+,(R0)+ MOV R0,XW$VTB+6 BR 40$ 30$: MOV #>/2.-1+^o100000,DWSTRT CLR R1 40$: JMP I.SLOT .DSABLE LSB .ASSUME . LE 1000,MESSAGE=<;Set area overflow> .SBTTL HEADER SECTION .DRBEG DW DWBASE=:DWSTRT+6 BR DWENT DWWPRO: .WORD 0 .Assume . LE DWSTRT+1000,MESSAGE=<;SET object not in block 1> .IF NE ERL$G SCSFLG: .WORD 0 .Assume . LE DWSTRT+1000,MESSAGE=<;SET object not in block 1> .ENDC DWWCHK: .WORD 0 .Assume . LE DWSTRT+1000,MESSAGE=<;SET object not in block 1> DWFBLK: .WORD 0,0,0,0 DRETRY: .WORD RETRYS .Assume . LE DWSTRT+1000,MESSAGE=<;SET object not in block 1> RETRY: .WORD 0 INREST: .WORD 0 FNFLAG: .WORD 0 WRFLAG: .WORD 0 WCNT: .WORD 0 CRNTCYL:.WORD 0 CRNTHD: .WORD 0 CRNTSEC:.WORD 0 RDTYP: $TYPE$ 0 0 177777 177777 177777 177777 177777 177777 DW$TYP =: RDTYP+0 DW$SRF =: RDTYP+2 DW$CYL =: RDTYP+4 DWASIZ =: RDTYP+6 DWUSIZ =: RDTYP+8. .IF EQ MMG$T BUFF: .WORD 0 .ENDC .IF NE ERL$G ERLIST: .BLKW ERLRGS .ENDC .SBTTL VECTOR TABLE DW$VEC =: PC$VEC .DRVTB XW,300,DWINT .DRVTB ,304,DWINT .DRVTB DW,0,DWINT,SLOTID=DW$ID .DRVTB ,4,DWINT .SBTTL I/O INITIATION SECTION .ENABL LSB DWENT: MOV #.-.,R4 DWCSR =:.-2 .Assume . LE DWSTRT+1000,MESSAGE=<;SET object not in block 1> CK.R4=DWID CK.R4 DWID TST DWSTAT(R4) .ASSUME EQ 100000 BMI JMPFD1 MOV #.-.,R0 DRETR1 =:.-2 CK.R0=DRETRY CK.R0 DRETRY,+2 CK.R0 RETRY,+2 MOV (R0)+,(R0)+ CK.R0 INREST,+2 CLR (R0)+ CK.R0 FNFLAG,+2 CLR (R0)+ CK.R0 WRFLAG,+2 CLR (R0)+ MOV DWCQE,R5 CK.R5=Q$BLKN CK.R5 Q$BLKN MOV @R5,R3 CK.R5 Q$BLKN MOVB Q$UNIT(R5),R0 BIC #^C<7>,R0 BNE JMPFU1 XRETRY: CK.R5 Q$BLKN MOVB Q$FUNC(R5),R0 ADD #FNEG,R0 CMP R0,#FNUM BLO DISPAT JMPFU1: JMP DWFUE JMPFD1: JMP DWFDE .DSABL LSB .SBTTL COMMAND DISPATCH DISPAT: ASL R0 ADD #.-.,R0 FNTBL1 =:.-2 ADD @R0,PC JMPREF: FNTBL: .WORD .WORD .WORD .WORD .WORD FTBZER: .WORD FTBEND: FNEG =: /2 FNUM =: /2 .Assume FNEG+1 EQ FNUM .SBTTL HANDLER FUNCTIONS SECTION .SBTTL ABSRW - Read/write absolute sector ABSW: CK.R5 Q$BLKN NEG Q$WCNT(R5) ABSR: BIS #AREQ,FNFLAG .BR RW .SBTTL - READ(X)/WRIT(X) FUNCTION .ENABLE LSB RW: CK.R5 Q$BLKN BIT #1,Q$BUFF(R5) BNE JMPFU1 CK.R5 Q$BLKN TST Q$WCNT(R5) BMI 10$ BNE 25$ BR INTRQS 10$: CK.R4 DWID BIT #S2WRF,DWST2(R4);Has a write fault occured? BNE JMPFD1 ASL (PC)+ DWW1: .WORD .-. .ASSUME . LE DWSTRT+1000 BCS 20$ TST DWWPRO BNE JMPFU1 20$: MOV #S2WRF,WRFLAG BIS #WREQ,FNFLAG CK.R5 Q$BLKN NEG Q$WCNT(R5) BR RWNEXT 25$: BIS #RREQ,FNFLAG .BR RWNEXT RWNEXT: INC R3 TSTB FNFLAG BPL 30$ .Assume AREQ EQ 200 CMP R3,DWASIZ BHIS JMPFU1 BR 40$ 30$: CMP R3,DWUSIZ BHI JMPFU1 40$: MOV R3,R1 BIC #SECMSK,R1 ASH #-SECBIT,R3 .Assume SECBIT EQ 4 BIC #170000,R3 CLR R2 DIV DW$SRF,R2 CMP R2,DW$CYL BHIS JMPFU1 MOV #.-.,R0 CRNT1 =:.-2 CK.R0=CRNTCYL CK.R0 CRNTCYL,+2 MOV R2,(R0)+ CK.R0 CRNTHD,+2 MOV R3,(R0)+ CK.R0 CRNTSEC,+2 MOV R1,(R0)+ .BR RWRTRY RWRTRY: CALL DSKADR TST FNFLAG .Assume WREQ EQ 100000 BMI 50$ DOREAD: MOV #110,@#ICDRQ CLRIRR =:.-4 .Assume . LE DWSTRT+1000,MESSAGE=<;SET object not in block 1> CK.R4 DWID MOV #CMREAD,DWCMD(R4) MOV #050,@#ICDRQ CLRIMR =:.-4 .Assume . LE DWSTRT+1000,MESSAGE=<;SET object not in block 1> RETURN 50$: BIC #RDAWRT,FNFLAG MOV CLRIRR,@#ICOPND CK.R4 DWID MOV #CMWRIT,DWCMD(R4) JSR R0,MTFILL MOV (R2)+,@R4 CLR @R4 CALLR CLRPND .DSABL LSB .SBTTL DSIZ - Get disk size .ENABLE LSB DSIZ: .IF EQ MMG$T CK.R5 Q$BLKN MOV DWUSIZ,@Q$BUFF(R5) .IFF MOV DWUSIZ,-(SP) CK.R5 Q$BLKN CK.R4=CK.R5 MOV R5,R4 CALL @$PTWRD .ENDC .BR INTRQS .DSABL LSB .SBTTL INTERRUPT SERVICE SECTION .ENABLE LSB INTRQS: JMP DWRQS .DRAST DW,PC$PRI MOV #070,@#ICOPND SETIMR =:.-4 .Assume . LE DWSTRT+1000,MESSAGE=<;SET object not in block 1> MOV SETIMR,@#ICDRQ .FORK DWFBLK MOV DWCQE,R5 CK.R5=Q$BLKN MOV DWCSR,R4 CK.R4=DWID CK.R4 DWID TST DWSTAT(R4) BMI DWFD1 CK.R4 DWID BIT WRFLAG,DWST2(R4) BNE DWFD1 CK.R4 DWID BIT #S2ERR,DWST2(R4);Error status? BNE 70$ TST INREST BNE 90$ .IF NE ERL$G TST SCSFLG BNE 10$ MOV R5,-(SP) S.TOP=CK.R5 MOV R4,-(SP) S.TOP2=CK.R4 MOV #<!377>,R4 CALL @$ELPTR MOV (SP)+,R4 CK.R4=S.TOP2 MOV (SP)+,R5 CK.R5=S.TOP .ENDC 10$: MOV FNFLAG,R0 .Assume WREQ!RDAWRT!RREQ NE 0 BEQ INTRQS .Assume RDAWRT GT 0 BPL 30$ TST DWWCHK BEQ 40$ .Assume RREQ EQ 1 ASR R0 BCC 20$ CALL DUMP BR 40$ .Assume RREQ EQ 1 20$: INC FNFLAG BR 110$ 30$: BMI 40$ JSR R0,MTFILL MOV @R4,(R2)+ MOV @R4,R5 CK.R5 Q$BLKN 40$: MOV WCNT,Q$WCNT(R5) BEQ INTRQS .IF NE MMG$T CK.R5 Q$BLKN MOV PARVAL,Q$PAR(R5) .IFF CK.R5 Q$BLKN MOV BUFF,Q$BUFF(R5) .ENDC TST FNFLAG .Assume WREQ EQ 100000 BPL 50$ ASL (PC)+ .WORD 100000 BCS 60$ 50$: CK.R5 Q$BLKN INC @R5 60$: CK.R5 Q$BLKN MOV @R5,R3 MOV DRETRY,RETRY JMP RWNEXT 70$: TST INREST DWFD1: BNE DWFDE CK.R4 DWID BIT #,DWERR(R4) BNE DWFDE .IF NE ERL$G MOV R5,-(SP) S.TOP=CK.R5 MOV R4,-(SP) S.TOP2=CK.R4 CALL ERLSET BISB RETRY,R4 CALL @$ELPTR MOV (SP)+,R4 CK.R4=S.TOP2 MOV (SP)+,R5 CK.R5=S.TOP .ENDC CK.R4 DWID TSTB DWSTAT(R4) BPL 80$ CALL DUMP 80$: CK.R4 DWID BIT #ERIDNF,DWERR(R4) BEQ 90$ CK.R4 DWID MOV DWST2(R4),R3 BIT #S2WRF,R3 BNE DWFDE BIC #^C,R3 CMP #,R3 BNE DWFDE MOV SP,INREST MOV CLRIRR,@#ICOPND CK.R4 DWID MOV #CMREST,DWCMD(R4) CLRPND: MOV CLRIMR,@#ICOPND RETURN 90$: DEC RETRY BEQ DWFDE CLR INREST TST FNFLAG .Assume RREQ!WREQ NE 0 BEQ 120$ .Assume WREQ EQ 100000 BPL 100$ BIT #RDAWRT,FNFLAG BNE 110$ 100$: JMP RWRTRY 110$: CALL DSKADR CALLR DOREAD 120$: JMP XRETRY .DSABLE LSB .SBTTL I/O COMPLETION SECTION .ENABL LSB DWFDE: .IF NE ERL$G MOV R5,-(SP) S.TOP=CK.R5 CALL ERLSET CALL @$ELPTR MOV (SP)+,R5 CK.R5=S.TOP .ENDC DWFUE: CK.R5 Q$BLKN BIS #HDERR$,@Q$CSW(R5) DWRQS: .DRFIN DW .DSABLE LSB .SBTTL EMPTY/FILL THE CONTROLLER'S SECTOR BUFFER SUBROUTINE .ENABL LSB MTFILL: S.TOP=CK.R5 MOV R5,-(SP) S.TOP2=CK.R4 MOV R4,-(SP) MOV (R0)+,60$ MOV (R0)+,100$ CK.R4 DWID MOV R4,R3 CK.R3=CK.R4 ADD #DWSTAT,R3 CK.R3 DWID,+DWSTAT ADD #DWBUF,R4 CK.R4 DWID,+DWBUF CK.R5 Q$BLKN MOV Q$BUFF(R5),R2 CK.R5 Q$BLKN MOV Q$WCNT(R5),R1 BEQ 90$ MOV R1,WCNT CMP R1,#256. BLOS 10$ MOV #256.,R1 10$: TST FNFLAG .Assume WREQ EQ 100000 BPL 20$ ASL (PC)+ .WORD 100000 BCS 30$ 20$: SUB R1,WCNT 30$: .IF NE MMG$T CK.R5 Q$BLKN MOV Q$PAR(R5),PARVAL JSR R0,@#.-. $P1EXT =:.-2 .WORD PARVAL-. .IFF MOV R2,BUFF TST FNFLAG .Assume WREQ EQ 100000 BPL 40$ ASL (PC)+ .WORD 100000 BCS 60$ 40$: ADD #512.,BUFF .ENDC 60$: .WORD 0 SOB R1,60$ .IF NE MMG$T PARVAL: .WORD 0 TST FNFLAG .Assume WREQ EQ 100000 BPL 70$ ASL (PC)+ .WORD 100000 BCS 80$ 70$: ADD #<256./32.>,PARVAL 80$: .ENDC 90$: CK.R3 DWSTAT MOV @R3,R5 .Assume STBUSY EQ 100000 BMI 110$ .Assume STOPND EQ 1 ASR R5 BCS 110$ .Assume STDRQ EQ 200 ASLB R5 BPL 90$ 100$: .WORD 0 BR 90$ 110$: MOV (SP)+,R4 CK.R4=S.TOP2 MOV (SP)+,R5 CK.R5=S.TOP RTS R0 .DSABL LSB .SBTTL DUMP THE CONTROLLER'S SECTOR BUFFER SUBROUTINE .ENABLE LSB DUMP: CK.R4 DWID CK.R2=CK.R4 MOV R4,R2 ADD #DWSTAT,R2 CK.R2 DWID,+DWSTAT MOV R4,R3 CK.R3=CK.R4 ADD #DWBUF,R3 CK.R3 DWID,+DWBUF 10$: CK.R2 DWSTAT MOV @R2,R1 ASR R1 .Assume STOPND EQ 1 BCS 20$ ASLB R1 .Assume STDRQ EQ 200 BPL 10$ CK.R3 DWBUF MOV @R3,R1 BR 10$ 20$: RETURN .DSABL LSB DSKADR: MOV #.-.,R0 CRNT2 =:.-2 CK.R0=CRNTCYL CK.R0 CRNTCYL,+2 CK.R4 DWID MOV (R0)+,DWCYL(R4) CK.R0 CRNTHD,+2 CK.R4 DWID MOV (R0)+,DWHEAD(R4) CK.R0 CRNTSEC,+2 CK.R4 DWID MOV (R0)+,DWSEC(R4) RETURN .IF NE ERL$G .SBTTL ERROR LOGGING SETUP SUBROUTINE .ENABLE LSB ERLSET: .ADDR #ERLIST,R2 MOV R2,R3 CK.R4 DWID MOV DWSTAT(R4),(R3)+ .Assume STBUSY EQ 100000 BMI 10$ CK.R4 DWID MOV DWCYL(R4),(R3)+ CK.R4 DWID MOV DWHEAD(R4),(R3)+ CK.R4 DWID MOV DWSEC(R4),(R3)+ CK.R4 DWID MOV DWERR(R4),(R3)+ CK.R4 DWID MOV DWST2(R4),@R3 BR 20$ 10$: MOV #-1,@R3 MOV (R3)+,@R3 MOV (R3)+,@R3 MOV (R3)+,@R3 MOV (R3)+,@R3 20$: MOV DRETRY,R3 SWAB R3 BISB #ERLRGS,R3 MOV #,R4 RETURN .DSABL LSB .ENDC .SBTTL BOOTSTRAP READ ROUTINE .DRBOT DW,BOOT1,READ,CONTROL= .ENABL LSB .=DWBOOT+14 DSKTYP: MOV #7,R3 CK.R4=DWID CLR DWSEC(R4) 10$: CK.R5=CK.R4 MOV R4,R5 BR 20$ .=DWBOOT+40 BOOT1: JMP @# 20$: CK.R5 DWID,+DWCYL ADD #DWCYL,R5 CK.R5 DWCYL,+2 CLR (R5)+ CK.R5 DWHEAD,+2 MOV R3,(R5)+ CK.R5 DWCMD,+2 MOV #CMREAD,(R5)+ BR 25$ .Assume . LE DWBOOT+120,MESSAGE=<;Bootstrap overlap> .=DWBOOT+120 25$: 30$: CK.R5 DWSTAT TST @R5 .Assume STBUSY EQ 100000 BMI 30$ CK.R4 DWID BIT #S2ERR,DWST2(R4) BEQ 40$ CK.R4 DWID BIT #ERIDNF!ERABO,DWERR(R4) BEQ 40$ SOB R3,10$ BR 60$ 40$: CK.R5 DWSTAT BIT #STOPND,@R5 BNE 50$ CK.R5 DWSTAT TSTB @R5 .Assume STDRQ EQ 200 BPL 40$ CK.R4 DWID TST DWBUF(R4) BR 40$ 50$: INC R3 TST (PC)+ 60$: SEC RETURN HITYP: .DSABL LSB .ENABL LSB READ: ASRB (PC)+ .WORD 1 BCC READX CLR R5 BISB @#173050,R5 SWAB R5 ASL R5 SUB #200,R5 MOV R5,@#KISAR1 MOV #AP$ACF,R5 MOV R5,@#KISDR1 CLR @#KISAR0 MOV R5,@#KISDR0 MOV #177600,@#KISAR7 MOV R5,@#KISDR7 BIS #20,@#MMUSR3 INC @#MMUSR0 MOV #CTI+PROCFG,R3 .ASSUME SLOT0 EQ CTI-4 MOV @R3,R4 MOV R4,R5 10$: TST -(R3) CMP -(R3),#DW$ID BEQ 20$ SOB R5,10$ CLR @#MMUSR0 BR ERRX 20$: CLR @#MMUSR0 SUB R5,R4 ASH #7.,R4 ADD R4,DWCSR1 MOV DWCSR1,R4 CK.R4=DWID CK.R4 DWID BIT #STDCAP,DWSTAT(R4) BNE READX MOV #-1,DW$CY1 CALL DSKTYP BCS ERRX MOV R3,DW$HD .DSABL LSB .ENABL LSB READX: MOV (PC)+,R4 DWCSR1: .WORD PC$CSR CK.R4=DWID CK.R4 DWID TST DWSTAT(R4) .Assume STBUSY EQ 100000 BMI ERRX 10$: MOV R0,-(SP) MOV R1,-(SP) BOTNXT: MOV @SP,R3 CMP R3,#256. BLOS 20$ MOV #256.,R3 20$: SUB R3,@SP MOV 2(SP),R1 INC R1 INC 2(SP) MOV R1,R5 BIC #SECMSK,R5 CK.R4 DWID MOV R5,DWSEC(R4) ASH #-SECBIT,R1 .Assume SECBIT EQ 4 BIC #170000,R1 CLR R0 DIV #4,R0 DW$HD =:.-2 CMP R0,(PC)+ DW$CY1: .WORD 153. BLO 30$ ERRX: JMP @# 30$: CK.R4 DWID MOV R4,R5 CK.R5=CK.R4 CK.R5 DWID,+DWCYL ADD #DWCYL,R5 CK.R5 DWCYL,+2 MOV R0,(R5)+ CK.R5 DWHEAD,+2 MOV R1,(R5)+ CK.R5 DWCMD,+2 MOV #CMREAD,(R5)+ .DSABL LSB .ENABL LSB 10$: CK.R5 DWSTAT TST @R5 .Assume STBUSY EQ 100000 BMI 10$ CK.R4 DWID BIT #S2ERR,DWST2(R4) BNE ERRX 20$: 30$: CK.R5 DWSTAT TSTB @R5 .Assume STDRQ EQ 200 BPL 30$ MOV DWBUF(R4),(R2)+ SOB R3,20$ 40$: CK.R5 DWSTAT BIT #STOPND,@R5 BNE 50$ TSTB @R5 .Assume STDRQ EQ 200 BPL 40$ CK.R4 DWID TST DWBUF(R4) BR 40$ 50$: TST @SP BNE BOTNXT CMP (SP)+,(SP)+ CLC RETURN .Assume . LE DWBOOT+612,MESSAGE=<;Bootstrap overlap> .DSABL LSB .=DWBOOT+612 BOOT: MOV #10000,SP MOV #2,R0 MOV #<4*256.>,R1 MOV #1000,R2 CALL READ MOV #,@#B$READ MOV #B$DNAM,@#B$DEVN CLR @#B$DEVU JMP @#B$BOOT .DREND DW .SBTTL FETCH/LOAD code .PSECT SETOVR SETOVR: FETCH: JMP FETCH1 DWREAD: MOV R0,-(SP) MOV R4,-(SP) MOV #2,DWSEC(R0) ADD #DWCYL,R0 MOV (R5)+,(R0)+ CLR (R0)+ MOV #CMREAD,(R0)+ MOV (R5)+,R3 MOV (R5)+,R4 10$: TST (R0) BMI 10$ 20$: TSTB (R0) BPL 20$ MOV DWBUF-DWSTAT(R0),(R4)+ SOB R3,20$ 30$: TSTB (R0) BPL 40$ TST DWBUF-DWSTAT(R0); YES - Drop a word from the controller 40$: BIT #STOPND,(R0) BEQ 30$ BIT #S2ERR,DWST2-DWSTAT(R0) BEQ 50$ SEC 50$: MOV (SP)+,R4 MOV (SP)+,R0 RTS R5 .ENABL LSB FNGEOM: TST DWTYPS BNE 95$ CMP 2(R1),TSIZE+2(R1) BNE 95$ MOV R2,-(SP) .ADDR #BUFHOM,R2 MOV R2,10$ JSR R5,DWREAD .WORD 0 .WORD 256. 10$: .WORD 0 BCS 90$ MOV R4,-(SP) MOV #-1,35$ 15$: MOV 4(R1),20$ INC 20$ .ADDR #BUFWRP,R2 MOV R2,25$ JSR R5,DWREAD 20$: .WORD 0 .WORD SIZWRP 25$: .WORD 0 BCS 85$ MOV #SIZWRP,R2 .ADDR #BUFHOM,R3 .ADDR #BUFWRP,R4 30$: CMP (R3)+,(R4)+ BNE 80$ SOB R2,30$ INC (PC)+ 35$: .WORD -1 BNE 75$ MOV #SIZWRP,R2 .ADDR #HOMPAT+,R4 40$: CMP -(R3),-(R4) BNE 45$ SOB R2,40$ CMP (R3)+,(R4)+ TST (R4)+ MOV (R4),(R3)+ MOV -(R4),(R3) CMP -(R3),-(R3) BR 60$ 45$: MOV (R4),(R3) BR 55$ 50$: MOV -(R4),-(R3) 55$: SOB R2,50$ 60$: MOV #2,DWSEC(R0) CLR DWCYL(R0) CLR DWHEAD(R0) MOV #CMWRIT,DWCMD(R0) 65$: TSTB DWSTAT(R0) BPL 70$ MOV (R3)+,DWBUF(R0) 70$: BIT #STOPND,DWSTAT(R0) BEQ 65$ BR 15$ 75$: SEC BR 85$ 80$: ADD #TSIZE,R1 CLC 85$: MOV (SP)+,R4 90$: MOV (SP)+,R2 BCC FNGEOM 95$: MOV (R1),R3 CK.R5=DWBASE CK.R2=SYSPTR MOV #TSIZE/2,R0 CK.R5 DWBASE ADD #RDTYP-DWBASE,R5 100$: MOV (R1)+,(R5)+ SOB R0,100$ 105$: CK.R2 SYSPTR MOVB R3,DWTYPE(R2) DWTYPX=:.-2 FETXIT: TST (PC)+ FETERR: SEC BIC R0,R0 RETURN .DSABL LSB DWTAB: .BYTE TYP51,TYP52C,TYP32,TYP52A,TYP52Q .EVEN DEVCHR: $TYPE$ TYP50 4. 153. 9792. 9727. 0. 9792. 9727. $TYPE$ TYP51 4. 306. 19584. 19519. 0. 19584. 19519. $TYPE$ TYP31 4. 615. 39360. 39295. 0. 39360. 39295. $TYPE$ TYP52C 5. 697. 55760. 55679. 0. 55760. 55679. $TYPE$ TYP32 6. 820. 78720. 78623. 13088. 65535. 65535. $TYPE$ TYP52A 7. 645. 72240. 72127. 6705. 65535. 65535. $TYPE$ TYP52Q 8. 512. 65536. 65407. 1. 65535. 65407. $TYPE$ TYP53 8. 1024. 131072. 130943. 65535. 65535. 65535. $TYPE$ 0 -1 0. 0. 0. 0. 0. 0. SIZWRP =: 3. BLKHOM =: 1. HOMPAT: .WORD 0,170000,7777 DWTYPS: .WORD 0 BUFWRP: .BLKW SIZWRP BUFHOM: .=BUFWRP .ENABL LSB FETCH1: NOP MOV @R5,R5 CK.R5=DWBASE MOV @#SYSPTR,R2 CK.R2=SYSPTR .IF NE MMG$T CK.R2 SYSPTR CK.R5 DWBASE MOV P1EXT(R2),$P1EXT-DWBASE(R5) .ENDC CK.R5 DWBASE MOV DWCSR-DWBASE(R5),R0 CK.R0=DWID BNE 15$ MOV #DW$ID,-(SP) CK.R1=$GTVEC CK.R1 ,+2 TST (R1)+ CK.R1 $GTCSR CALL @R1 MOV (SP)+,R0 CK.R0=DWID BCS FETERR CK.R0 DWID CK.R5 DWBASE MOV R0,DWCSR-DWBASE(R5) MOV #DW$ID,-(SP) CK.R1 $GTCSR,+2 TST (R1)+ CK.R1 $GTSLT CALL @R1 CK.R5 DWBASE BIS @SP,CLRIMR-DWBASE(R5) CK.R5 DWBASE BIS @SP,SETIMR-DWBASE(R5) CK.R5 DWBASE BIS (SP)+,CLRIRR-DWBASE(R5) BR 17$ 15$: INC DWTYPX 17$: MOV R5,R1 CK.R1=CK.R5 ADD #DRETRY-DWBASE,R1 CK.R1 ,+DRETRY-DWBASE CK.R1 DRETRY CK.R5 DWBASE MOV R1,DRETR1-DWBASE(R5) CK.R1 DRETRY ADD #CRNTCYL-DRETRY,R1 CK.R1 ,+CRNTCYL-DRETRY CK.R1 CRNTCYL CK.R5 DWBASE MOV R1,CRNT1-DWBASE(R5) CK.R1 CRNTCYL CK.R5 DWBASE MOV R1,CRNT2-DWBASE(R5) CK.R1 CRNTCYL ADD #FNTBL-CRNTCYL,R1 CK.R1 ,+FNTBL-CRNTCYL CK.R1 FNTBL CK.R5 DWBASE MOV R1,FNTBL1-DWBASE(R5) CMP #DPT.BT,R3 BNE 20$ MOV @#DW$HD-DWBOOT,R3 BR HEADCK .SBTTL Use the DSKTYP routine in DRBOT CK.R2 SYSPTR 20$: MOV DWTYPE(R2),R3 BIT #1,DWTYPX BEQ 23$ SWAB R3 23$: MOVB R3,R3 BNE 31$ MOV R4,-(SP) S.TOP=CK.R4 MOV R5,-(SP) S.TOP2=CK.R5 CK.R0 DWID MOV R0,R4 CK.R4=CK.R0 CK.R4 DWID CALL DSKTYP MOV (SP)+,R5 CK.R5=S.TOP2 MOV (SP)+,R4 CK.R4=S.TOP BCS FETERR HEADCK: CMP #4,R3 BNE 30$ CK.R3=4 CK.R0 DWID BIT #STDCAP,DWSTAT(R0) BEQ 30$ MOV #TYP50,R3 31$: INC DWTYPS BR FETUPD 30$: .BR FETXLT CK.R5 DWBASE CK.R2 SYSPTR .DSABL LSB .ENABL LSB FETXLT: .ADDR #DWTAB-4,R3,ADD MOVB @R3,R3 FETUPD: .ADDR #DEVCHR,R1 10$: CMPB @R1,R3 BEQ 20$ ADD #TSIZE,R1 BR 10$ 20$: JMP FNGEOM .DSABL LSB .ASSUME BUFHOM+1000 LE SETOVR+2000,MESSAGE=<;FETCH area overflow> .ASSUME .+ LE SETOVR+2000,MESSAGE=<;DSKTYP not all in FETCH blocks> .END .MCALL .MODULE .MODULE DZ,VERSION=20,COMMENT=,AUDIT=YES ; COPYRIGHT (c) 1986, 1987 BY ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED ; ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE ; INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER ; COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY ; OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY ; TRANSFERRED. ; ; THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE ; AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT ; CORPORATION. ; ; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS ; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL. .SBTTL CONDITIONAL ASSEMBLY SUMMARY .ENABL LC .SBTTL General Comments .SBTTL DEFINITIONS .MCALL .DRDEF, .ASSUME, .BR, .ADDR .DRDEF DZ,52,FILST$!SPFUN$,800.,0,0 .DRPTR FETCH=DZLOAD,LOAD=DZLOAD .DREST CLASS=DVC.DK .DRSPF <377> .DRSPF <376> .SBTTL Constants and defaults .IIF NDF DZ.CMA, DZ.CMA = 173206 .IIF NDF DZ.CMB, DZ.CMB = 173212 .IIF NDF DZ.IEN, DZ.IEN = 1 DZ$CS0 = 4 SPFUNC = 100000 SYSPTR = 54 P1EXT = 432 GETVEC = 436 PC$CSR = 174000 PC$VEC = 300 PC$IC1 = 173206 PC$IC2 = 173212 MMUSR0 = 177572 MMUSR3 = 172516 .IRPC X <01234567> KISAR'X = 172340+<2*X> KISDR'X = 172300+<2*X> .ENDR AP$ACF= 077406 PROCFG = 37776 CTI = -10. SLOT0 = -14. DZ$ID = 2004 DZ.ID = -4 DZ.CS0 = 0 C0.DSK = 002 C0.DRV = 004 C0.MTO = 010 C0.FN0 = 020 C0.FN1 = 040 C0.FN2 = 100 C0.STA = 000 C0.RSD = 040 C0.RSS = 060 C0.RED = 100 C0.RER = 120 C0.RAD = 140 C0.WRT = 160 C0.DON = 10 DZ.CS1 = 2 DZ.CS2 = 4 DZ.CS3 = 6 DZ.DB = 14 DZ.CA = 16 DZ.GO = 20 DZMTRK = 79. RETRY = 8. DZNREG = 7. KISAR1 = 172342 .SBTTL Installation checks .DRINS DZ BR 1$ BR 2$ 1$: MOV @#SYSPTR,R3 MOV GETVEC(R3),R3 TST (R3)+ 2$: MOV #DZ$ID,-(SP) CALL @R3 MOV (SP)+,R3 RETURN FINDRV: .ADDR #DEVNAM,R0 MOV PC,-(SP) ADD #DAREA-.,@SP EMT 342 BCS O.BAD MOV DAREA+4,R1 BEQ O.BAD BR O.GOOD DAREA: .BLKW 4 DEVNAM: .RAD50 /DZ / BAREA: .BYTE 17,10 .BLKW 0 .BLKW 0 .WORD 256. .WORD 0 .IIF GT,<.-356> .ERROR .SBTTL SET options .DRSET RETRY, 127., O.RTRY, NUM .IF NE ERL$G .DRSET SUCCES, -1, O.SUCC, NO .ENDC .SBTTL Handler modification routines O.RTRY: CMP R0,R3 BHI O.BAD MOV R0,DRETRY BNE O.GOOD BR O.BAD .IF NE ERL$G O.SUCC: MOV #0,R3 N.SUCC: MOV R3,SCSFLG .ASSUME O.SUCC+4 EQ N.SUCC BR O.GOOD .ENDC O.GOOD: TST (PC)+ O.BAD: SEC RETURN .IIF GT,<.-1000> .ERROR .SBTTL Driver request entry point .ENABL LSB .DRBEG DZ .IF NE ERL$G BR DZENT SCSFLG: .WORD 0 .ASSUME . LE DZSTRT+1000 DZENT: .ENDC MOV #9.,DZTRY MOV #110,R0 BIS (PC)+,R0 INTENB: .WORD DZ.IEN MOV #50,R2 BIS INTENB,R2 MOV (PC)+,R1 IRRA: .WORD DZ.CMA MOV R0,@R1 MOV R2,@R1 MOV (PC)+,R1 IRRB: .WORD DZ.CMB MOV R0,@R1 NOP MOV R2,(PC)+ ENABLE: .WORD 0 MOV #70,R2 BIS INTENB,R2 MOV R2,(PC)+ DSABLE: .WORD 0 CLR (PC)+ SPFUNF: .WORD 0 MOV DZCQE,R3 MOV (R3)+,R5 MOV #C0.RED,R4 MOVB (R3)+,R1 CMPB #376,R1 BLE 45$ JMP DZABRT DRETRY: .WORD RETRY 45$: MOVB (R3)+,R0 ASRB R0 BCC 20$ BIS #C0.DSK,R4 20$: ASRB R0 BCC 30$ BIS #C0.DRV,R4 30$: ASRB R0 BCS DZERR MOV (R3)+,R0 MOV (R3)+,R2 BPL 40$ BIS #C0.WRT,R4 NEG R2 40$: ASL R1 MOV R1,SPFUNF ADD PC,R1 ADD CHGTBL-.(R1),R4 MOV R4,DZFUN2 TST SPFUNF BNE 90$ ASL R2 MOV (PC)+,R4 .BYTE -7.,-10. 50$: CMP #1280.,R5 BHI 60$ ADD #-1280.,R5 60$: ROL R5 INCB R4 BLE 50$ MOVB R5,R1 ADD R4,R5 MOV R1,R4 ASL R1 70$: SUB #10.,R1 BGT 70$ MOV R1,TRKOFF BR 100$ 90$: SWAB R5 BISB R2,R5 MOV #512.,R2 100$: MOV R0,(PC)+ BUFRAD: .WORD 0 MOV R5,(PC)+ TRACK: .BYTE 0 SECTOR: .BYTE 0 MOV R2,(PC)+ BYTCNT: .WORD 0 .IF NE MMG$T TST (R3)+ MOV @R3,PARVAL .ENDC .BR DZINIT .DSABL LSB .SBTTL Start transfer or retry .ENABL LSB DZINIT: MOV DZCSA,R4 MOV R4,R5 ADD #DZ.DB,R5 10$: MOV DZFUN2,R0 MOV R0,-(SP) BIC #^C,@SP CMP #C0.WRT,(SP)+ BNE 30$ TST DZTRY BNE 20$ MOV DRETRY,DZTRY 20$: JSR R0,SILOFE MOVB (R2)+,@R5 MOV R1,@R5 30$: MOVB SECTOR,R2 BGT 50$ SUB #-6.,R2 BGT 40$ ADD #4.,R2 SEC 40$: ROL R2 ADD (PC)+,R2 TRKOFF: .WORD 0 BGT 50$ ADD #10.,R2 50$: MOVB R0,@R4 MOV TRACK,R0 CMPB R0,#DZMTRK+1 BNE 60$ CLR R0 60$: MOVB R0,DZ.CS1(R4) MOVB R2,DZ.CS2(R4) CLRB DZ.GO(R4) RETURN DZERR: MOV DZCQE,R4 BIS #HDERR$,@-(R4) BR DZABRT .SBTTL Interrupt and abort entry points .DRAST DZ,5 .FORK DZFBLK MOV (PC)+,R0 DZFUN2: .WORD 0 MOV #512.,R3 MOV (PC)+,R4 DZCSA: .WORD DZ$CS0 MOV R4,R5 ADD #DZ.DB,R5 TSTB @R4 BMI DZRTRY MOV DRETRY,DZTRY MOV R0,-(SP) BIC #17,@SP CMP #C0.WRT,(SP)+ BEQ 70$ JSR R0,SILOFE MOVB @R5,(R2)+ MOV @R5,R2 MOV #1,DZTRY 70$: INCB SECTOR BNE 80$ ADD #-10.*256.+1,TRACK ADD #2,TRKOFF BLE 80$ SUB #10.,TRKOFF 80$: .IF EQ MMG$T ADD R3,BUFRAD .IFF ADD #8.,PARVAL .ENDC SUB R3,BYTCNT BHI 10$ 90$: .IF NE ERL$G TST SCSFLG BNE 100$ MOV #DZ$COD*400+377,R4 MOV DZCQE,R5 CALL @$ELPTR .ENDC DZABRT: CLR DZFBLK+2 100$: MOV DSABLE,@IRRA MOV DSABLE,@IRRB .DRFIN DZ .DSABL LSB .SBTTL DZRTRY - Error handling .ENABL LSB DZRTRY: .IF NE ERL$G .ADDR #DZRBUF,R3 MOV R3,R2 MOV #DZNREG,R0 10$: MOV (R4)+,(R3)+ DEC R0 BNE 10$ MOVB DRETRY,R3 SWAB R3 BISB #DZNREG,R3 MOV #,R4 BISB DZTRY,R4 DECB R4 MOV DZCQE,R5 CALL @$ELPTR MOV DZCSA,R4 .ENDC DEC (PC)+ DZTRY: .WORD 0 BGT 30$ 20$: JMP DZERR 30$: MOV DZ.CS1(R4),R0 .ADDR #DZERRT,R3 40$: TSTB @R3 BEQ 20$ CMP R0,(R3)+ BNE 40$ JMP DZINIT .DSABL LSB .SBTTL SILOFE - Fill or empty the silo .ENABL LSB SILOFE: MOV (R0)+,20$ MOV (R0)+,40$ MOV #512.,R3 CLRB DZ.CA(R4) MOV BUFRAD,R2 MOV BYTCNT,R1 BEQ 50$ .IF NE MMG$T JSR R0,@(PC)+ $P1EXT: .WORD P1EXT .WORD PARVAL-. .ENDC CMP R1,R3 BLOS 10$ MOV R3,R1 10$: SUB R1,R3 20$: HALT DEC R1 BNE 20$ .IF NE MMG$T PARVAL: .WORD 0 .ENDC 30$: TST R3 BEQ 50$ 40$: HALT DEC R3 BNE 40$ 50$: MOV #512.,R3 NOP RTS R0 .DSABL LSB .SBTTL Tables, fork block, end of driver .WORD C0.WRT-C0.RED .WORD C0.RED-C0.RED CHGTBL: .WORD 0 DZFBLK: .WORD 0,0,0,0 .NLIST BEX DZERRT: .WORD 060 .WORD 140 .WORD 200 .WORD 210 .WORD 0,0,0,0 .LIST BEX .IF NE ERL$G DZRBUF: .BLKW DZNREG .ENDC .SBTTL VECTOR TABLE DZ$VEC = PC$VEC .DRVTB DZ,0,DZINT,SLOTID=DZ$ID .SBTTL Bootstrap read routine .DRBOT DZ,BOOT1,READ1,CONTROL= . = DZBOOT+40 BOOT1: JMP @#BOOT-DZBOOT .ENABL LSB . = DZBOOT+120 READ1: MOV @#B$DEVU,-(SP) BR 10$ READ: MOV BTUNIT,-(SP) 10$: CALL FNDCSR MOV (SP)+,R4 ASL R4 BIS #C0.RED,R4 MOV R4,(PC)+ SELBIT: .WORD 0 ASL R1 MOV (PC)+,R4 .BYTE -7.,-10. 20$: CMP #1280.,R0 BHI 30$ ADD #-1280.,R0 30$: ROL R0 INCB R4 BLE 20$ MOVB R0,R5 ADD R4,R0 MOV R5,R4 ASL R5 40$: SUB #10.,R5 BGT 40$ MOV R5,TRKOF MOV R0,(PC)+ TRK: .BYTE 0 SEC: .BYTE 0 50$: MOVB SEC,R0 SUB #-6.,R0 BGT 60$ ADD #4.,R0 SEC 60$: ROL R0 ADD (PC)+,R0 TRKOF: .WORD 0 BGT 70$ ADD #10.,R0 70$: MOV (PC)+,R5 DZCSR0: .WORD PC$CSR+DZ$CS0 MOV SELBIT,@R5 MOVB TRK,DZ.CS1(R5) MOVB R0,DZ.CS2(R5) MOV R5,R4 ADD #DZ.DB,R4 CLRB DZ.GO(R5) 80$: BITB #C0.DON,@R5 BEQ 80$ CLRB DZ.CA(R5) MOV #512.,R0 90$: MOVB @R4,(R2)+ DEC R1 BEQ 100$ DEC R0 BNE 90$ 100$: INCB SEC BNE 110$ ADD #-10.*256.+1,TRK ADD #2,TRKOF BLE 110$ SUB #10.,TRKOF 110$: TST R1 BNE 50$ CLC RETURN .DSABL LSB FNDCSR: ASRB (PC)+ .WORD 1 BCC 3$ CLR R5 BISB @#173050,R5 SWAB R5 ASL R5 SUB #200,R5 MOV R5,@#KISAR1 MOV #AP$ACF,R5 MOV R5,@#KISDR1 CLR @#KISAR0 MOV R5,@#KISDR0 MOV #177600,@#KISAR7 MOV R5,@#KISDR7 BIS #20,@#MMUSR3 INC @#MMUSR0 MOV #CTI+PROCFG,R3 .ASSUME SLOT0 EQ CTI-4 MOV @R3,R4 MOV R4,R5 1$: TST -(R3) CMP -(R3),#DZ$ID BEQ 2$ SOB R5,1$ CLR @#MMUSR0 JMP @# 2$: CLR @#MMUSR0 SUB R5,R4 ASH #7.,R4 ADD R4,DZCSR0 3$: RETURN . = DZBOOT+556 BOOT: CALL FNDCSR MOV DZCSR0,R2 MOV @R2,R1 BIC #^C,R1 .ASSUME EQ 0 MOV R0,(PC)+ BTUNIT: .WORD 0 ASR R0 BIS R0,R1 MOV R1,@R2 CLRB DZ.GO(R2) 10$: BIT #,@R2 BEQ 10$ MOV #10000,SP MOV #2,R0 MOV #<4*256.>,R1 MOV #1000,R2 CALL READ MOV #READ1-DZBOOT,@#B$READ MOV BTUNIT,@#B$DEVU JMP @#B$BOOT .DREND DZ DZLOAD: MOV (R5),R5 .IF NE MMG$T MOV @#SYSPTR,R4 MOV P1EXT(R4),$P1EXT-DZLQE(R5) .ENDC MOV #DZ$ID,-(SP) TST (R1)+ CALL (R1) ADD (SP)+,DZCSA-DZLQE(R5) MOV #DZ$ID,-(SP) TST (R1)+ CALL (R1) MOV (SP)+,INTENB-DZLQE(R5) CLC RETURN .END .MCALL .MODULE .MODULE LD,VERSION=27,COMMENT= ; COPYRIGHT (c) 1986 BY ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. ; ALL RIGHTS RESERVED. ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED ; ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE ; INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER ; COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY ; OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY ; TRANSFERRED. ; ; THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE ; AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT ; CORPORATION. ; ; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS ; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL. .SbTtl Conditional assembly summary .SbTtl PSECT ordering .PSect LdDvr .PSect SetOvr .PSect LdRun .PSect .LibC. .NList BEX,CND .IIf NDF RTE$M RTE$M=0 .IIf NDF MMg$t MMg$t=0 .IIf NDF SJOnly SJOnly=0 .IIf NE SJOnly SJOnly=1 .IIf NDF LD$Own LD$Own=1 .IIf NE LD$Own LD$Own=1 .IIf NDF LD$Nam LD$Nam=^rLD .IIf NE SJOnly LD$Own=0 .IIf NDF EIS$I EIS$I=RTE$M!MMg$t .IIf NE SJOnly*MMg$t .Error .IIf NE SJOnly*RTE$M .Error .IIf NE MMg$t*RTE$M .Error .IIf NDF Def$LD Def$LD=:^rDSK .LDGen =: <2*MMg$t>!<10*RTE$M>!<400*EIS$I>!<1000*SJOnly>!<2000*LD$Own> .Audit .LD .LDGen Def$LD .SbTtl .If NE MMg$t .SbTtl *** Supports XM .SbTtl LDX is handler name .IfF .If EQ SJOnly .If EQ RTE$M .SbTtl *** Supports FB .SbTtl *** Supports SJ .SbTtl LD is handler name .IfF .SbTtl *** Supports RTEM .SbTtl LDM is handler name .EndC;EQ RTE$M .IfF .SbTtl *** Supports SJ .SbTtl LD is handler name .EndC .EndC .If EQ LD$Own .SbTtl Device ownership is NOT checked .IfF .SbTtl Device ownership IS checked .EndC .SbTtl .SbTtl Macros and Definitions .MCall .DrDef .MCall .CsiSpc .Print .Exit .Purge .MCall .LookUp .DStat .FProt .Fetch .MCall .Enter .SpFun .WritW .CStat .MCall .Release .SErr .Chain .SetTop .MCall .SReset .Assume .Br ...CmZ .MCall .Addr .CkXX .IIf EQ EIS$I .MCall SOB .CkXX .CkXX .CkXX .CkXX .CkXX .CkXX .CkXX CkUnit =: 3 CkUBuf =: 10000 CkSP =: 1000 CkFlag =: CkSP-2 CkCurr =: 3003 CkNUnit =: 5 CkFile =: 6 CkIndx =: 13 CkJunk =: 123456 .SbTtl Global References to ULBLIB .Globl $CBOMg .Globl $FnAsc .Globl $R50Asc LD.Cnt = 0 RM.Cnt = 0 .Macro $Rel Loc Value Base ...V2 = . . = Loc .If IDN Ld.Cnt = Ld.Cnt+1 .Irp ...V3 <\Ld.Cnt> LD.'...V3: .Word Value-LdBase .EndR . = ...V2 .MExit .EndC .If IDN RM.Cnt = RM.Cnt+1 .Irp ...V3 <\RM.Cnt> RM.'...V3: .Word Value .EndR . = ...V2 .MExit .EndC .Error .EndM $Rel .Macro Boff Dst Beq Dst .EndM Boff .Macro Bon Dst Bne Dst .EndM Bon .Macro ...... .EndM ...... .SbTtl Equates PR7 =: 7*40 JSP =: 42 JSW =: 44 SpXit$ =: 40 Chain$ =: 400 Ovly$ =: 1000 ChnIF$ =: 4000 RStrt$ =: 20000 JUsErB =: 53 Succs$ =: 1 Warn$ =: 2 Error$ =: 4 Fatal$ =: 10 Uncon$ =: 20 JRMon =: 54 InsCsr =: 176 InsCk =: 200 CmdLen =: 510 CmdStr =: 512 ChnTo =: 500 PPN =: 510 ChnFrm =: 512 ChnArg =: 522 ChnNon =: 377 ChnRtn =: 177 ChnErr =: 523 ChnUEB =: 524 ChnMsg =: 525 ChnEOL =: -1 Indx$M =: 76 SyUnit =: 275 SysVer =: 276 MinVer =: 5 ConFg1 =: 300 FBMon$ =: 000001 $MTPS =: 360 $MFPS =: 362 SyIndx =: 364 ConFg2 =: 370 LDRel$ =: 000020 SysGen =: 372 XMMon$ =: 000002 RTEM$ =: 000010 $PName =: 404 MaxSlt =: 31. EntEnd =: 177777 Suffix =: 412 OwnMsk =: 17 Odd =: 1 Bin2As =: '0 LC2UC =: 040 LC.a =: 'a LC.z =: 'z Bin2Rd =: ^r 0 WdsBlk =: 256. JobMsk =: 7 FilNum =: 17 Upd$Fn =: 372 H2B =: +1 B2H =: -1 Siz$Fn =: 373 Swt.$ =: '$ Swt.A =: 'A Swt.C =: 'C Swt.L =: 'L Swt.R =: 'R Swt.W =: 'W .SbTtl Define handler characteristics .DrDef LD, 46, FilSt$!SpFun$!VarSz$, 0, 0, 0 .DrPtr FETCH=INIT,LOAD=INIT .DrESt CLASS=DVC.DK,DATA=LDData,TYPE=LD .DRSpF .DRSpF .Asect .=:JSW .Word Ovly$ .SbTtl Installation check code .DrIns LD Br 10$ ........... .Assume . EQ InsSys Br InErr ............. 10$: Mov @#JRmon, R0 CK.R0=JRmon CK.R0 JRmon CmpB SysVer(R0),#MinVer Blo InErr .If NE SJOnly CK.R0 JRmon Bit #FBMon$,ConFg1(R0) Bon InErr .EndC CK.R0 JRmon Bit #RTEM$,SysGen(R0) .If NE RTE$M Boff InErr .IfF Bon InErr .EndC CK.R0 JRmon Bit #XMMon$,SysGen(R0) .If NE MMG$T Boff InErr .IfF Bon InErr .EndC Tst (PC)+ InErr: Sec Return ...... .Enable LSB DoChain: Mov @#JRMON,R0 CK.R0=JRmon CK.R0 JRmon Add SUFFIX(R0),RNAME Jsr R1,10$ .Rad50 "SY " RName: .RMODULE .Rad50 " SYS" .Word 0 .Word 0,0,0,0 .Word ChnEOL 10$: Mov #ChnTo,R0 20$: Mov @R1,(R0)+ Cmp #ChnEOL,(R1)+ Bne 20$ Tst -(R0) 30$: Mov @R3,(R0)+ Cmp #ChnEOL,(R3)+ Bne 30$ .Chain ...... .Dsabl LSB .Assume . LE 400,MESSAGE=<;Install area overflow> .SbTtl Set Code .Enable LSB .DrSet CLEAN Swt.C SetCle .DrSet EMPTY -1 SetMty .DrSet WRITE Swt.R SetWri NO .DrSet BPT NOP SetBPT SetBPT: Mov #BPT,R3 .Br SetNoB SetNoB: .Assume SetBPT+4 EQ SetNoB Cmp #BPTLen/2,R0 Blos SetErr Asl R0 CK.SP=CkSP CK.SP ,-2 Jsr R1,10$ BPTTab: .Word DBGSet-TabBas .Word DBGQue-TabBas BPTLen =: .-BPTTab 10$: Add R1,R0 Mov @R0,R0 Add PC,R0 TabBas=:. Mov R3,@R0 CK.SP ,+2 Mov (SP)+,R1 CK.SP CkSP Br SetOk ............. SetWri: Mov #Swt.W,R3 .Br SetNoW SetNoW: .Assume SetWri+4 EQ SetNoW .Br SetCle SetCle: Call DBGSet TstB -1(R5) Bne Not1Op MovB R3,Letter Bis #Bin2As,R1 MovB R1,Number Jsr R3,DoChain .............. .Assume . EQ 20$ 20$: .Ascii "/" Letter: .BlkB 1 .Ascii ":" Number: .BlkB 1 .Asciz "" .Even .Word ChnEOL SetMty: Call DBGSet TstB -1(R5) Bne Not1Op Jsr R3,DoChain .IRpC x,<01234567> .Ascii "/L:x" .EndR .Asciz "" .Even .Word ChnEOL .Enable LSB Not1Op: CK.SP=CkSP CK.SP ,-2 Jsr R0,SetMsg ................. .Ascii "?" .NLCsi TYPE=I,PART=NAME .Asciz "-F-Only 1 option per SET allowed" .Even SetMsg: 10$: TstB -(R5) TstB -1(R5) Bne 10$ .Print CK.SP ,+2 Tst (SP)+ CK.SP CkSP .Br SetOk SetOk: Tst (PC)+ SetErr: Sec Return ...... DBGSet: BPT .=:DBGSet;******************************;5 NOP Return ...... .Assume . LE 1000,MESSAGE=<;Set area overflow> LDHand =: 1000 .SbTtl Queue Manager code .Enable LSB .DrBeg LD LdBase =:LDSTRT+6 Br Cont ............ .SbTtl Data Area LdData:: Units =: 8. UntMsk =: Units-1 .Assume Units EQ 8. BufLow: .RAD50 "LD" .Word Units Handlr: .BlkW Units H.Leng =: 2 Handlz: Ld.Act =: 100000 Ld.RdO =: 040000 Ld$Unt =: 037400 Ld.UOf =: 000200 Ld.UNx =: 000100 Ld$Ndx =: 000076 .Assume . LE LDStrt+1000,MESSAGE=<;Set object not in block 1> Offset: .BlkW Units Size: .BlkW Units Name: .BlkW Units*4 BufHi: Cont: Mov LdCQE,R4 CK.R4=Q$BlkN DBGQue: BPT .=:DBGQue;******************************;3 NOP .Assume . LE LDStrt+1000,MESSAGE=<;Set object not in block 1> Mov #Handlr,R5 $Rel .-2 Handlr LD CK.R5=Handlr CK.R4 Q$BlkN MovB Q$Unit(R4),R2 Bic #^cUntMsk,R2 CK.R2=CkUnit CK.R2 CkUnit Asl R2 CK.R2=CkUnit*2 CK.R4 Q$BlkN MovB Q$Func(R4),R1 Bpl RelCk CmpB #Upd$Fn,R1 Bne 60$ CK.R5A=CK.R5 Cmp -(R5),-(R5) CK.R5A BufLow,-2-2 .If EQ MMG$T CK.R4 Q$BlkN Mov Q$Buff(R4),R2 CK.R2A=CkUBuf CK.R4 Q$BlkN Tst Q$WCnt(R4) .Assume B2H LT 0 Bmi 10$ CK.R5A BufLow Mov R5,R1 CK.R1=CK.R5A Mov R2,R5 CK.R5A=CK.R2A Mov R1,R2 CK.R2A=CK.R1 10$: Mov #BufHi-BufLow/2,R1 20$: Mov (R2)+,(R5)+ Sob R1,20$ .IfF Mov #BufHi-BufLow,R1 CK.R4 Q$BlkN Tst Q$WCnt(R4) .Assume B2H LT 0 Bmi 40$ CK.R5A BufLow 30$: CK.SP=CkSP MovB (R5)+,-(SP) CK.SP ,-2 Call @$PtByt CK.SP ,+2 CK.SP CkSP Sob R1,30$ Br LdDon1 .............. 40$: CK.R5A BufLow 50$: CK.SP=CkSP Call @$GtByt CK.SP ,-2 MovB (SP)+,(R5)+ CK.SP ,+2 CK.SP CkSP Sob R1,50$ .EndC Br LdDon1 .............. 60$: CmpB #Siz$Fn,R1 Bne LdDon1 .Assume Ld.Act EQ 100000 CK.R2 CkUnit*2 Tst Handlr(R2) $Rel .-2 Handlr LD CK.R4A=CK.R4 Bpl LdEr1 .If EQ Mmg$t CK.R2 CkUnit*2 CK.R4 Q$BlkN Mov Size(R2),@Q$Buff(R4) $Rel .-4 Size LD .IfF CK.R2 CkUnit*2 CK.SP=CkSP Mov Size(R2),-(SP) $Rel .-2 Size LD CK.SP ,-2 Call @$PtWrd CK.SP ,+2 CK.SP CkSP .EndC LdDon1: Jmp LdDone .............. .SbTtl Check the .Release/$UNLOAD bit .Enable LSB RelCk: Bit #LDRel$,@#ConFg2 $Rel .-2 ConFg2 RMON .CnFg2=:.-2 Boff 20$ Bic #LDRel$,@.CnFg2 Mov #Units,R1 CK.R1=Units Add R1,R5 CK.R5 ,+Units Add R1,R5 CK.R5 ,+Units CK.R5 Handlz 10$: Bis #Ld.Unx,-(R5) CK.R5 ,-<2*CK.R1> Sob R1,10$ CK.R5 Handlr .Br 20$ .SbTtl Check for valid info about LDn: unit n 20$: CK.R2 CkUnit*2 CK.R5 Handlr Add R2,R5 CK.R5=CkCurr CK.R5 CkCurr Tst @R5 LdEr1: .Assume Ld.Act EQ 100000 CK.R4B=CK.R4 Bpl LdErr CK.R5 CkCurr BitB #Ld.UNx!Ld.UOf,@R5 Boff LimCk .Assume Ld.UNx NE 200 .Assume Ld.UOf EQ 200 CK.R4C=CK.R4 Bmi LdErr Mov R2,R1 CK.R1=CK.R2 Asl R1 CK.R1=CK.R1*2 Asl R1 CK.R1=CK.R1*2 CK.R1 CkUnit*8. CK.SP=CkSP Mov R2,-(SP) CK.SP ,-2,CkR2 CkSP1=CK.R2 CK.R1 CkUnit*8. Mov Name(R1),-(SP) $Rel .-2 Name LD CK.SP ,-2,S.Name Beq 50$ Mov #$PName,R1 $Rel .-2 $PName RMON RM.PNm=:.-2 CK.R1=CkJunk Mov RM.Ent,R2 CK.R2=CkJunk 30$: CK.SP S.Name Cmp @SP,(R1)+ Beq 40$ Cmp R1,R2 Bne 30$ CK.R4D=CK.R4 Br 50$ ........... 40$: Sub RM.PNm,R1 Tst -(R1) Br 60$ ........... 50$: Sec 60$: Bit (SP)+,R2 CK.SP ,+2 Mov (SP)+,R2 CK.SP CkR2,+2 CK.SP CkSP CK.R2=CkSP1 CK.R4E=CK.R4 Bcs LdNoDv CK.R5 CkCurr MovB R1,@R5 .Assume <&Ld.UNx> EQ 0 .Br LimCk .SbTtl Validate request (R/O) and block limits ok .Enable LSB LimCk: CK.R4 Q$BlkN Mov Q$WCnt(R4),R1 Bpl ReadCk CK.R5 CkCurr Bit #Ld.RdO,@R5 CK.R4F=CK.R4 Bon LdErr Neg R1 ReadCk: CK.R4 Q$BlkN CK.R2 CkUnit*2 Cmp @R4,Size(R2) $Rel .-2 Size LD CK.R4G=CK.R4 Bhis LdErr Add #WdsBlk-1,R1 ClrB R1 .Assume WdsBlk EQ 400 SwaB R1 CK.R4 Q$BlkN Add @R4,R1 Bcs 10$ CK.R2 CkUnit*2 Cmp R1,Size(R2) $Rel .-2 Size LD Blos FixOft 10$: CK.R4 Q$BlkN Bis #HdErr$,@Q$CSW(R4) CK.R2 CkUnit*2 Mov Size(R2),R1 $Rel .-2 Size LD CK.R4 Q$BlkN Sub @R4,R1 ClrB R1 SwaB R1 CK.R4 Q$BlkN Mov R1,@Q$WCnt(R4) .Br FixOft FixOft: CK.R2 CkUnit*2 CK.R4 Q$BlkN Add Offset(R2),@R4 $Rel .-2 Offset LD CK.R2 CkUnit*2 MovB Handlr+1(R2),R1 $Rel .-2 Handlr+1 LD CK.R1=CkNUnit CK.R1 CkNUnit Bic #^cUntMsk,R1 CK.R1=CkNUnit&UntMsk CK.R4 Q$BlkN BicB #UntMsk,Q$Unit(R4) CK.R1 CkNUnit CK.R4 Q$BlkN BisB R1,Q$Unit(R4) .If EQ LD$Own .Br ReQue .IfF .Br OwnCk .SbTtl Process ownership validation .Enable LSB OwnCk: CK.R1 CkNUnit Asr R1 CK.R1=CkNUnit/2 ....SJ: Br ..NoCk .=:....SJ;******************************;3 CK.R5 CkCurr MovB @R5,R5 CK.R5=CkIndx Add R5,R1 CK.R1 ,+CK.R5 Add R5,R1 CK.R1 ,+CK.R5 CK.R1 CkNUnit/2+ MovB .-.(R1),R5 RM.Own=:.-2 CK.R5=CkJunk CK.R2 CkUnit*2 Bit #Odd,Handlr(R2) $Rel .-2 Handlr LD Boff 10$ .Rept 4 Asr R5 .EndR 10$: Bic #^cOwnMsk,R5 Boff ReQue Dec R5 CK.R4 Q$BlkN MovB Q$JNum(R4),R1 Asr R1 Asr R1 Asr R1 Bic #^cJobMsk*2,R1 Cmp R1,R5 CK.R4H=CK.R4 Bne LdErr .Br ReQue ..NoCk: .EndC .SbTtl Requeuing process ReQue: CK.R2 CkUnit*2 MovB Handlr(R2),R2 $Rel .-2 Handlr LD Mov .-.(R2),R2 RM.Ent=:.-2 CK.R4H=CK.R4 Beq LdNoDv Clr LdCQE Clr LdLQE Add #2,@SP Return LDInt:: ...... LdNoDv: LdErr: .IRpC x, CK.R4'x Q$BlkN .EndR Bis #HdErr$,@-(R4) LdDone: .DrFin LD .......... .DrEnd LD .SbTtl Initialization, one-time code .PSect SETOVR SetOvr: .Enable LSB Init:: Nop Mov @#JRMon,R4 CK.R4=JRmon Mov @R5,R1 CK.R1=LdBase RM.Did = 1 .Rept RM.Cnt .Irp x,<\RM.Did> CK.R4 JRmon CK.R1 LdBase Add R4,RM.'x-LdBase(R1) .EndR RM.Did = RM.Did+1 .EndR .Addr #LD.Lst,R0 10$: Mov (R0)+,R5 Bmi 20$ CK.R1 LdBase Add R1,R5 CK.R1 LdBase Add R1,@R5 Br 10$ .......... 20$: CK.R1 LdBase Mov @RM.PNm-LdBase(R1),R5 CK.R4 JRmon Add R4,R5 CK.R1 LdBase Mov R5,RM.PNm-LdBase(R1) Mov R5,R3 30$: Cmp (R5)+,#EntEnd Bne 30$ Tst -(R5) Sub R3,R5 .If NE LD$Own CK.R1 LdBase Mov R5,RM.Own-LdBase(R1) .EndC Asr R5 Mov R5,R0 Add R3,R5 CK.R1 LdBase Mov R5,RM.Ent-LdBase(R1) .If NE LD$Own Cmp (R0)+,(R0)+ Sub R0,R3 Sub R0,R3 CK.R1 LdBase Sub RM.Own-LdBase(R1),R3 CK.R1 LdBase Mov R3,RM.Own-LdBase(R1) .If EQ MMG$T CK.R1 LdBase Bit #FBMon$,ConFg1(R4) Bon 40$ CK.R1 LdBase Mov #.-.,....SJ-LdBase(R1) .....1=. .=.-4 Br ..NoCk-....SJ+. . =.....1 40$: .EndC; EQ MMG$T .EndC Clc Return ...... LD.Did = 1 LD.Lst: .Rept LD.Cnt .Irp x,<\LD.Did> .Word LD.'x-LdBase .EndR LD.Did = LD.Did+1 .EndR .Word -1 .=. .Assume . LE SetOvr+<2*1000>,MESSAGE=<;Init code overflow> .Assume LD.Cnt EQ LD.Did-1 .Assume RM.Cnt EQ RM.Did-1 .SbTtl LDRun - control LD handler .PSect LDRUN .Enable LSB LDRun:: Nop ...CmZ Fudge=.LD .SErr Mov #ClrLow,R0 Mov #ClrHi-ClrLow/2,R1 10$: Clr (R0)+ Sob R1,10$ Bit #Chain$,@#JSW Boff 20$ Mov #ChnArg,R1 CmpB #ChnNon,@R1 Bne 20$ Clr R1 20$: Mov #CmdBuf,R3 CK.R3=CmdBuf CK.R3 CmdBuf Mov R3,CmdPtr Clr CmdCnt CK.SP=CkSP CK.R3 CmdBuf .CSISpc #Out1,#DefExt,R1,R3 CK.SP ,-2,CkSNum Bcc 30$ Jsr R0,ErrMsg .Word MsgCsi Br Done2 ........... 30$: CK.R3 CmdBuf TstB @R3 Bne 40$ .Print #MsgId Br Done2 ............ 40$: Mov #In1,R0 Mov R0,R1 .Rept 3 Tst -(R0) .Rept 4 Mov -(R0),-(R1) .EndR .EndR .Br CkSys .SbTtl Insure that system channel open on LD handler on SY: .Enable LSB CkSys: Mov @#JRmon,R5 CK.R5=JRmon Mov #LD$Nam,R2 CK.R5 JRmon Add Suffix(R5),R2 Mov R2,DBlock+O.Name .CStat #CStatS,Code=NoSet Bic #^cLd$Ndx,CStat CK.R5 JRmon Cmp SyIndx(R5),CStat Bne 10$ CK.R5 JRmon CmpB SyUnit(R5),CStat+C.Unit Beq DoSwt 10$: .Purge #SysChn Mov #<^rSY >,DBlock+O.Dev Clr DBlock+O.Name+2 Mov #<^rSYS>,DBlock+O.Type .LookUp #LukUpS,Code=NoSet Bcc 20$ Jmp NoLErr .............. 20$: Bit #Chain$,@#JSW Bon 40$ Clr @#ChnFrm Mov #CmdBuf,R0 Mov #ChnArg,R1 30$: MovB (R0)+,(R1)+ Bne 30$ 40$: .Chain ...... ErrUkS: Jsr R0,ErrMsg .Word MsgUkS Br Done2 ............ ErrNoV: Jsr R0,ErrMsg .Word MsgNoV Br Done2 ............ .SbTtl Process switches .Enable LSB DoSwt: Mov #H2B,R5 Call SpFun Mov #CheckV,R5 CK.R5=CheckV CK.SP CkSNum,+2 Mov (SP)+,R1 Bne NxtSwt Done2: Br Done1 ............. NxtSwt: Mov #SwList-2,R2 CK.R2=SwSubr Mov (SP)+,R0 CmpB R0,#LC.a Blo 10$ CmpB R0,#LC.z Bhi 10$ Bic #LC2UC,R0 10$: 20$: CK.R2 SwSubr,+2 Tst (R2)+ CK.R2 SwLeng .Assume SwEOL EQ 0 CK.R2=SwEOL CK.R2 SwEOL,+1 TstB (R2)+ .Assume SwLEnd LT 0 Bmi ErrUkS CK.R2 SwLtr,+1 CmpB (R2)+,R0 CK.R2 SwSubr Bne 20$ CK.R2 SwSubr Jmp @(R2) ............ Swt$: Mov R0,Flag$ Bpl SwtXit Tst (SP)+ Br SwtXit ............. SwtA: Tst R0 Bpl ErrNoV Mov (SP)+,ValueA Br SwtNoC ............. SwtC: Mov R0,FlagC Bpl SwtXit Mov (SP)+,ValueC Br SwtXit ............. SwtL: CK.R5 CheckV Call @R5 CK.R3=CkUnit*2 CK.R3 CkUnit*2 Bis #Sw.L,Table(R3) SwaB R0 Bic #^cFilNum,R0 CK.R3 CkUnit*2 MovB R0,Table(R3) CK.R3 CkUnit*2 AsrB R3 CK.R3=CK.R3/2 CK.R3 CkUnit MovB R3,UnitA Inc CountL Br SwtNoC ............. SwtR: CK.R5 CheckV Call @R5 CK.R3=CkUnit*2 CK.R3 CkUnit*2 Bis #Sw.R,Table(R3) Br SwtNoC ............. SwtW: CK.R5 CheckV Call @R5 CK.R3=CkUnit*2 CK.R3 CkUnit*2 Bis #Sw.W,Table(R3) .Br SwtNoC SwtNoC: Inc FlgNoC SwtXit: Sob R1,NxtSwt .Br CkSwt .SbTtl CkSwt - verify correct switch selections .Enable LSB CkSwt: Tst FlagC Boff 10$ Tst FlgNoC Boff 20$ Jsr R0,ErrMsg .Word MsgSwC Br Done1 ............. 10$: Tst ValueA Boff DoFile Dec CountL Beq DoFile Jsr R0,ErrMsg .Word MsgALS Done1: Jmp Done ............ 20$: Mov #Handlr,R5 CK.R5=Handlr Mov #Name,R4 CK.R4=O.Dev Mov #In1-<3*>,R3 CK.R3=O.Dev Clr R1 Mov #Units,R2 .Br 30$ 30$: CK.R5 Handlr,+1 MovB R1,(R5)+ Inc R1 CK.R5 Handlr+1,+1 MovB (R5)+,R0 Bic #^cUntMsk,R0 CK.R4 O.Dev,+2 Add (R4)+,R0 Add #Bin2Rd,R0 CK.R3 O.Dev,+2 Mov R0,(R3)+ CK.R4 O.Name,+2 CK.R3 O.Name,+2 Mov (R4)+,(R3)+ CK.R4 O.Name+2,+2 CK.R3 O.Name+2,+2 Mov (R4)+,(R3)+ CK.R4 O.Type,+2 CK.R3 O.Type,+2 Mov (R4)+,(R3)+ CK.R4 O.Leng CK.R3 O.Leng Sob R2,30$ Mov #Handlr,R2 CK.R2A=Handlr Br DoSwtC .............. ErrNoF: Jsr R0,ErrMsg .Word MsgNoF Br FilXi1 .............. ErrDev: Jsr R0,ErrMsg .Word MsgDev Br FilXi1 .............. ErrRan: Jsr R0,ErrMsg .Word MsgRan FilXi1: Jmp FilXit .............. ErrHTB: Jsr R0,ErrMsg .Word MsgHTB Br SetTo1 .............. ErrFet: Jsr R0,ErrMsg .Word MsgFet Mov Sp,Feterr Tst FlagC Boff Done1 SetTo1: Jmp SetTop .............. ErrFNF: CK.SP=CkFlag Jsr R0,ErrMsg .Word MsgFNF CK.SP ,+2 Tst (SP)+ CK.SP CkSP Br Done1 ............. .SbTtl Process input and update handler tables .Enable LSB DoFile: Mov #Table,R2 CK.R2=Table DoSwtC: CK.R2A Handlr Mov #In1-<3*>,R1 CK.R1=O.Dev Mov #Handlr,R4 CK.R4=Handlr Clr R5 NxtFil: CK.R2 Table Tst @R2 .Assume 100000 EQ Sw.L Bpl 10$ CK.R4 Handlr Bic #Ld.Act!Ld.UOf,@R4 CK.R2 Table MovB @R2,R3 CK.R3=CkFile Bic #^cFilNum,R3 CK.R3 CkFile Asl R3 CK.R3=CK.R3*2 Asl R3 CK.R3=CK.R3*2 Asl R3 CK.R3=CK.R3*2 CK.R3 CkFile*8. Add R1,R3 CK.R3=O.Dev Tst @R3 Bon 20$ 10$: Jmp 110$ .......... 20$: CK.R3 O.Dev Tst O.Name(R3) CK.R3W=CK.R3 Boff ErrNoF CK.R4 Handlr Bis #Ld.Act!Ld.UNx,@R4 CK.SP=CkSP CK.SP ,-2,CkR1 Mov R1,-(SP) Mov #DStat,R1 Tst FlagC Boff 30$ Inc R1 30$: CK.R3 O.Dev .DStatus R1,R3 CK.SP CkR1,+2 Mov (SP)+,R1 CK.SP CkSP CK.R3Z=CK.R3 Bcs ErrDev Tst DStat+D.Stat .Assume 100000 EQ FilSt$ CK.R3X=CK.R3 Bpl ErrRan Tst DStat+D.EntP Bon 40$ Add LimHi,DStat+D.HSiz .SetTop DStat+D.HSiz Cmp R0,DStat+D.HSiz Blo ErrHTB CK.R3 O.Dev .Fetch LimHi,R3 CK.R3V=CK.R3 Bcs ErrFet 40$: CK.SP=CkSP CK.SP CkFlag,-2 Clr -(SP) .Assume Chan EQ 0 .Purge #0 CK.R3C=CK.R3 Call PhyLog CK.R3 O.Dev .LookUp #LukUpF,,R3,Code=NoSet CK.R3 O.Dev Bic #Odd,R3 Bcc 60$ .Br 50$ 50$: CK.SP CkFlag Inc @SP Tst FlagC CK.SP CkFlag CK.R3N=CK.R3 Boff ErrFNF CK.R4 Handlr Bis #Ld.UOf,@R4 CK.SP CkFlag CK.R3 O.Dev Mov O.Name(R3),@SP CK.R3 O.Dev Clr O.Name(R3) .Lookup #LukUpF,Code=NoSet CK.SP CkFlag CK.R3 O.Dev Mov @SP,O.Name(R3) 60$: .CStat #CStatF,Code=NoSet CK.R4 Handlr Mov CStat+C.Leng,Size-Handlr(R4) CK.R4 Handlr Mov CStat+C.SBlk,Offset-Handlr(R4) MovB CStat+C.Unit,R0 Bic #^cUntMsk,R0 Cmp #LD$Nam,CStat+C.DevN Bne 66$ Mov R5,-(SP) $1=1 .Rept 3 Asr @SP $1=$1+$1 .EndR .Assume O.Size EQ $1 CmpB (SP)+,R0 Bgt 66$ Beq 63$ Mov #NsWarn,WarnNS Br 66$ .......... 63$: Mov #NsErr,WarnNS 66$: CK.R4 Handlr BicB #UntMsk,1(R4) CK.R4 Handlr BisB R0,1(R4) .Assume Chan EQ 0 .Purge #0 CK.SP CkFlag,+2 Tst (SP)+ Bon 90$ Tst Flag$ Boff 80$ Tst DStat+D.EntP Bon 80$ CK.SP ,-2,CkR0 Mov R0,-(SP) CK.SP ,-2,CkR1 Mov R1,-(SP) Mov CmdPtr,R1 Mov #LCmnd,R0 .Br 70$ 70$: Inc CmdCnt MovB (R0)+,(R1)+ Bne 70$ TstB -(R1) Mov CStat+C.DevN,R0 Call $R50Asc ClrB (R1)+ Mov R1,CmdPtr Add #3,CmdCnt CK.SP CkR1,+2 Mov (SP)+,R1 CK.SP CkR0,+2 Mov (SP)+,R0 CK.SP CkSP 80$: CK.R3D=CK.R3 Call PhyLog CK.R3 O.Dev .FProt #FProt,,R3,Code=NoSet CK.R3 O.Dev Bic #Odd,R3 CK.R3M=CK.R3 Bcs ErrPro .Br 90$ 90$: Releas: CK.R3 O.Dev .Release R3 SetTop: .SetTop LimHi CK.R4 Handlr Bis #Ld.UNx,@R4 Mov R5,R0 Add #Name,R0 CK.R0=O.Dev Tst FetErr Bne 100$ CK.R0 O.Dev,+2 Mov CStat+C.DevN,(R0)+ CK.R3 O.Dev,+2 Tst (R3)+ CK.R3 O.Name,+2 CK.R0 O.Name,+2 Mov (R3)+,(R0)+ CK.R3 O.Name+2,+2 CK.R0 O.Name+2,+2 Mov (R3)+,(R0)+ CK.R3 O.Type,+2 CK.R0 O.Type,+2 Mov (R3)+,(R0)+ 100$: Clr FetErr Tst FlagC Bon 110$ CK.R4 Handlr Bic #Ld.RdO,@R4 110$: Mov #Ld.RdO,R0 Bit #Sw.W,@R2 Boff 130$ .Assume Sw.R EQ Ld.RdO CK.R2 Table Bit R0,@R2 Boff 120$ Mov SP,WarnRW 120$: CK.R4 Handlr Bic R0,@R4 130$: .Assume Sw.R EQ Ld.RdO CK.R2 Table Bit R0,@R2 Boff FilXit CK.R4 Handlr Bis R0,@R4 .Br FilXit FilXit: CK.R2 ,+2 CK.R4 ,+2 Cmp (R2)+,(R4)+ Add #O.Size,R5 Cmp #Units*O.Size,R5 Beq WrapUp CK.R2 T.Leng+Table CK.R4 H.Leng+Handlr Jmp NxtFil .............. ErrPro: Jsr R0,ErrMsg .Word MsgPro Br Releas .............. .SbTtl WrapUp .Enable LSB WrapUp: Tst WarnNs Beq 11$ .Assume NsErr LT 0 Bmi ErrFNs .Assume NsWarn GT 0 Jsr R0,ErrMsg .Word MsgWNs 11$: Clr FlagC .WritW #WritW,,,,,,Code=NoSet Bcc 20$ Tst LDMem Bon 10$ Cmp #-1,ValueC Beq 10$ Jsr R0,ErrMsg .Word MsgWri Br Done ............ 10$: Jsr R0,ErrMsg .Word MsgWWr 20$: Mov #B2H,R5 Call SpFun Done: Mov @#JSP,SP Tst WarnRW Bon 30$ Tst HadErr Bon 40$ Jsr R0,ErrMsg .Word MsgAOK Br 40$ ........... 30$: Clr WarnRW Jsr R0,ErrMsg .Word MsgWRW 40$: Tst CmdCnt Bon Kmon Tst ValueA Bon Kmon Bit #Chain$,@#JSW Bon 50$ .SReset Jmp LDRun ............. ErrFNs: Jsr R0,ErrMsg .Word MsgFNs Br 40$ 50$: Tst @#ChnFrm Boff Exit Chain: Mov #ChnTo,R2 Mov #ChnFrm,R1 .Rept 4 Mov (R1)+,(R2)+ .EndR .Assume Chan EQ 0 .Purge #0 .Chain ...... Kmon: Mov CmdPtr,R1 Mov CmdCnt,R3 Mov ValueA,R0 Boff 70$ BisB #Bin2As,UnitA Mov #ACmnd,R2 60$: Inc R3 MovB (R2)+,(R1)+ Bne 60$ TstB -(R1) Call $R50Asc ClrB (R1)+ Add #3,R3 70$: Mov #CmdBuf,R0 Mov #CmdLen,R1 Mov R3,(R1)+ .Assume CmdLen+2 EQ CmdStr 80$: MovB (R0)+,(R1)+ Sob R3,80$ Bis #SpXit$!ChnIF$,@#JSW Clr R0 Exit: .Exit ...... .SbTtl PHYLOG -- set low bit of R3 if /C specified .Enable LSB CK.R3C O.Dev CK.R3D O.Dev PhyLog: Tst FlagC Boff 10$ Inc R3 10$: Return .Dsabl LSB .SbTtl ErrMsg - process error messages .Enable LSB ErrMsg: CK.SP=CkSP CK.SP ,,CkR0E Mov SP,HadErr CK.SP ,-2,CkRet Mov R0,-(SP) CK.SP CkRet Add #2,@SP Mov @R0,R0 CK.SPE=CK.SP-2 CK.R0=M.Subr CK.R0 M.Subr,+2 Call @(R0)+ Tst ValueC Bge 10$ CK.R0 M.Num CmpB #Warn$,M.Levl-M.Num(R0) Bge 10$ CK.R0 M.Num MovB #Warn$,M.Levl-M.Num(R0) CK.R0 M.Num MovB #Sev.W,M.Sev-M.Num(R0) CK.SP ,-2,CkR1 10$: Mov R1,-(SP) Bit #Chain$,@#JSW Boff 30$ Tst @#ChnFrm Boff 30$ Mov #ChnArg,R1 MovB #ChnRtn,(R1)+ .Assume ChnErr EQ ChnArg+1 20$: MovB (R0)+,(R1)+ Bne 20$ Br 40$ ........... 30$: CK.R0 ,+2 Mov (R0)+,R1 .Assume CK.R0-1 EQ M.Levl Swab R1 BisB R1,@#JUsErB CK.R0 M.Sev TstB M.Msg-M.Sev(R0) Boff 40$ CK.SP ,-2,CkR0A Mov R0,-(SP) .Print #Prefix CK.SP CkR0A,+2 Mov (SP)+,R0 .Print 40$: CK.SP CkR1,+2 Mov (SP)+,R1 CK.SP CkRet,+2 Mov (SP)+,R0 CK.SP CkSP Rts R0 .......... .SbTtl SpFun Subroutine .Enable LSB SpFun: .DStatus #DStat!Odd,#R50LD Bcc 10$ NoLErr: Mov #R50LD,R3 CK.R3Y=O.Dev Jsr R0,ErrMsg .Word MsgDev Done3: Jmp Done ............ 10$: Mov DStat+D.EntP,LDMem Boff 30$ Cmp DStat+D.Stat,#LDSts Bne NoLErr Call 30$ .LookUp #LukUpL,Code=NoSet Bcc 20$ Jsr R0,ErrMsg .Word MsgLuk Br Done3 ............. 20$: .SpFun #SpFunL,WCnt=R5,Code=NoSet Bcc 30$ Jsr R0,ErrMsg .Word MsgSpF Br Done3 ............. 30$: .Assume Chan EQ 0 .Purge #0 Return ...... .SbTtl Check for valid switch values subroutine .Enable LSB CheckV: Tst R0 Bmi 10$ Jsr R0,ErrMsg .Word MsgNoV Br Done3 ............. 10$: Mov (SP)+,R3 Mov (SP)+,R2 Cmp #Units-1,R2 Bhis 20$ Jsr R0,ErrMsg .Word MsgBdV Br Done3 ............. 20$: Mov R3,-(SP) Mov R2,R3 Asl R3 Return ...... .SbTtl Error message formatting routines Device: CK.SP=CkSP CK.R0=M.Subr+2 CK.SP ,-2,CkR1 CK.R3Z O.Dev CK.R3Y O.Dev CK.R3X O.Dev CK.R3W O.Dev CK.R3V O.Dev Mov R1,-(SP) CK.R0 M.Out,+2 Mov (R0)+,R1 CK.SP ,-2,CkR0 Mov R0,-(SP) Mov #ErrBuf+2,R0 Clr @R0 CK.R3Z O.Dev Mov @R3,@R0 Clr 2(R0) Br CalFnA .............. File: CK.R3M O.Dev CK.R3N O.Dev CK.R0=M.Subr+2 CK.SPA=CkSP CK.SPA ,-2,CkR1 Mov R1,-(SP) CK.R0 M.Out,+2 Mov (R0)+,R1 CK.SPA ,-2,CkR0 Mov R0,-(SP) CK.R3M O.Dev Mov R3,R0 CalFnA: Call $FnAsc ClrB (R1)+ Br R01Ret .............. Switch: CK.R0=M.Subr+2 CK.R0 M.Out,+2 MovB CkR0E-CK.SPE(SP),@(R0)+ Return ...... SwiVal: CK.R0=M.Subr+2 CK.R0 M.Out,+2 MovB CkR0E-CK.SPE(SP),@(R0)+ CK.SPB=CkSP CK.SPB ,-2,CKR1B Mov R1,-(SP) CK.R0 M.Out2,+2 Mov (R0)+,R1 CK.SPB ,-2,CkR0B Mov R0,-(SP) Mov R1,R0 Mov R2,R1 CK.SPB ,-2,CkR2B Mov R2,-(SP) Clr R2 Call $CBOMg ClrB (R0)+ CK.SPB CkR2B,+2 Mov (SP)+,R2 R01Ret: CK.SPB CkR0B,+2 CK.SP CkR0,+2 Mov (SP)+,R0 CK.SPB CkR1B,+2 CK.SP CkR1,+2 Mov (SP)+,R1 CK.SPB CkSP CK.SP CkSP Nothin: RtsPC: Return ...... .SbTtl Messages MsgId: .IIf EQ MMg$T!RTE$M .NLCSI .If NE MMg$T .NLCSI TYPE=I,PART=NAME .Ascii "X " .NLCSI TYPE=Z,PART=RLSVER .EndC .If NE RTE$M .NLCSI TYPE=I,PART=NAME .Ascii "M " .NLCSI TYPE=Z,PART=RLSVER .EndC Prefix: .Ascii "?" .NLCSI TYPE=I,PART=NAME .Ascii "-"<200> M.Subr =: 0 M.Out =: 2 M.Out2 =: 4 M.Num =: 2 M.Levl =: 3 M.Sev =: 4 M.Msg =: 5 Sev.I =: 'I Sev.W =: 'W Sev.E =: 'E Sev.F =: 'F Sev.U =: 'U .Even MsgAOK: .Word Nothin .Asciz <-1>"" .Even MsgCsi: .Word Nothin .Asciz <1>"-Invalid Command" .Even MsgWRW: .Word Nothin .Asciz <2>"-/W and /R specified for same unit, /W ignored " .Even MsgDev: .Word Device,ChrDev .Ascii <3>"-Device not installed " ChrDev: .BlkB 4. .Asciz "" .Even MsgRan: .Word Device,ChrRan .Ascii <4>"-Invalid device " ChrRan: .BlkB 4. .Asciz "" .Even MsgNoV: .Word Switch,ChrNoV .Ascii <5>"-Switch without required value /" ChrNoV: .BlkB 1. .Asciz "" .Even MsgPro: .Word File,ChrPro .Ascii <6>"-Unable to protect file " ChrPro: .BlkB 14. .Asciz "" .Even MsgBdV: .Word SwiVal,ChrBdV,ValBdV .Ascii <7>"-Switch value out of range (0--7) /" ChrBdV: .BlkB 1. .Ascii ":" ValBdV: .BlkB 6. .Asciz "" .Even MsgNoF: .Word Device,ChrNoF .Ascii <8.>"-No file specified " ChrNoF: .BlkB 4. .Asciz "" .Even MsgFNF: .Word File,ChrFNF .Ascii <9.>"-File not found " ChrFNF: .BlkB 14. .Asciz "" .Even MsgUkS: .Word Switch,ChrUkS .Ascii <10.>"-Unknown switch (/C, /L, /R, or /W only) /" ChrUkS: .BlkB 1 .Asciz "" .Even MsgALS: .Word Nothin .Asciz <11.>"-/A requires exactly 1 /L" .Even MsgLuk: .Word Nothin .Asciz <12.>"-.LookUp for LD failed" .Even MsgSpF: .Word Nothin .Asciz <13.>"-.SpFun to LD failed" .Even MsgWri: .Word Nothin .Asciz <14.>"-Unable to update LD handler" .Even MsgWWr: .Word Nothin .Asciz <15.>"-Unable to update disk copy of LD handler" .Even MsgHTB: .Word Nothin .Asciz <16.>"-Insufficient memory" .Even MsgFet: .Word Device,ChrFet .Ascii <17.>"-.Fetch error " ChrFet: .BlkB 4. .Asciz "" .Even MsgSwC: .Word Nothin .Asciz <18.>"-/C not specified alone" .Even MsgFNs: .Word Nothin .Asciz <19.>"-Invalid nesting" .Even MsgWNs: .Word Nothin .Asciz <19.>"-Invalid nesting" .Even .SbTtl Data Chan =: 0 SysChn =: 17 ..LDEX:: DefExt: .Word Def$LD,Def$LD,Def$LD,Def$LD R50LD: .Word LD$Nam .Word 0 LimLow: .Limit LimHi =: LimLow+2 ACmnd: .Ascii "$ASSIGN LD" UnitA: .BlkB 1. .Asciz " " LCmnd: .Asciz "$LOAD " .Even SwList: SwEOL =: 0 SwLtr =: 1 SwSubr =: 2 SwLeng =: 4 .Byte 0,Swt.$ .Word Swt$ .Byte 0,Swt.A .Word SwtA .Byte 0,Swt.C .Word SwtC .Byte 0,Swt.L .Word SwtL .Byte 0,Swt.R .Word SwtR .Byte 0,Swt.W .Word SwtW SwLEnd =: -1 .Byte SwLEnd .SbTtl EMT argument blocks .LookUp =: 1 .Write =: 11 .CStat =: 27 .SpFun =: 32 .FProt =: 43 Protect =: 1 Physical=: RtsPC+1 .Even CStatF: .Byte Chan, .CStat .Word CStat CStatS: .Byte SysChn, .CStat .Word CStat FProt: .Byte Chan, .FProt .BlkW 1. .Word Protect LukUpF: .Byte Chan, .LookUp .BlkW 1. .Word 0 .BlkW 1 .Word Physical LukUpL: .Byte Chan, .LookUp .Word R50LD!Odd .Word 0 .BlkW 1 .Word Physical LukUpS: .Byte SysChn, .LookUp .Word DBlock!Odd .Word 0 .BlkW 1 .Word Physical SpFunL: .Byte Chan, .SpFun .Word 0 .Word BufLow .BlkW 1. .Byte 377, Upd$Fn .Word 0 WritW: .Byte SysChn, .Write .Word LDStrt/WdsBlk/2 .Word LDStrt .Word WdsBlk*2 .Word 0 .SbTtl Area to clear on startup ClrLow: ErrBuf: .BlkW 2. Flag$: .BlkW 1. FlagC: .BlkW 1. FlgNoC: .BlkW 1. ValueA: .BlkW 1 ValueC: .BlkW 1 CountL: .BlkW 1 WarnRW: .BlkW 1. WarnNs: .BlkW 1 NsWarn =: 1 NsErr =: -1 LDMem: .BlkW 1. HadErr: .BlkW 1. FetErr: .BlKW 1 CmdPtr: .BlkW 1. CmdCnt: .BlkW 1. DBlock =: ChnTo .IRpC .....1 <123> Out'.....1: .BlkW 5. .EndR .IRpC .....1 <123456> In'.....1: .BlkW 4. .EndR O.Dev =: 0 O.Name =: 2 O.Type =: 6 O.Leng =: 10 O.Size =: 10 DStat: .BlkW 4. D.Stat =: 0 D.HSiz =: 2 D.EntP =: 4 D.DSiz =: 6 CStat: .BlkW 6. C.CSW =: 0 C.SBlk =: 2 C.Leng =: 4 C.Used =: 6 C.Unit =: 10 C.DevN =: 12 Table: .BlkW Units T.Leng =: 2 Sw.L =: 100000 Sw.R =: 040000 Sw.W =: 000020 .Assume Sw.L EQ Ld.Act .Assume Sw.R EQ Ld.RdO CmdBuf: .BlkB 100. .Even ClrHi: .End LDRun .MCALL .MODULE .MODULE LP,VERSION=07,COMMENT=,AUDIT=YES ; COPYRIGHT (c) 1984,1985,1986 BY ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. ; ALL RIGHTS RESERVED. ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED ; ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE ; INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER ; COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY ; OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY ; TRANSFERRED. ; ; THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE ; AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT ; CORPORATION. ; ; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS ; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL. .SBTTL CONDITIONAL ASSEMBLY SUMMARY .SBTTL MACROS AND DEFINITIONS .MCALL .DRDEF .ASSUME .DRDEF LP,3,WONLY$!SPECL$,0,177514,200 .DRPTR .DREST CLASS=DVC.LP .IIF NDF LP.CSZ, LP.CSZ =: 132. .IIF NDF LP.PSZ, LP.PSZ =: 66. .IIF NDF OFORM, OFORM =: 1 IE =: 100 RDY =: 200 ERR =: 100000 HT =: 11 LF =: 12 FF =: 14 CR =: 15 CTRLQ =: 'Q-100 CTRLS =: 'S-100 SPACE =: 40 COLSIZ == LP.CSZ PAGSIZ == LP.PSZ CLOS.. =: 1 LOOK.. =: 3 ENTE.. =: 4 .SBTTL INSTALLATION CODE and SET CODE overflow .DRINS LP .=300 I.CSR: MOV R0,INSCSR MOV R0,LPS MOV R0,DISCSR ADD #2,R0 MOV R0,LPB BR CMPR03 .ASSUME . LE 400 .SBTTL SET OPTION PARAMETER TABLE .DRSET WIDTH,30.,O.WIDTH,NUM .DRSET CR,NOP,O.CR,NO .DRSET FORM0,NOP,O.FORM0,NO .DRSET HANG,,O.HANG,NO .DRSET LC,40,O.LC,NO .DRSET CTRL,,O.CTRL,NO .DRSET TAB,,O.TAB,NO .DRSET CSR,160000,O.CSR,OCT .DRSET VECTOR,477,O.VEC,OCT .DRSET ENDPAG,-1,O.ENDP,NUM .DRSET BIT8,<^c177>,O.BIT8,NO .IF NE OFORM .DRSET FORM,100000!LF,O.FF,NO .DRSET LENGTH,1,O.LENG,NUM .DRSET SKIP,O$LENG,O.SKIP,NUM .ENDC .SBTTL SET OPTION PROCESSING ROUTINES .ENABL LSB O.CSR: BR I.CSR O.WIDT: MOV R0,COLCNT MOV R0,O$WIDT CMPR03: CMP R0,R3 RETURN O.CR: MOV (PC)+,R3 BEQ RSTC-O$CR+. N.CR: MOV R3,O$CR .ASSUME O.CR+4 EQ N.CR RETURN O.FORM0:MOV (PC)+,R3 BEQ BLK0-O$FORM+. N.FORM0:MOV R3,O$FORM .ASSUME O.FORM0+4 EQ N.FORM0 RETURN O.HANG: MOV (PC)+,R3 BMI RET-O$HANG+. N.HANG: MOV R3,O$HANG .ASSUME O.HANG+4 EQ N.HANG RETURN O.LC: CLR R3 NOP N.LC: MOV R3,O$LC .ASSUME O.LC+4 EQ N.LC RETURN O.CTRL: MOV (PC)+,R3 BNE PRINTC-O$CTRL+. N.CTRL: MOV R3,O$CTRL .ASSUME O.CTRL+4 EQ N.CTRL RETURN O.TAB: MOV (PC)+,R3 BEQ HDWTAB-O$TAB+. N.TAB: MOV R3,O$TAB .ASSUME O.TAB+4 EQ N.TAB RETURN O.VEC: MOV R0,LPSTRT CMPR30: CMP R3,R0 RETURN O.ENDP: MOV R0,O$ENDP RETURN O.BIT8: MOV #^c377,R3 N.BIT8: MOV R3,O$BIT8 .ASSUME O.BIT8+4 EQ N.BIT8 RETURN .IF NE OFORM O.FF: MOV (PC)+,R3 .WORD FF N.FF: MOV R3,O$FF .ASSUME O.FF+4 EQ N.FF RETURN O.LENG: MOV R0,O$LENG MOV R0,LINCTR BR CMPR03 O.SKIP: TST R0 BEQ 2$ INC R0 2$: MOV R0,O$SKIP BR CMPR30 .ENDC .ASSUME . LE 1000 .DSABL LSB .SBTTL DRIVER ENTRY .DRBEG LP MOV LPCQE,R4 TSTB Q$FUNC(R4) BNE RET ASL Q$WCNT(R4) BEQ LPDONE BCC LPERR RET: BIS #IE,@LPS RETURN .SBTTL OPERATION COMPLETE LPERR: BIS #HDERR$,@-(R4) LPDONE: CLR @LPS CLR LPFBLK+2 .DRFIN LP .SBTTL INTERRUPT SERVICE .ENABL LSB .DRAST LP,4,LPDONE MOV LPCQE,R4 BIT #ERR!RDY,@(PC)+ LPS=:. .WORD LP$CSR .Assume . LE LPSTRT+1000,MESSAGE=<;Set code object not in block1> O$HANG=:. BMI RET .Assume . LE LPSTRT+1000,MESSAGE=<;Set code object not in block1> BEQ RET CLR @LPS .FORK LPFBLK MOV LPCQE,R4 MOVB Q$FUNC(R4),R5 BEQ WRITE BMI LPDONE CMPB #CLOS..,R5 BEQ 25$ CMPB #100!CLOS..,R5 BEQ DOFF CMPB #ENTE..,R5 BEQ 24$ CMPB #LOOK..,R5 BNE LPDONE 24$: CLR DIDIO BR LPDONE 25$: DIDIO=:.+2 TST #0 BEQ LPDONE O$ENDP=:.+2 MOV #0,Q$WCNT(R4) .Assume . LE LPSTRT+1000,MESSAGE=<;Set code object not in block1> BEQ LPDONE MOVB #100!CLOS..,Q$FUNC(R4) BR DOFF WRITE: MOV SP,DIDIO TST @R4 O$FORM0=:. BEQ BLK0 .Assume . LE LPSTRT+1000,MESSAGE=<;Set code object not in block1> LPNEXT: TSTB @LPS BPL RET ASLB (PC)+ TABFLG: .WORD 0 BNE TAB DOFF: .IF NE OFORM MOV (PC)+,R5 FFFLAG: .WORD 0 BMI DOFORM .ENDC CMPB #100!CLOS..,Q$FUNC(R4) BNE IGNORE DEC Q$WCNT(R4) BGE BLKZ BR LPDONE IGNORE: TST Q$WCNT(R4) BEQ LPDONE .IF EQ MMG$T MOVB @Q$BUFF(R4),R5 INC Q$BUFF(R4) .IFF CALL @$GTBYT MOV (SP)+,R5 .ENDC INC Q$WCNT(R4) O$BIT8=:.+2 BIC #^C<177>,R5 .Assume . LE LPSTRT+1000,MESSAGE=<;Set code object not in block1> BEQ IGNORE .IF NE OFORM ASRB (PC)+ SKPFLG: .WORD 0 BCC 1$ CMPB #FF,R5 BEQ IGNORE 1$: .ENDC CMPB R5,#SPACE BLO CHRTST CMPB R5,#'a!40 BLO PCHAR CMPB R5,#'z!40 BHI PCHAR SUB (PC)+,R5 O$LC=:. .WORD 40 .Assume . LE LPSTRT+1000,MESSAGE=<;Set code object not in block1> PCHAR: DEC COLCNT BLT IGNORE ASLB (PC)+ TABCNT: .WORD 1 BEQ RSTTAB PRINTC: MOVB R5,@(PC)+ LPB=:. .WORD LP$CSR+2 .Assume . LE LPSTRT+1000,MESSAGE=<;Set code object not in block1> BR LPNEXT CHRTST: CMPB #HT,R5 O$TAB=:. BEQ TABSET .Assume . LE LPSTRT+1000,MESSAGE=<;Set code object not in block1> CMPB #FF,R5 BEQ SENDFF CMPB #CR,R5 O$CR=:. NOP .Assume . LE LPSTRT+1000,MESSAGE=<;Set code object not in block1> CMPB #LF,R5 O$CTRL=:. BNE IGNORE .Assume . LE LPSTRT+1000,MESSAGE=<;Set code object not in block1> .IF NE OFORM CMP LINCTR,(PC)+ O$SKIP=:. .WORD 0 .Assume . LE LPSTRT+1000,MESSAGE=<;Set code object not in block1> BLE SKIPFF DOFORM: DEC LINCTR BGT RSTC NEWPAG: MOV (PC)+,(PC)+ O$LENG=:. .WORD LP.PSZ .Assume . LE LPSTRT+1000,MESSAGE=<;Set code object not in block1> LINCTR: .WORD LP.PSZ .Assume . LE LPSTRT+1000,MESSAGE=<;Set code object not in block1> CLR FFFLAG .ENDC RSTC: MOV (PC)+,(PC)+ O$WIDT=:. .WORD LP.CSZ .Assume . LE LPSTRT+1000,MESSAGE=<;Set code object not in block1> COLCNT: .WORD LP.CSZ .Assume . LE LPSTRT+1000,MESSAGE=<;Set code object not in block1> RSTTAB: MOV #1,TABCNT BR PRINTC TABSET: MOV TABCNT,TABFLG TAB: MOV #SPACE,R5 BR PCHAR HDWTAB: ASLB TABCNT BEQ RSTTAB DEC COLCNT BR HDWTAB .IF NE OFORM SKIPFF: INC SKPFLG BR SENDFF .ENDC BLKZ: BLK0: INC @R4 SENDFF: MOV (PC)+,R5 O$FF=:. .WORD FF .Assume . LE LPSTRT+1000,MESSAGE=<;Set code object not in block1> .IF NE OFORM MOV R5,FFFLAG BPL NEWPAG BR DOFORM .IFF BR RSTC .ENDC .DSABL LSB LPFBLK: .WORD 0,0,0,0 .DREND LP .END .MCALL .MODULE .MODULE LS,VERSION=19,COMMENT= ; COPYRIGHT (c) 1984,1985,1986 BY ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. ; ALL RIGHTS RESERVED. ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED ; ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE ; INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER ; COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY ; OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY ; TRANSFERRED. ; ; THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE ; AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT ; CORPORATION. ; ; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS ; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL. .SBTTL Conditional assembly summary .SBTTL ORDER and LABEL PSECTS .PSECT LSDVR .PSECT $$$PAD .PSECT SETOVR .PSECT PC$PDP PCBASE: .PSECT LSDVR .SBTTL MACROS AND DEFINITIONS .DSABL GBL .IIF NDF LS$PC LS$PC = 0 .IIF NDF LS$PDP LS$PDP = 1 .IIF EQ LS$PC!LS$PDP .ERROR LSBOTH = LS$PC&LS$PDP .IIF NDF TIM$IT TIM$IT= 0 .IIF NE TIM$IT TIM$IT= 1 .IIF NDF LS$HANG LS$HANG = TIM$IT .IIF NE LS$HANG LS$HANG = 1 .IIF NE MMG$T EIS$I = 1 .IIF NDF EIS$I EIS$I = 0 .IIF NDF LS$PRI LS$PRI = 4 .IIF NDF LS.CSZ LS.CSZ = 132. .IIF NDF LS.PSZ LS.PSZ = 66. .IIF NDF LS$VCX LS$VCX = 470 PC.CSR = 173400 PC.VEC = 220 .LSGEN = LS$PDP!!! .AUDIT .LS .AUDIT .LSGEN .MCALL .DRDEF, .INTEN, .MTPS .MCALL .ADDR, .ASSUM, .BR .MCALL .READC, .WRITE, .WRITC .IIF EQ EIS$I .MCALL SOB F.BADR = 2 .IF NE LS$PC .IF EQ LS$PDP LS$CSR = PC.CSR LS$VEC = PC.VEC .ENDC .ENDC .IF NE LS$PDP .DRDEF LS,41,,0,176500,300 .IFF .DRDEF LS,41,,0,173400,220 .ENDC .IF NE LSBOTH .DRPTR FETCH=FETCH,LOAD=FETCH .DREST CLASS=DVC.LP,MOD2=DV2.V2 .IFF .DRPTR .DREST CLASS=DVC.LP .ENDC CLOS.. =:1 LOOK.. =:3 ENTE.. =:4 .READ =:10 .WRITE =:11 SYSPTR = 54 SPUSR =:272 ILLFUN =:2 LOWMAP =:326 CONFG2 =:370 PRO$ = 020000 SYSGEN = 372 V.TRP4 =: 004 BLK =: 1000 BLOCK0 = 0 PSW = 177776 PR0 =:000000 PR7 =:000240 CARRY =:000001 SYSCHN = 17 RC.IE = 000100 XC.IE = 000100 IC0DR = 173200 IC0CR = IC0DR+2 C.CSM = 050 C.SSM = 070 C.CSI = 110 C.SSI = 130 RC.ID = 005 XC.ID = 006 LS$BUF = PC.CSR LS$STA = PC.CSR+2 LS$MOD = PC.CSR+4 LS$CMD = PC.CSR+6 ST.DSR = 200 ST.FE = 040 ST.OE = 020 ST.PE = 010 ST.RD = 002 ST.TR = 001 M1.SBM = 300 SB.1 = 100 SB.15 = 200 SB.2 = 300 M1.PT = 040 M1.PEN = 020 M1.CLM = 014 CL.5 = 000 CL.6 = 004 CL.7 = 010 CL.8 = 014 M1.REQ = 002 M2.REQ = ^B10110000 B.50 = 00 B.75 = 01 B.110 = 02 B.134 = 03 B.150 = 04 B.300 = 05 B.600 = 06 B.1200 = 07 B.1800 = 10 B.2000 = 11 B.2400 = 12 B.3600 = 13 B.4800 = 14 B.7200 = 15 B.9600 = 16 B.192K = 17 CM.OM1 = 200 CM.OM0 = 100 CM.RTS = 040 CM.RE = 020 CM.FB = 010 CM.RXE = 004 CM.DTR = 002 CM.TXE = 001 HT = 11 LF = 12 FF = 14 CR = 15 CTRLQ = 'Q-100 CTRLS = 'S-100 SPACE = 40 .SBTTL Block 0 of handler file .ASECT . = 0 REF0:: . = 120 ROMCHK: .IF EQ LS$PC CLRB @INSCSR .IFF CLRB @DISCSR .ENDC BCS 1$ .IF EQ LS$PC BITB #177,@INSCSR .IFF BITB #177,@DISCSR .ENDC BEQ 1$ SEC 1$: RETURN .ASSUME . LE ,MESSAGE=<;Code below installation code too large> .SBTTL INSTALLATION CODE .ENABL LSB .IF NE LSBOTH .DRINS -LS,PC.CSR .IFF .DRINS LS .ENDC BR 1$ BR SETER2 1$: MOV @#SYSPTR,R0 BIT #PRO$,CONFG2(R0) .IF EQ LS$PC BNE SETER2 .ENDC .IF EQ LS$PDP BEQ SETER2 .IFF BEQ ROMCHK .ENDC .IF NE LS$PC TST @#LS$CMD MOVB #,@#LS$MOD MOVB #,@#LS$MOD ISPEED=:.-4 MOVB #,LS$CMD BR 20$ I.SPEE: .IF NE LSBOTH MOV @#SYSPTR,R1 BIT #PRO$,CONFG2(R1) BEQ SETER2 .ENDC .ADDR #SPEEDT,R1 10$: TST (R1) BEQ SETER2 CMP R0,(R1)+ BNE 10$ SUB PC,R1 SUB #,R1 ASR R1 BIS #M2.REQ,R1 TST @#LS$CMD TST @#LS$MOD MOVB R1,@#LS$MOD MOV R1,ISPEED .ENDC 20$: TST (PC)+ SETER2: SEC RETURN .DSABL LSB .IF NE LS$PDP I.VEC: .IF NE LSBOTH MOV R0,LX$VTB .IFF MOV R0,LS$VTB .IFTF ADD #4,R0 .IFT MOV R0,LX$VTB+6 .IFF MOV R0,LS$VTB+6 .ENDC CMP R3,R0 RETURN .ENDC .ASSUME . LT 400 MESSAGE=<;Installation code too large> .SBTTL SET OPTION PARAMETER TABLE .DRSET BIT8 O.BIT8/2 GETOVR NO .DRSET CR O.CR/2 GETOVR NO .IF NE LS$PDP .DRSET CSR O.CSR/2 GETOVR OCT .ENDC .DRSET CTRL O.CTRL/2 GETOVR NO .DRSET ENDPAG O.ENDP/2 GETOVR NUM .DRSET FORM O.FF/2 GETOVR NO .DRSET FORM0 O.FORM0/2 GETOVR NO .DRSET GRAPH O.GRAP/2 GETOVR NO .IF NE LS$HANG .DRSET HANG O.HANG/2 GETOVR NO .ENDC .DRSET LC O.LC/2 GETOVR NO .DRSET LENGTH O.LENG/2 GETOVR NUM .DRSET SKIP O.SKIP/2 GETOVR NUM .IF NE LS$PC .DRSET SPEED -1 O.SPEE NUM .ENDC .DRSET TAB O.TAB/2 GETOVR NO .IF NE LS$PDP .DRSET VECTOR 477 O.VEC OCT .ENDC .DRSET WIDTH O.WIDTH/2 GETOVR NUM .SBTTL SET OPTION PROCESSING ROUTINES .ENABL LSB .IF NE LS$PDP O.VEC: BR I.VEC .ENDC .IF NE LS$PC O.SPEE: BR I.SPEE SPEEDT: .WORD 50., 75., 110., 134., 150., 300. .WORD 600., 1200., 1800., 2000., 2400., 3600. .WORD 4800., 7200., 9600., 19200. .WORD 0 .ENDC .SBTTL GETOVR - Get Overlay SET code routine from disk .ENABL LSB .Assume . LE 656,MESSAGE=<;Overlay read routine overlaps set code> .=656 VALWCT =: ./2 OVRSIZ =: . .SBTTL GETBK0 - Read block zero - resident routine GETBK0: MOV #SET.EX/2,R3 .BR GETOVR GETOVR:: CMPB -(R3),-(R3) NOP .Assume . EQ GETOVR+4 CMPB (R3)+,(R3)+ MOV R0,-(SP) SWAB R3 MOVB R3,REABLK BIC #377,R3 .Assume BLOCK0 EQ 0 JSR R0,10$ REAFUN: .BYTE 17,10 REABLK: .BLKW 1 REABUF: .BLKW 1 .WORD VALWCT .WORD 0 10$: .ADDR #BLOCK0,R5,PUSH MOV R5,REABUF MOV (SP)+,R5 EMT 375 MOV (SP)+,R0 BCS SET.NOR SWAB R3 ASL R3 ADD REABUF,R3 MOV (SP)+,R0 JMP @R3 .DSABL LSB SET.EX: TST R2 BEQ SET.NOR DEC R2 BEQ SET.ERR ADD #2,(SP) SET.ERR:SEC SET.NOR:RETURN .DSABL LSB .Assume . LE 1000,MESSAGE=<;Set code overflow> .SBTTL DRIVER ENTRY .ENABL LSB .DRBEG LS LSBASE =:LSSTRT+6 MOV LSCQE,R4 MOVB Q$FUNC(R4),R5 BNE FILREQ ASL Q$WCNT(R4) BEQ LSDON1 BCC LSERR MOV SP,DIDIO .IF NE LSBOTH PDPA1: .ENDC .IF NE LS$PDP BIS #RC.IE,@RCSR .ENDC .IF NE LSBOTH PDPZ1 =:.-PDPA1 .SAVE .PSECT PC$PDP PCA1: .ENDC .IF NE LS$PC MOVB #,@#IC0CR .ENDC .IF NE LSBOTH PCZ1 =:.-PCA1 .RESTORE .Assume PDPZ1 EQ PCZ1 .ENDC DOINT: .IF NE LSBOTH PDPA2: NOP NOP NOP NOP NOP NOP PDPZ2 =:.-PDPA2 .SAVE .PSECT PC$PDP PCA2: .ENDC .IF NE LS$PC MOVB #,@#IC0CR MOVB #,@#IC0CR .ENDC .IF NE LSBOTH PCZ2 =:.-PCA2 .RESTORE .Assume PDPZ2 EQ PCZ2 .ENDC TST STALLF .IF EQ LS$HANG BEQ 20$ .IFF BEQ O$HANG ENAOU1: CALLR ENAOUI .IFT ENAOU1: CALL ENAOUI 20$: RETURN .ENDC FILREQ: BMI LSDONE CLR Q$WCNT(R4) CMPB #ENTE..,R5 BEQ 24$ CMPB #CLOS..,R5 BEQ DOINT CMPB #LOOK..,R5 BNE 25$ 24$: CLR DIDIO 25$: LSDON1: BR LSDONE .DSABL LSB .SBTTL REGISTERS AND VECTOR TABLES .IF NE LS$PDP RCSR: .WORD LS$CSR RBUF: .WORD LS$CSR+2 XCSR: .WORD LS$CSR+4 XBUF: .WORD LS$CSR+6 .ENDC .IF NE LSBOTH .DRVTB LS,LS$VCX,LIINT .DRVTB ,LS$VCX+4,LSINT .DRVTB LX,LS$VEC,LIINT .IFF .DRVTB LS,LS$VEC,LIINT .ENDC .DRVTB ,LS$VEC+4,LSINT .SBTTL INPUT INTERRUPT SERVICE .ENABL LSB .DRAST LI,LS$PRI,LSABT .IF NE LSBOTH PDPA3: .ENDC .IF NE LS$PDP MOVB @RBUF,R4 .ENDC .IF NE LSBOTH PDPZ3 =:.-PDPA3 .SAVE .PSECT PC$PDP PCA3: .ENDC .IF NE LS$PC MOVB @#LS$BUF,R4 .ENDC .IF NE LSBOTH PCZ3 =:.-PCA3 .RESTORE .Assume PDPZ3 EQ PCZ3 .ENDC BIC #^C<177>,R4 CMPB R4,#CTRLQ BNE 20$ .IF NE LS$HANG CALL CTIMER .ENDC MOV SP,STALLF BR ENAOU1 20$: CMPB R4,#CTRLS BNE 30$ CALL DISOUI CLR STALLF .IF NE LS$HANG TST LSCQE BEQ 30$ O$HANG: BR EXIT .Assume .-LSSTRT LE 1000,MESSAGE=<;Code to set not in block 1> TST TCOMPL BNE 30$ MOV LSCQE,R4 MOVB Q$JNUM(R4),R4 ASR R4 ASR R4 ASR R4 BIC #^C<16>,R4 MOV R4,TJOBNM .ADDR #OFFLIN,R4 MOV R4,TCOMPL .FORK LIFBLK .TIMIO TBLOCK,0,60.*5 .ENDC EXIT: 30$: RETURN .DSABL LSB .SBTTL OPERATION COMPLETE .ENABL LSB LSABT: .IF NE LS$HANG CALL LSCLR CALL CTIMER .ENDC MOV SP,STALLF BR LSDONE LSERR: BIS #HDERR$,@-(R4) LSDONE: CALL LSCLR .DRFIN LS LSCLR: CLR LIFBLK+F.BADR CALL DISOUI .IF NE LSBOTH PDPA4: .ENDC .IF NE LS$PDP BIC #RC.IE,@RCSR .ENDC .IF NE LSBOTH PDPZ4 =:.-PDPA4 .SAVE .PSECT PC$PDP PCA4: .ENDC .IF NE LS$PC 10$: MOVB #,@#IC0CR .ENDC .IF NE LSBOTH PCZ4 =:.-PCA4 .RESTORE .Assume PDPZ4 EQ PCZ4 .ENDC RETURN .DSABL LSB .SBTTL OUTPUT INTERRUPT SERVICE .ENABL LSB .DRAST LS,LS$PRI,LSABT CALL DISOUI MOV LSCQE,R4 BEQ 20$ CMPB #CLOS..,Q$FUNC(R4) BNE 17$ DIDIO =:.+2 TST #.-. BEQ LSDONE O$ENDP=:.+2 MOV #0,Q$WCNT(R4) .Assume .-LSSTRT LE 1000,MESSAGE=<;Code to set not in block 1> BEQ LSDONE MOVB #<100!CLOS..>,Q$FUNC(R4) 17$: CMPB #<100!CLOS..>,Q$FUNC(R4) BEQ 19$ TST @R4 O$FORM: BEQ BLK0 .Assume .-LSSTRT LE 1000,MESSAGE=<;Code to set not in block 1> TST STALLF BEQ 20$ ASLB (PC)+ TABFLG: .WORD 0 BNE TAB 19$: MOV (PC)+,R5 FFFLAG: .WORD 0 BNE DOFORM CMPB #<100!CLOS..>,Q$FUNC(R4) BNE 18$ DEC Q$WCNT(R4) BGE BLKZ BR LSDONE 18$: IGNORE: TST Q$WCNT(R4) BEQ LSDONE .IF EQ MMG$T MOVB @Q$BUFF(R4),R5 INC Q$BUFF(R4) .IFF CALL @$GTBYT MOV (SP)+,R5 .ENDC INC Q$WCNT(R4) O$BIT8=:.+2 BIC #^C<177>,R5 .Assume .-LSSTRT LE 1000,MESSAGE=<;Code to set not in block 1> BEQ IGNORE ASRB (PC)+ SKPFLG: .WORD 0 BCC 10$ CMPB R5,#FF BEQ IGNORE 10$: CMPB R5,#SPACE BLO CHRTST CMPB R5,#'A!40 BLO PCHAR CMPB R5,#'Z!40 BHI PCHAR BIC (PC)+,R5 O$LC: .WORD 0 .Assume .-LSSTRT LE 1000,MESSAGE=<;Code to set not in block 1> PCHAR: DEC COLCNT O$GRAP: BLT IGNORE .Assume .-LSSTRT LE 1000,MESSAGE=<;Code to set not in block 1> ASLB (PC)+ TABCNT: .WORD 1 BEQ RSTTAB PRINTC: .IF NE LSBOTH PDPA5: .ENDC .IF NE LS$PDP MOVB R5,@XBUF .ENDC .IF NE LSBOTH PDPZ5 =:.-PDPA5 .SAVE .PSECT PC$PDP PCA5: .ENDC .IF NE LS$PC MOVB R5,@#LS$BUF .ENDC .IF NE LSBOTH PCZ5 =:.-PCA5 .RESTORE .Assume PDPZ5 EQ PCZ5 .ENDC CALL ENAOUI 20$: RETURN CHRTST: CMPB R5,#HT O$TAB: BEQ TABSET CMPB R5,#FF BEQ SENDFF CMPB R5,#CR O$CR: BEQ RSTC CMPB R5,#LF O$CTRL: BNE PRINTC CMP LINCTR,(PC)+ O$SKIP: .WORD 0 BLE SKIPFF DOFORM: DEC LINCTR BGT RSTC .IF EQ <.-LSSTRT>&777-774 NOP .ENDC NEWPAG: MOV (PC)+,(PC)+ O$LENG: .WORD LS.PSZ LINCTR: .WORD LS.PSZ CLR FFFLAG .IF EQ <.-LSSTRT>&777-774 NOP .ENDC RSTC: MOV (PC)+,(PC)+ O$WIDT: .WORD LS.CSZ COLCNT: .WORD LS.CSZ CLR TABFLG RSTTAB: MOV #1,TABCNT BR PRINTC BLKZ: BLK0: INC @R4 SENDFF: MOV #CR,R5 O$FF = .+2 MOV #FF,FFFLAG BMI RSTC CLR LINCTR BR RSTC TABSET: MOV TABCNT,TABFLG TAB: MOV #SPACE,R5 BR PCHAR HDWTAB: ASLB TABCNT BEQ RSTTAB DEC COLCNT BR HDWTAB SKIPFF: INC SKPFLG BR SENDFF .DSABL LSB .IF NE LS$HANG .SBTTL TIMER SUPPORT ROUTINES CTIMER: TST TCOMPL BEQ 10$ .FORK LIFBLK .CTIMIO TBLOCK CLR TCOMPL 10$: RETURN OFFLIN: MOV @SP,-(SP) .IF EQ MMG$T CLR 2(SP) .IFF MOV @#PSW,2(SP) .ENDC .MTPS #340 .INTEN 0,PIC CLR TCOMPL MOV LSCQE,R4 JMP LSERR .ENDC .SBTTL INTERRUPT ENABLE ROUTINES ENAOUI: .IF NE LSBOTH PDPA6: .ENDC .IF NE LS$PDP BIS #XC.IE,@XCSR .ENDC .IF NE LSBOTH PDPZ6 =:.-PDPA6 .SAVE .PSECT PC$PDP PCA6: .ENDC .IF NE LS$PC 10$: MOVB #,@#IC0CR .ENDC .IF NE LSBOTH PCZ6 =:.-PCA6 .RESTORE .Assume PDPZ6 EQ PCZ6 .ENDC RETURN DISOUI: .IF NE LSBOTH PDPA7: .ENDC .IF NE LS$PDP BIC #XC.IE,@XCSR .ENDC .IF NE LSBOTH PDPZ7 =:.-PDPA7 .SAVE .PSECT PC$PDP PCA7: .ENDC .IF NE LS$PC 10$: MOVB #,@#IC0CR .ENDC .IF NE LSBOTH PCZ7 =:.-PCA7 .RESTORE .Assume PDPZ7 EQ PCZ7 .ENDC RETURN .SBTTL IMPURE DATA AREAS STALLF: .WORD 1 .IF NE LS$HANG TBLOCK: .WORD 0,0,0 TJOBNM: .WORD 0 .WORD 177000+LS$CODE .WORD -1 TCOMPL: .WORD 0 .ENDC LIFBLK: .WORD 0,0,0,0 .DREND LS .SBTTL OVRBK0 -- overlay block number zero .PSECT SETOVR OVRBK0: BIAS == O.TAB: BR 20$ NOP MOV (PC)+,R3 BEQ TABSET-O$TAB+. BR 30$ 20$: MOV (PC)+,R3 BEQ HDWTAB-O$TAB+. 30$: MOV R3,-(SP) MOV #,R3 CALL CORWRT MOV (SP)+,R3 BCS S.IGN1 MOV R3,(R2) BR CORXI1 O.CR: BR 20$ NOP MOV (PC)+,R3 NOP BR 30$ 20$: MOV (PC)+,R3 BEQ RSTC-O$CR+. 30$: MOV R3,-(SP) MOV #,R3 CALL CORWRT MOV (SP)+,R3 S.IGN1: BCS S.IGN MOV R3,(R2) CORXI1: BR CORXIT O.SKIP: CMP #255.,R0 BLO S.ERR TST R0 BEQ 10$ INC R0 10$: MOV #,R3 MOV R0,-(SP) CALL CORWRT MOV (SP)+,R0 BCS S.IGN MOV R0,(R2) BR CORXIT O.LENG: TST R0 BLE S.ERR MOV #,R3 MOV R0,-(SP) CALL CORWRT MOV (SP)+,R0 BCS S.IGN MOV R0,(R2) MOV R0,(R2) BR CORXIT O.WIDT: CMP R0,#30. BLT S.ERR MOV #,R3 MOV R0,-(SP) CALL CORWRT MOV (SP)+,R0 BCS S.IGN MOV R0,(R2) MOV R0,(R2) BR CORXIT O.CTRL: BR 20$ NOP MOV (PC)+,R3 BNE IGNORE-O$CTRL+. BR 30$ 20$: MOV (PC)+,R3 BNE PRINTC-O$CTRL+. 30$: MOV R3,-(SP) MOV #,R3 CALL CORWRT MOV (SP)+,R3 BCS S.IGN MOV R3,(R2) BR CORXIT .IF NE LS$PDP O.CSR: CMP R0,#160000 BLO S.ERR CLR R3 MOV R0,-(SP) CALL CORWRT MOV (SP)+,R0 BCS S.IGN .IF EQ LS$PC MOV R0,(R2) MOV R0,(R2) .IFF MOV R0,(R2) .ENDC MOV R0,-(SP) CALL CORREA MOV (SP)+,R0 BCS S.IGN .ADDR #RCSR+BIAS,R1 MOV #4,R2 10$: .Assume RCSR+2 EQ RBUF .Assume RBUF+2 EQ XCSR .Assume XCSR+2 EQ XBUF MOV R0,(R1)+ ADD #2,R0 SOB R2,10$ BR S.NOR .ENDC O.FF: BR 20$ NOP MOV #<100000!LF>,R3 BR 30$ 20$: MOV #FF,R3 30$: MOV R3,-(SP) MOV #,R3 CALL CORWRT MOV (SP)+,R3 BCS S.IGN MOV R3,(R2) CORXIT: CALL CORREA BCS S.IGN .BR S.NOR .SBTTL ADIOS - Common exit point for overlayed code S.NOR: CLR R2 S.IGN: CMP (PC)+,(PC)+ S.ERR: MOV #1,R2 JMP GETBK0+BIAS .SBTTL CORE - Sub/Coroutine for core reads/writes BAREA: .BYTE 17,11 .BLKW .BLKW .WORD 256. .WORD 0 CORWRT: .ADDR #BAREA+4,R1 .ADDR #1000+BIAS,R2 MOV R2,(R1) MOV #1,-(R1) TST -(R1) MOV R1,R0 EMT 375 BCS C2.ERR MOV R1,R0 DECB 1(R0) MOV R3,2(R0) EMT 375 BCS C.ERR BR C.NOR CORREA: MOV R1,R0 INCB 1(R0) EMT 375 BCS C2.ERR MOV R1,R0 DECB 1(R0) MOV #1,2(R0) EMT 375 BCS C.ERR INCB 1(R1) BR C.NOR C2.ERR: MOV #2,R2 BR C.NOR C.ERR: MOV #1,R2 C.NOR: RETURN .ASSUME <.-OVRBK0> LE OVRSIZ,MESSAGE=<;Overlay overflow> OVRSZ0==.-OVRBK0 OVRSP0==OVRSIZ-OVRSZ0 .SBTTL OVRBK1 -- overlay block number one . = OVRBK0+1000 OVRBK1: BIAS == O.ENDP: .ADDR #O$ENDP+BIAS,R1 MOV R0,@R1 BR S.1NOR O.BIT8: BR 20$ NOP MOV #^c177,R3 BR 30$ 20$: MOV #^c377,R3 30$: .ADDR #O$BIT8+BIAS,R1 BR MOV3A1 O.FORM0:BR 20$ NOP MOV (PC)+,R3 NOP BR 30$ 20$: MOV (PC)+,R3 BEQ BLK0-O$FORM+. 30$: .ADDR #O$FORM+BIAS,R1 BR MOV3A1 O.LC: CLR R3 BR 20$ MOV #40,R3 20$: .ADDR #O$LC+BIAS,R1 BR MOV3A1 O.GRAP: BR 20$ NOP MOV (PC)+,R3 BLT IGNORE-O$GRAP+. BR 30$ 20$: MOV (PC)+,R3 NOP 30$: .ADDR #O$GRAP+BIAS,R1 .IF NE LS$HANG BR MOV3A1 O.HANG: BR 20$ NOP MOV (PC)+,R3 NOP BR 30$ 20$: MOV (PC)+,R3 BR EXIT-O$HANG+. 30$: .ADDR #O$HANG+BIAS,R1 .ENDC MOV3A1: MOV R3,@R1 BR S.1NOR .SBTTL ADIOS - Common exit point for overlayed code S.1NOR: CLR R2 S.1IGN: CMP (PC)+,(PC)+ S.1ERR: MOV #1,R2 JMP GETBK0+BIAS .ASSUME <.-OVRBK1> LE OVRSIZ,MESSAGE=<;Overlay overflow> OVRSZ1==.-OVRBK1 OVRSP1==OVRSIZ-OVRSZ1 .IF NE LSBOTH .SBTTL FETCH/LOAD CODE .ENABL LSB FETCH:: MOV @R5,R5 MOV @#SYSPTR,R0 BIT #PRO$,CONFG2(R0) BEQ 30$ PCMSK =: 360/<<15.*>>/8.>+1> PCLOC =: 326+ BISB #PCMSK,PCLOC(R0) MOV LS$VTB-LSBASE(R5),R1 MOV #PC.VEC,R2 CALL VECMOV .ADDR #PCBASE,R1 .ADDR #REPL,R4 10$: MOV (R4)+,R0 BEQ 40$ MOV R5,R2 ADD (R4)+,R2 CALL DATMOV BR 10$ 30$: MOV LX$VTB-LSBASE(R5),R2 MOV R0,-(SP) MOV R2,-(SP) ADD #LOWMAP,R0 MOV #2,R4 CALL PROTECT MOV (SP)+,R2 MOV (SP)+,R0 MOV #LS$VCX,R1 CALL VECMOV LXMSK =: 360/<<15.*>>/8.>+1> LXLOC =: 326+ BICB #LXMSK,LXLOC(R0) MOV LX$VTB-LSBASE(R5),LS$VTB-LSBASE(R5) MOV LX$VTB+6-LSBASE(R5),LS$VTB+6-LSBASE(R5) 40$: CLC RETURN VECMOV: MOV #4,R0 DATMOV: 50$: MOV (R1)+,(R2)+ SOB R0,50$ RETURN PROTECT: ASR R2 MOV R2,R1 BIC #177407,R2 BIC #177770,R1 ASR R2 ASR R2 ASR R2 ADD R0,R2 60$: CLR R0 SEC 70$: RORB R0 DEC R1 BPL 70$ 80$: BISB R0,@R2 DEC R4 BMI 90$ RORB R0 BCC 80$ INC R2 BR 60$ 90$: RETURN REPL: .IRPC x,<1234567> .WORD PDPZ'x/2,PDPA'x-LSBASE .ENDR .WORD 1,LS$VTB-LSBASE .WORD 1,LS$VTB+6-LSBASE .WORD 0 .ASSUME <.-OVRBK1> LE 2000,MESSAGE=<;FETCH/LOAD code overflow> .PSECT PC$PDP .WORD PC.VEC .WORD PC.VEC+4 .ENDC .END .MCALL .MODULE .MODULE NC,VERSION=16,COMMENT=,AUDIT=NO ; COPYRIGHT (c) 1986 BY ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED ; ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE ; INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER ; COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY ; OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY ; TRANSFERRED. ; ; THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE ; AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT ; CORPORATION. ; ; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS ; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL. .SBTTL CONDITIONAL ASSEMBLY SUMMARY ;+ ;COND ; LOOP (0) controls loopback code ; 0 no loopback code ; 1 yes loopback code ; ; MMG$T std conditional = 1 ; TIM$T std conditional (no code effects) ; ERL$G std conditional (no code effects) ;- NI$CNA = 1 .INCLUDE "SRC:NI.MAC" .SBTTL .SBTTL ******************************************************** .SBTTL * DECNA Ethernet Controller Device Handler * .SBTTL ******************************************************** .SBTTL General Information .SBTTL General RT-11 Definitions .AUDIT .NI .AUDIT .NC .IIF NDF MMG$T MMG$T = 1 .IIF NDF LOOP LOOP = 0 QCOMP = 270 SYSVER = 276 CONFIG = 300 FBMON$ = 000001 CONFG2 = 370 PRO$ = 020000 SYSGEN = 372 BIT00 = 1 BIT01 = 2 BIT02 = 4 BIT03 = 10 BIT04 = 20 BIT05 = 40 BIT06 = 100 BIT07 = 200 BIT08 = 400 BIT09 = 1000 BIT10 = 2000 BIT11 = 4000 BIT12 = 10000 BIT13 = 20000 BIT14 = 40000 BIT15 = 100000 .SBTTL Macros .MACRO SRTCNA CNACMD,ERRADR MOV CNACMD,SCBCMD(R1) JSR PC,CMD BCS ERRADR .ENDM SRTCNA .MACRO GETBLK ERRADR,?A CALL GTBLK BCC A JMP ERRADR A: .ENDM GETBLK .MACRO PUTBLK CALL PTBLK .ENDM PUTBLK .MACRO SAVRG A .IRP REG, MOV REG,-(SP) .ENDR .ENDM SAVRG .MACRO RESRG A .IRP REG, MOV (SP)+,REG .ENDR .ENDM RESRG .MACRO MAP PAR1VL MOV PAR1VL,@#KISAR1 .ENDM MAP .MACRO PAGDEF NUM,ADDR PG'NUM' = ADDR PHYL'NUM' = *100 PHYH'NUM' = &77 .ENDM PAGDEF .SBTTL Description of DECNA/Host Interaction .SBTTL CNA Device Register and Data Structures CR.EM = BIT00 CR.ME = BIT01 CR.IE = BIT02 CR.CA = BIT03 CR.LP = BIT04 CR.OA = BIT05 CR.ED = BIT07 TOPAR1 = 137600 SYSBUS = 017766 ISCP = 017774 ST.CX = BIT15 ST.PR = BIT14 ST.CN = BIT13 ST.RN = BIT12 ST.CU = BIT11-BIT08 CU.IDL = 0 CU.SPN = 1*BIT08 CU.RDY = 2*BIT08 ST.RU = BIT07-BIT04 RU.IDL = 0 RU.SPN = 1*BIT04 RU.NRS = 2*BIT04 RU.RDY = 4*BIT04 CM.XC = BIT15 CM.RP = BIT14 CM.NC = BIT13 CM.NR = BIT12 CLFLGS=CM.XC+CM.RP+CM.NC+CM.NR CM.CU = ST.CU CU.NOP = 0 CU.SRT = 1*BIT08 CU.RES = 2*BIT08 CU.STP = 3*BIT08 CU.ABT = 4*BIT08 CM.RE = BIT07 CM.RU = ST.RU RU.NOP = 0 RU.SRT = 1*BIT04 RU.RES = 2*BIT04 RU.STP = 3*BIT04 RU.ABT = 4*BIT04 CBLSTS = 0 CBL.C = BIT15 CBL.B = BIT14 CBL.OK = BIT13 CBL.AB = BIT12 CBLCMD = 2 CBL.EL = BIT15 CBL.S = BIT14 CBL.I = BIT13 CBL.CM = BIT03-1 CM.NOP = 0 CM.SPA = 1 CM.CFG = 2 CM.SMA = 3 CM.XMT = 4 CM.TDR = 5 CM.DMP = 6 CM.DIA = 7 CBLLNK = 4 RLSADD = 14 CFGWA = 6 CFGWB = 10 CFGWC = 12 CFGWD = 14 CFGWE = 16 CFGWF = 20 CFGDFA = CFA.LM+4 CFGDFB = CFB.PL+CFB.AL+CFB.AN CFGDFC = CFC.GP CFGDFD = CFD.RT+1000 CFGDFE = CFE.TN CFA.LM = 10*BIT08 CFA.BY = BIT04-1 CFB.XL = BIT15 CFB.IL = BIT14 CFB.PL = 2*BIT12 CFB.AL = BIT11 CFB.AN = 6*BIT08 CFB.SB = BIT07 CFB.SA = BIT06 CFC.GP = ^d96*BIT08 CFC.EB = BIT07 CFC.EP = BIT07-BIT04 CFC.LP = BIT03-1 CFD.RT = ^D15*BIT12 CFD.TM = BIT11-1 CFE.DS = BIT15 CFE.CD = BIT15-BIT12 CFE.RS = BIT11 CFE.CR = BIT11-BIT08 CFE.PD = BIT07 CFE.BS = BIT06 CFE.CC = BIT05 CFE.NI = BIT04 CFE.TN = BIT03 CFE.MD = BIT02 CFE.BD = BIT01 CFE.P = BIT00 CFF.MN = BIT08-1 MLTCNT = 6 MLTADR = 10 XMTSTS = CBLSTS XMTCMD = CBLCMD XMTLNK = CBLLNK XMTBDP = 06 XMTCCB = 10 XM.CSL = BIT10 XM.CTS = BIT09 XM.OVR = BIT08 XM.DFR = BIT07 XM.HBT = BIT06 XM.ABT = BIT05 XM.AMT = BIT04-1 TBDBGN = 0 TBDCNT = TBDBGN TBD.EP = BIT15 TBD.LN = BIT14-1 TBDLNK = TBDBGN+2 TBDBUF = TBDBGN+4 TBDEXT = TBDBGN+6 TBDCCB = TBDBGN+10 PKTSTS = 0 PK.C = BIT15 PK.B = BIT14 PK.OK = BIT13 PK.CRC = BIT11 PK.FRM = BIT10 PK.RER = BIT09 PK.OVR = BIT08 PK.SHT = BIT07 PKTCMD = 2 PKT.EL = BIT15 PKT.S = BIT14 PKT.I = BIT13 PKTLNK = 4 PKTBUF = 6 PKTCCB = 10 RBDBGN = 0 RBDCNT = RBDBGN RBD.EP = BIT15 RBD.F = BIT14 RBD.LN = BIT14-1 RBDLNK = RBDBGN+2 RBDBUF = RBDBGN+4 RBDEXT = RBDBGN+6 RBDLEN = RBDBGN+10 RBD.EL = BIT15 RBD.MX = BIT14-1 RBDCCB = RBDBGN+12 SW.BRD = BIT00 SW.LOO = BIT01 SW.XLO = BIT02 SW.ON = BIT03 SW.HBT = BIT04 SW.PRO = BIT05 PRO.MD = BIT15 .SBTTL Extended memory definitions. BEGREL = 20000 ENDREL = 37776 PGSIZ = 20000 PAGDEF 1,134000 PAGDEF 2,134200 RCV1L = 020000 + 0 RCV1H = 056 RCV2L = 020000 + MAXMSG RCV2H = 056 RCV3L = 020000 + RCV3H = 056 RCV4L = 020000 + RCV4H = 056 RC9L = 020000 + RC9H = 056 RCVPR1 = 134200 RCVBF1 = 20000 RCVPR2 = 134227 RCVBF2 = 20052 RCVPR3 = 134257 RCVBF3 = 20024 RCVPR4 = 134306 RCVBF4 = 20076 RCPR9 = 134336 RCBF9 = 20050 PAGDEF 3,134400 RCV5L = 040000 + 0 RCV5H = 056 RCV6L = 040000 + MAXMSG RCV6H = 056 RCV7L = 040000 + RCV7H = 056 RCV8L = 040000 + RCV8H = 056 RC10L = 040000 + RC10H = 056 RCVPR5 = 134400 RCVBF5 = 20000 RCVPR6 = 134427 RCVBF6 = 20052 RCVPR7 = 134457 RCVBF7 = 20024 RCVPR8 = 134506 RCVBF8 = 20076 RCPR10 = 134536 RCBF10 = 20050 PAGDEF 4,134600 XMT1L = 060000 + 0 XMT1H = 056 XMTPAR = 134600 XMTBUF = 20000 PAGDEF 5,135000 PAGDEF 16,137600 ISCBSY = 0 ISCOFF = ISCBSY + 2 ISCBSE = ISCBSY + 4 SCBSTS = ISCBSY + 10 SCBCMD = SCBSTS + 2 SCBCBL = SCBSTS + 4 SCBPRA = SCBSTS + 6 SCBCRC = SCBSTS + 10 SCBALN = SCBSTS + 12 SCBRSC = SCBSTS + 14 SCBOVR = SCBSTS + 16 FRELST = SCBOVR + 2 CMDBLK = FRELST + 1024. MULCMD = CMDBLK + 256. MULLEN = MULCMD + 6 MULLST = MULLEN + 2 .SBTTL General Definitions (Size and identities) BLKNUM = 30. BLKSIZ = 10. DISINT = 70 ENBINT = 50 CLRINT = 110 CNAID = 000042 INTCTL = 173206 DELAY = 250. MINMSG = 64.-4 MAXMSG = 1518.-4 PROOVR = 14. MULMAX = 16. NIL = -1 PKNUM = 10. RBDNUM = 10. AMOUNT = 512.*2 LSTSIZ = AMOUNT/BLKSIZ CMDSIZ = 128. .SBTTL Installation code .DRINS NI .ENABL LSB DPMSIZ = 4000 DPMBAS = 134000 BR 10$ BR 50$ 10$: MOV @#SYSPTR,R1 MOV GETVEC(R1),R0 TST (R0)+ MOV #CNAID,-(SP) CALL @R0 MOV (SP)+,R0 BCS 50$ MOV MEMPTR(R1),R0 ADD R1,R0 MOV CORPTX(R0),R5 ADD R1,R5 20$: CMP (R5)+,#-1 BNE 20$ 30$: CMP (R5),#-1 BEQ 50$ TST (R5) BEQ 40$ ADD #GR.ESZ,R5 BR 30$ 40$: MOV #DPMSIZ,(R5)+ MOV #DPMBAS,(R5)+ MOV #,(R5)+ MOV (PC)+,(R5)+ .WORD NI$HND MOV #<^R$>,(R5) TST (PC)+ 50$: SEC RTS PC .DSABL LSB .Assume . LE 400,<;INSTALL area overflow> .SBTTL SET option parameter table .DRSET SHOW,CNAID,O.SHOW .SBTTL SET option routines .MCALL .TTYOU,.PRINT,.ADDR .ASSUME CTLMSK = 000040 .ENABL LSB O.SHOW: CALL GETINF BCS 30$ .ADDR #MSG,R0 .PRINT CLRB @RMA MOVB #CTLMSK,@CTL MOV RMD,R1 MOV #6.,R2 BR 20$ 10$: .TTYOU #'- 20$: MOV (R1),-(SP) MOVB (SP),R0 .REPT 4. ASR R0 .ENDR BIC #^C<017>,R0 .ADDR #HEX,R0,ADD MOVB (R0),R0 .TTYOU MOVB (SP)+,R0 BIC #^C<017>,R0 .ADDR #HEX,R0,ADD MOVB @R0,R0 .TTYOU DEC R2 BNE 10$ .ADDR #CRLF,R0 .PRINT 30$: RTS PC .DSABL LSB GETVEC = 436 GETINF: MOV R5,-(SP) MOV @#SYSPTR,R5 MOV R3,-(SP) MOV GETVEC(R5),R5 TST (R5)+ CALL @R5 BCS 40$ MOV (SP),RMD ADD #2,(SP) MOV (SP),RMA ADD #2,(SP) MOV (SP),CTL ADD #2,(SP) 40$: MOV (SP)+,MEM MOV (SP)+,R5 RTS PC .NLIST BEX RMD: .WORD 0 RMA: .WORD 0 CTL: .WORD 0 MEM: .WORD 0 MSG: .ASCII /Ethernet address = /<200> HEX: .ASCII /0123456789ABCDEF/ CRLF: .BYTE 0 .EVEN .LIST BEX .Assume . LE 1000,<;SET area overflow> .SBTTL I/O Initiation Section .SBTTL Some startup routines .PSECT NIDVR .MCALL .TTYOU,.PRINT .SBTTL INIT - Initialize during first entry to handler. .ENABL LSB DPMMSK = 027 INIT: MOV @#SYSPTR,R5 MOV #CNAID,-(SP) MOV GETVEC(R5),R5 CALL @R5 MOV (SP)+,CNAVEC BCS 2$ MOV #CNAID,-(SP) TST (R5)+ CALL @R5 MOV (SP)+,R0 BCS 2$ MOV R0,CN$RMD ADD R0,CN$RMA ADD R0,CN$CTL ADD R0,CN$MEM MOV #CNAID,-(SP) TST (R5)+ CALL @R5 MOV (SP)+,CNASLT BCS 2$ 1$: CLR TMPCTL CLR @CN$CTL CLR @CN$RMA BISB #CTLMSK,TMPCTL MOVB TMPCTL,@CN$CTL MOV CN$RMD,R1 .ADDR #NIPHAD,R2 .REPT 6 MOVB (R1),(R2)+ .ENDR MOVB #DPMMSK,@CN$MEM BISB #,TMPCTL MOVB TMPCTL,@CN$CTL TST (PC)+ 2$: SEC RTS PC .DSABL LSB .SBTTL ENABLE - Initialize during first open portal. .ENABL LSB ENABLE: JSR PC,SAVPAR JSR PC,CNAINI JSR PC,CNCONF BCS 32$ MOV #CMDBLK,R2 ADD R1,R2 CLR (R2)+ MOV #CBL.EL+CM.SPA,(R2)+ CLR (R2)+ .ADDR #NIPHAD,R0 MOV (R0)+,(R2)+ MOV (R0)+,(R2)+ MOV (R0)+,(R2)+ CALL SETIT 32$: BCS E.BAD 35$: JSR PC,LSTINI GETBLK E.BAD MOV R0,R5 MOV R0,BEGFD SUB #BEGREL,R0 MOV #PKNUM,R3 MOV R0,R4 MOV R0,SCBPRA(R1) 40$: CLR (R5)+ CLR (R5)+ DEC R3 BLE 50$ GETBLK E.BAD SUB #BEGREL,R0 MOV R0,(R5)+ MOV #NIL,(R5)+ CLR (R5) ADD #BEGREL,R0 MOV R0,R5 BR 40$ 50$: MOV R4,(R5)+ MOV #NIL,(R5)+ MOV #PKT.EL,PKTCMD(R0) MOV R0,ENDFD MOV #RBDNUM,R3 GETBLK E.BAD MOV R0,R4 BR 70$ 60$: GETBLK E.BAD 70$: CLR RBDCNT(R0) CLR RBDLNK(R0) JSR PC,GETPHY MOV #MAXMSG,RBDLEN(R0) MOV SCBPRA(R1),R5 ADD #BEGREL,R5 MOV PKTBUF(R5),RBDLNK(R0) MOV R0,PKTBUF(R5) SUB #BEGREL,PKTBUF(R5) SOB R3,60$ MOV R0,BEGRBD MOV R4,ENDRBD BIS #RBD.EL,RBDLEN(R4) MOV BEGRBD,RBDLNK(R4) SUB #BEGREL,RBDLNK(R4) SRTCNA #,E.BAD MOV #-1,XBUSY MOV #-1,RBUSY MOV CNASLT,R0 BIS #CLRINT,R0 MOV R0,@#INTCTL MOV CNASLT,R0 BIS #ENBINT,R0 MOV R0,@#INTCTL CLR SCBCBL(R1) TST (PC)+ E.BAD: SEC RTS PC .DSABL LSB .SBTTL LSTINI - Initialize list .ENABL LSB LSTINI: MOV R1,-(SP) MOV #FRELST,R2 ADD R1,R2 MOV R2,LSTHD MOV R2,R3 MOV #LSTSIZ,R1 10$: ADD #BLKSIZ,R2 MOV R2,(R3) MOV R2,R3 SOB R1,10$ CLR R3 MOV (SP)+,R1 RTS PC .DSABL LSB .SBTTL GETBLK - Get block from free list .ENABL LSB GTBLK: SAVRG MOV LSTHD,R2 TST @R2 BEQ 10$ MOV R2,R0 MOV (R2),LSTHD TST (PC)+ 10$: SEC RESRG RTS PC .DSABL LSB .SBTTL PUTBLK - Put block back on frelist PUTBLK: MOV LSTHD,(R0) MOV R0,LSTHD RTS PC .SBTTL GETPHY - Get physical address of buffer for RBD .ENABL LSB GETPHY: MOV R3,-(SP) NEG R3 ADD #10.,R3 ASL R3 ASL R3 .ADDR #BUFADR,R3,ADD MOV (R3)+,RBDBUF(R0) MOV (R3),RBDEXT(R0) MOV (SP)+,R3 RETURN .DSABL LSB .SBTTL DISABL - Cleanup after last close portal. DISABL: MOV CNASLT,R1 BIS #DISINT,R1 MOV R1,@#INTCTL MOV CNASLT,R1 BIS #CLRINT,R1 MOV R1,@#INTCTL BICB #CR.ED+CR.IE,TMPCTL BISB #CR.EM+CR.ME+CR.LP,TMPCTL MOVB TMPCTL,@CN$CTL RTS PC .SBTTL SETUP - Set hearing characteristics of controller .ENABL LSB SETUP: JSR PC,SAVPAR MAP #PG1 MOV #BEGREL,R1 MOV #CMDBLK,R2 ADD R1,R2 CLR (R2)+ MOV #CBL.EL+CM.CFG,(R2)+ CLR (R2)+ MOV #CFGDFA+6,(R2)+ MOV #CFGDFB,(R2)+ MOV #CFGDFC,(R2)+ MOV #CFGDFD,(R2)+ MOV #CFGDFE,(R2) BIC #CFE.TN,(R2) TST NIPMFG BNE 10$ BIC #CFE.P,(R2) BR 20$ 10$: BIS #CFE.P,(R2) 20$: CALL SETIT .ADDR #NIUAT,R0 MOV #MULLST,R2 MOV #MULLEN,R3 ADD R1,R2 ADD R1,R3 CLR (R3) MOV #8.,R4 30$: MOV (R0)+,-(SP) BIS (R0)+,(SP) BIS (R0)+,(SP)+ BEQ 40$ SUB #UA.ESZ,R0 .REPT 3 MOV (R0)+,(R2)+ .ENDR ADD #6.,(R3) 40$: DEC R4 BGT 30$ CALL SETMLT RTS PC .DSABL LSB .SBTTL SETMLT - Set/Reset multicast address .ENABL LSB SETMLT: MOV #MULCMD,R2 ADD R1,R2 CLR (R2)+ MOV #,(R2)+ CLR (R2)+ BISB #CR.EM+CR.ED+CR.ME+CR.IE,TMPCTL BICB #CR.LP,TMPCTL MOVB TMPCTL,@CN$CTL 5$: TST SCBCMD(R1) BNE 5$ 7$: MOV #MULCMD,SCBCBL(R1) MOV #CLFLGS+CU.SRT,SCBCMD(R1) BISB #CR.EM+CR.ED+CR.CA+CR.ME+CR.IE,TMPCTL MOVB TMPCTL,@CN$CTL BICB #CR.CA,TMPCTL MOVB TMPCTL,@CN$CTL MOV #DELAY*4,R0 10$: BIT #,SCBSTS(R1) BNE 20$ SOB R0,10$ 15$: 20$: BISB #CR.LP,TMPCTL MOVB TMPCTL,@CN$CTL RTS PC .DSABL LSB .SBTTL CNAINI - Initialize the DECNA controller .ENABL LSB CNAINI: MAP #PG16 MOV #BEGREL,R1 CLR SYSBUS(R1) MOV #PHYL1,ISCP(R1) MOVB #PHYH1,ISCP+2(R1) MAP #PG1 MOV #1,ISCBSY(R1) MOV #PHYL1,ISCBSE(R1) MOV #PHYH1,ISCBSE+2(R1) MOV #SCBSTS,ISCOFF(R1) MOV R1,R2 ADD #SCBSTS,R2 MOV #8.,R3 10$: CLR (R2)+ SOB R3,10$ BISB #CR.LP+CR.EM+CR.ED+CR.CA+CR.ME,TMPCTL MOVB TMPCTL,@CN$CTL BICB #CR.CA,TMPCTL MOVB TMPCTL,@CN$CTL RTS PC .DSABL LSB .SBTTL CNCONF - Configure the DECNA .ENABL LSB CNCONF: MOV #CMDBLK,R2 ADD R1,R2 CLR (R2)+ MOV #CBL.EL+CM.CFG,(R2)+ CLR (R2)+ MOV #CFGDFA+6,(R2)+ .if ne loop MOV #CFGDFB+CFB.XL,(R2)+ .iff MOV #CFGDFB,(R2)+ .endc MOV #CFGDFC,(R2)+ MOV #CFGDFD,(R2)+ MOV #CFGDFE,(R2) BIC #CFE.TN,(R2) SETIT: BISB #CR.EM+CR.ED+CR.ME+CR.IE,TMPCTL BICB #CR.LP,TMPCTL MOVB TMPCTL,@CN$CTL 5$: TST SCBCMD(R1) BNE 5$ 7$: MOV #CMDBLK,SCBCBL(R1) MOV #CLFLGS+CU.SRT,SCBCMD(R1) BISB #CR.EM+CR.ED+CR.CA+CR.ME+CR.IE,TMPCTL MOVB TMPCTL,@CN$CTL BICB #CR.CA,TMPCTL MOVB TMPCTL,@CN$CTL MOV #DELAY*4,R0 10$: BIT #,SCBSTS(R1) BNE 20$ SOB R0,10$ 20$: BISB #CR.LP,TMPCTL MOVB TMPCTL,@CN$CTL RTS PC .DSABL LSB .SBTTL Xmit/Recv - Transmit and Receive initiation. .ENABL LSB XMIT: TST XBUSY BPL 10$ MOV NIOCQE,R4 BEQ 10$ INC XBUSY JSR PC,SAVPAR MAP #PG1 MOV #BEGREL,R1 BEQ 10$ JSR PC,SRCCHK JSR PC,BLKMV GETBLK 20$ MOV R0,R3 MOV R0,R2 CLR (R3)+ MOV #CBL.EL+CBL.I+CM.XMT,(R3)+ CLR (R3)+ GETBLK 20$ MOV R0,(R3) SUB #BEGREL,(R3) MOV R0,R3 MOV Q$WCNT(R4),R0 DEC R0 DEC R0 ASL R0 MOV R0,(R3) BIS #TBD.EP,(R3)+ CLR (R3)+ MOV #XMT1L,(R3)+ MOV #XMT1H,(R3)+ MOV R2,SCBCBL(R1) SUB #BEGREL,SCBCBL(R1) SRTCNA #CU.SRT,20$ 10$: TST (PC)+ 20$: SEC RTS PC .DSABL LSB .ENABL LSB RECV: JSR PC,SAVPAR MAP #PG1 MOV #BEGREL,R1 CALL RCVINT RTS PC .DSABL LSB .SBTTL BLKMV - Move data between extended and user .ENABL LSB BLKMV: SAVRG MOV R4,R3 MOV @#SYSPTR,R4 MOV P1EXT(R4),(PC)+ $MVBLK: .WORD 0 SUB #2,$MVBLK MOV Q$WCNT(R3),R5 DEC R5 DEC R5 MOV Q$PAR(R3),R1 MOV Q$BUFF(R3),R2 add #4,r2 MOV #XMTPAR,R3 MOV #XMTBUF,R4 CALL @$MVBLK RESRG RTS PC .DSABL LSB .SBTTL SRCCHK - Source address check .ENABL LSB SRCCHK: JSR PC,SAVPAR SAVRG MAP Q$PAR(R4) MOV Q$BUFF(R4),R2 add #4,r2 ADD #EF.SRC,R2 MOV @R2,-(SP) BIS 2(R2),(SP) BIS 4(R2),(SP)+ BNE 10$ .ADDR #NIPHAD,R1 MOV (R1)+,(R2)+ MOV (R1)+,(R2)+ MOV (R1)+,(R2)+ 10$: RESRG RTS PC .DSABL LSB .SBTTL Interrupt entry .DRAST NI,5,NCABOR .ENABL LSB JSR PC,SAVPAR SAVRG MAP #PG1 MOV #BEGREL,R1 MOV SCBSTS(R1),-(SP) BIC #^C,(SP) SRTCNA (SP),10$ 10$: ASL (SP) BCC 20$ JSR PC,CNACXS 20$: ASL (SP) BCC 30$ JSR PC,CNAPRS 30$: ASL (SP) BCC 40$ JSR PC,CNACNS 40$: ASL (SP)+ BCC 50$ JSR PC,CNARNS 50$: RESRG RTS PC .DSABL LSB .SBTTL Abort entry point NCABOR: CALLR NIABRT .SBTTL CNACXS - Command done interrupt service routine .ENABL LSB CNACXS: TST NOQCHG BNE 40$ MOV SCBCBL(R1),R2 ADD #BEGREL,R2 TST (R2) BNE 20$ 10$: RTS PC 20$: MOV R2,R0 TST (R2)+ BPL 10$ MOV (R2)+,R3 BIC #^C,R3 TST (R2)+ CMP R3,#CM.XMT BNE 10$ CNAXMT: MOV #-1,XBUSY MOV NIOCQE,R4 MOV (R2),R2 ADD #BEGREL,R2 MOV (R0),-(SP) CALL PUTBLK MOV R2,R0 CALL PUTBLK MOV (SP)+,R2 BIT #CBL.OK,R2 BNE 30$ BIS #HDERR$,@-2(R4) MOV #RC.XMT+SC.WEC,-(SP) JSR PC,@$PTWRD 30$: MOV Q$LINK(R4),NIOCQE CALL NIFIN JMP XMIT 40$: RTS PC .DSABL LSB .SBTTL CNAPRS - Packet received interrupt service routine .ENABL LSB CNAPRS: TST NIQCHG BNE F.END RCVINT: INC RBUSY BNE F.END NEXT: MOV SCBPRA(R1),R3 BEQ F1.END ADD #BEGREL,R3 MOV R3,BEGFD TST (R3)+ BPL F1.END TST (R3)+ MOV (R3)+,SCBPRA(R1) MOV (R3)+,R2 ADD #BEGREL,R2 MOV BEGFD,R3 MOV R2,R5 CLR R0 10$: MOV (R2),R0 BMI 20$ br .-2 20$: MOV NIICQE,R4 BEQ C.END TST NIPMFG BNE 22$ JSR PC,GETPRO JSR PC,GETQEL BCS C.END 22$: BIC #^C,R0 30$: BIT #PK.OK,(R3) BEQ C.END JSR PC,MOVBLK BCC 40$ BIS #HDERR$,@-2(R4) MOV #RC.TRU,-(SP) JSR PC,@$PTWRD 40$: JSR PC,NIIDEQ C.END: JSR PC,MANAGE JMP NEXT F1.END: MOV #-1,RBUSY F.END: RTS PC .DSABL LSB .SBTTL CNACNS - Control Unit not ready service routine CNACNS: RTS PC .SBTTL CNARNS - Receive Unit not ready service routine .ENABL LSB CNARNS: SRTCNA #,10$ TST (PC)+ 10$: SEC RTS PC .DSABL LSB .SBTTL MANAGE - Update circular rings .ENABL LSB MANAGE: SAVRG MOV BEGFD,R0 BIS #PKT.EL,PKTCMD(R0) MOV R0,R3 MOV ENDFD,R0 BIC #PKT.EL,PKTCMD(R0) MOV R3,ENDFD MOV SCBPRA(R1),BEGFD ADD #BEGREL,BEGFD MOV BEGRBD,R0 BIS #RBD.EL,RBDLEN(R0) MOV R0,R3 MOV ENDRBD,R0 BIC #RBD.EL,RBDLEN(R0) MOV R3,ENDRBD MOV RBDLNK(R2),BEGRBD ADD #BEGREL,BEGRBD RESRG RTS PC .DSABL LSB .SBTTL GETPRO - Get protocol from user buffer GETPRO: SAVRG .ADDR #FAKEQ,R4 MOV R2,R0 JSR PC,INVALS MOV R1,Q$PAR(R4) MOV R2,Q$BUFF(R4) .ADDR #NCDST,R3 MOV #UA.ESZ,R1 10$: JSR PC,@$GTBYT MOVB (SP)+,(R3)+ SOB R1,10$ ADD #EF.TYP,R2 MOV R2,Q$BUFF(R4) MOV R3,R0 JSR PC,@$GTBYT MOVB (SP)+,(R3)+ JSR PC,@$GTBYT MOVB (SP)+,(R3)+ MOV (R0),R5 RESRG RTS PC .DSABL LSB .SBTTL INVALS - Input values for Par1 and buf .ENABL LSB INVALS: SAVRG MOV RBDBUF(R0),R3 CMP #RC9L,R3 BLO CHKG3 BNE 9$ MOV #RCPR9,R1 MOV #RCBF9,R2 BR 70$ 9$: CMP #RCV4L,R3 BNE 10$ MOV #RCVPR4,R1 MOV #RCVBF4,R2 BR 70$ 10$: CMP #RCV3L,R3 BNE 20$ MOV #RCVPR3,R1 MOV #RCVBF3,R2 BR 70$ 20$: CMP #RCV2L,R3 BNE 30$ MOV #RCVPR2,R1 MOV #RCVBF2,R2 BR 70$ 30$: CMP #RCV1L,R3 BNE CHKG3 MOV #RCVPR1,R1 MOV #RCVBF1,R2 BR 70$ CHKG3: CMP #RC10L,R3 BNE 39$ MOV #RCPR10,R1 MOV #RCBF10,R2 BR 70$ 39$: CMP #RCV8L,R3 BNE 40$ MOV #RCVPR8,R1 MOV #RCVBF8,R2 BR 70$ 40$: CMP #RCV7L,R3 BNE 50$ MOV #RCVPR7,R1 MOV #RCVBF7,R2 BR 70$ 50$: CMP #RCV6L,R3 BNE 60$ MOV #RCVPR6,R1 MOV #RCVBF6,R2 BR 70$ 60$: CMP #RCV5L,R3 BNE 70$ MOV #RCVPR5,R1 MOV #RCVBF5,R2 70$: RESRG RTS PC .DSABL LSB .SBTTL GETQEL - Get q-element matching protocol if any .ENABL LSB GETQEL: SAVRG CLR R3 .ADDR #NIUPT,R1 10$: CMP (R1)+,R5 BEQ 20$ INC R3 CMP #8.,R3 BGT 10$ BR 50$ 20$: CALL MATADR BCS 50$ .ADDR #NIUOT,R1 ASL R3 ADD R3,R1 MOVB @R3,R0 MOV NIICQE,R1 30$: CMPB Q$UNIT(R1),R0 BEQ 40$ MOV Q$LINK(R1),R1 BEQ 50$ BR 30$ 40$: MOV R1,R4 TST (PC)+ 50$: SEC RESRG RTS PC .DSABL LSB .SBTTL MATADR - Match Address .ENABL LSB MATADR: SAVRG .ADDR #NIPHAD,R0 .ADDR #NCDST,R1 MOV R1,R2 CMP (R0)+,(R1)+ BNE 10$ CMP (R0)+,(R1)+ BNE 10$ CMP (R0)+,(R1)+ BEQ 30$ 10$: MOV R2,R1 .ADDR #NIUAT,R0 MUL #UA.ESZ,R3 ADD R3,R0 CMP (R0)+,(R1)+ BNE 20$ CMP (R0)+,(R1)+ BNE 20$ CMP (R0)+,(R1)+ BNE 20$ 30$: TST (PC)+ 20$: SEC RESRG RTS PC .DSABL LSB .SBTTL MOVBLK - Move data between user and extended memory .ENABL LSB MOVBLK: SAVRG MOV @#SYSPTR,R3 MOV P1EXT(R3),(PC)+ $BLKMV: .WORD 0 SUB #2,$BLKMV MOV R0,R5 MOV Q$WCNT(R4),R0 DEC R0 DEC R0 ASL R0 CMP R5,R0 BLE 10$ MOV #-1,RCVFLG MOV R0,R5 10$: MOV Q$BUFF(R4),R0 TST (R0)+ MOV R0,Q$BUFF(R4) MOV R5,-(SP) JSR PC,@$PTWRD MOV R2,R0 MOV Q$PAR(R4),R3 MOV Q$BUFF(R4),R4 ASR R5 JSR PC,INVALS CALL @$BLKMV RESRG TST RCVFLG BPL 20$ CLR RCVFLG SEC 20$: RTS PC .DSABL LSB .SBTTL Support routines .SBTTL CMD - Start the controller to process commands .ENABL LSB CMD: BISB #CR.LP+CR.EM+CR.ED+CR.CA+CR.ME+CR.IE,TMPCTL MOVB TMPCTL,@CN$CTL .if ne loop BICB #CR.LP,TMPCTL .endc BICB #CR.CA,TMPCTL MOVB TMPCTL,@CN$CTL 10$: TST SCBCMD(R1) BNE 10$ TST (PC)+ 20$: SEC RTS PC .DSABL LSB .SBTTL Impure data area .PSECT NIDAT .DRVTB NI,0,NIINT,SLOTID=CNAID CN$RMD: .WORD 0 CN$RMA: .WORD 2 CN$CTL: .WORD 4 CN$MEM: .WORD 6 NINAME: .WORD NI$HND .WORD 0 NCDST: .BLKW 3 NCPROT: .BLKW 1 FREEND: .BLKW 1 BEGRBD: .BLKW 1 ENDRBD: .BLKW 1 ENDFD: .BLKW 1 BEGFD: .BLKW 1 CNAVEC: .BLKW 1 CNASLT: .BLKW 1 LSTHD: .BLKW 1 FAKEQ: .WORD 0 .WORD 0 F.BUF: .WORD 0 .WORD 0 .WORD 0 F.PAR: .WORD 0 RCVFLG: .WORD 0 TMPCTL: .WORD 0 XBUSY: .WORD -1 RBUSY: .WORD -1 BUFADR: .WORD RCV1L, RCV1H .WORD RCV2L, RCV2H .WORD RCV3L, RCV3H .WORD RCV4L, RCV4H .WORD RC9L, RC9H .WORD RCV5L, RCV5H .WORD RCV6L, RCV6H .WORD RCV7L, RCV7H .WORD RCV8L, RCV8H .WORD RC10L, RC10H CNALEN: .END .MCALL .MODULE .MODULE NI,VERSION=22,COMMENT=,AUDIT=NO ; COPYRIGHT (c) 1986 BY ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. ; ALL RIGHTS RESERVED. ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED ; ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE ; INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER ; COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY ; OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY ; TRANSFERRED. ; ; THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE ; AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT ; CORPORATION. ; ; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS ; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL. .SBTTL CONDITIONAL ASSEMBLY SUMMARY .SBTTL Class Handler Edit History .ENABL LC .SBTTL Class Handler Functional Description .SBTTL Class Handler Definitions .MCALL .DRDEF, .ADDR, .ASSUME .MCALL .INTEN, .BR .IIF NDF NI$CNA NI$CNA = 0 .IIF NE NI$CNA NI$CNA = 1 .IIF NDF NI$QNA NI$QNA = 0 .IIF NE NI$QNA NI$QNA = 1 .IIF NDF NI$UNA NI$UNA = 0 .IIF NE NI$UNA NI$UNA = 1 .ASSUME MMG$T NE 0,<;XM only> NI$$NI = .ASSUME NI$$NI NE 0,<;No hardware type specified> .ASSUME NI$$NI EQ 1,<;More than 1 hardware type specified> NI$PRI =: 5 .IF NE NI$CNA .DRDEF NI,61,,0,0,0 NI$HND = <^RNC > .ENDC .IF NE NI$QNA .IIF DF NQ$CSR NI$CSR = NQ$CSR .IIF DF NQ$VEC NI$VEC = NQ$VEC .DRDEF NI,61,,0,174440,120 NI$HND = <^RNQ > .ENDC .IF NE NI$UNA .IIF DF NU$CSR NI$CSR = NU$CSR .IIF DF NU$VEC NI$VEC = NU$VEC .DRDEF NI,61,,0,174510,120 NI$HND = <^RNU > .ENDC .DRPTR FETCH=*NO* .DREST CLASS=DVC.NI .DRSPF <200> .DRSPF <201> .DRSPF <202> .DRSPF <203> .DRSPF <204> .DRSPF <205> SYSPTR =: 54 QCOMP =: 270 SPUSR =: 272 CONFG2 =: 370 PROS$ = 020000 QBUS$ = 000100 MEMPTR =: 430 CORPTX =: 4 P1EXT =: 432 XDEALC =: -18. FINDGR =: -10. XALLOC =: -6 BLKMOV =: -2 SP.POR =: 200 SP.PM =: 201 SP.PT =: 202 SP.MA =: 203 SP.XMT =: 204 SP.RCV =: 205 RC.SUC =: 0 RC.UNK =: 1 RC.CHN =: 2 RC.RES =: 3 RC.TRU =: 4 RC.NON =: 5 RC.EXC =: 6 RC.IMP =: 7 RC.PRO =: 10 RC.ACT =: 11 RC.INC =: 12 RC.XMT =: 13 SC.WFL =: 1 SC.WEC =: 2 SC.WCC =: 3 SC.WSC =: 4 SC.WOC =: 5 SC.WRF =: 6 RC.RLN =: 14 RC.INV =: 15 RC.ABO =: 16 SC.RFL =: 1 SC.RBC =: 2 SC.RFE =: 3 JOBMK =: 370 UNITMK =: 007 KTGRAN =: 32. KISAR1 =: 172342 PSW =: 177776 .SBTTL Class Handler Data Structure Definitions GR.SIZ =: 0 GR.ADR =: 2 GR.STA =: 4 GR.PVT = 100000 GR.NRF = 000040 GR.NAM =: 6 GR.ESZ =: 10. UO.JOB =: 0 UO.OFG =: 1 UO.ESZ =: 2 UA.ADD =: 0 UA.ESZ =: 6 UP.TYP =: 0 UP.ESZ =: 2 EF.DST =: 0 EF.SRC =: 6 EF.TYP =: 14 EF.DAT =: 16 NIMFSZ =: 1514. P.RTBS = 003140 .SBTTL Psect Ordering .PSECT NIDVR .PSECT NIDAT .PSECT NIEND .PSECT SETOVR .DREND NI,PSECT=NIEND .SBTTL Handler Entry Point .DRBEG NI .IF NE NI$QNA!NI$UNA BR NIBEG NICSR: .WORD NI$CSR NIVEC: .WORD NI$VEC .Assume . LE NISTRT+1000,<;SET object not in block 1> .ENDC NIBEG: ASR (PC)+ .WORD 1 BCC 10$ MOV @#SYSPTR,R4 MOV P1EXT(R4),R4 .ADDR #NINAME,R5 CALL FINDGR(R4) MOV GR.ADR(R1),NIXADR CALL INIT BCS 10$ MOV SP,NICHFG 10$: MOV NICQE,R4 MOVB Q$FUNC(R4),R5 MOVB Q$UNIT(R4),R3 BIC #^C,R3 .ASSUME UO.ESZ EQ 2,<;change the ASL> ASL R3 .ADDR #NIUOT,R3,ADD CMPB R5,#SP.POR BNE 20$ .ASSUME Q$BLKN EQ 0 TST (R4) BNE 40$ 20$: .ASSUME UO.JOB EQ 0 .ASSUME UO.OFG EQ 1 TST (R3) BNE 30$ MOV #RC.UNK,-(SP) BR SPERR 30$: .ASSUME UO.JOB EQ 0 CMPB Q$UNIT(R4),(R3) BEQ 40$ MOV #RC.RES,-(SP) BR SPERR 40$: TSTB R5 BNE SPFUN BR NIERR .SBTTL SPFUN - Special Function Dispatcher .ENABL LSB SPFUN: TST NICHFG BEQ 30$ CLR -(SP) CALL @$PTWRD SUB #2,Q$BUFF(R4) .ADDR #SPFTAB,R2 10$: TST (R2) BEQ NIDONE CMPB R5,(R2) BEQ 20$ ADD #4,R2 BR 10$ 20$: MOV 2(R2),R2 ADD PC,R2 SPFDSP: MOVB Q$UNIT(R4),R5 BIC #^C,R5 JMP @R2 30$: MOV #RC.CHN,-(SP) SPERR: CALL @$PTWRD NIERR: BIS #HDERR$,@-(R4) NIDONE: .DRFIN NI SPFTAB: .WORD SP.POR, .SPPOR-SPFDSP .WORD SP.PM, .SPPM-SPFDSP .WORD SP.PT, .SPPT-SPFDSP .WORD SP.MA, .SPMA-SPFDSP .WORD SP.XMT, .SPXMT-SPFDSP .WORD SP.RCV, .SPRCV-SPFDSP .WORD 0 .DSABL LSB .SBTTL .SPPOR - Open/Close Portal .ENABL LSB .SPPOR: .ASSUME Q$BLKN EQ 0 TST (R4) BEQ SPCLO. SPOPP.: .ASSUME UO.JOB EQ 0 .ASSUME UO.OFG EQ 1 TST NIPMFG BNE 30$ TST (R3) BNE 20$ .ASSUME UO.JOB EQ 0 .ASSUME UO.OFG EQ 1 MOV #-1,(R3) .ASSUME UO.JOB EQ 0 MOVB Q$UNIT(R4),(R3) INC PORTCT BNE 10$ CALL ENABLE BCS 35$ 10$: MOV NICQE,R4 MOV @#KISAR1,-(SP) MOV Q$PAR(R4),@#KISAR1 MOV Q$BUFF(R4),R0 ADD #2,R0 MOV NIPHAD,(R0)+ MOV NIPHAD+2,(R0)+ MOV NIPHAD+4,(R0)+ MOV (SP)+,@#KISAR1 BR NIDONE 20$: MOV #RC.RES,-(SP) BR SPERR 30$: MOV #RC.EXC,-(SP) BR SPERR 35$: CLR NICHFG MOV #RC.CHN,-(SP) BR SPERR SPCLO.: MOVB Q$UNIT(R4),R0 MOV NIOCQE,R1 BEQ 50$ 40$: CMPB R0,Q$UNIT(R1) BEQ 100$ MOV Q$LINK(R1),R1 BNE 40$ 50$: MOV NIICQE,R1 BEQ 70$ 60$: CMPB R0,Q$UNIT(R1) BEQ 100$ MOV Q$LINK(R1),R1 BNE 60$ 70$: CLR NIPMFG 80$: .ASSUME UO.JOB EQ 0 .ASSUME UO.OFG EQ 1 CLR (R3) .ASSUME UP.ESZ EQ UO.ESZ CLR NIUPT-NIUOT(R3) MOV R5,R3 MUL #UA.ESZ,R3 .ADDR #NIUAT,R3,ADD CLR (R3)+ CLR (R3)+ CLR (R3)+ CALL SETUP DEC PORTCT BPL 90$ CALL DISABL 90$: BR NIDONE 100$: MOV #RC.ACT,-(SP) BR SPERR .DSABL LSB .SBTTL .SPPM - Enable/Disable Promiscuous Mode .ENABL LSB .SPPM: .ASSUME Q$BLKN EQ 0 TST (R4) BEQ SPDPM. SPEPM.: TST PORTCT BGT 10$ MOV #-1,NIPMFG MOVB Q$UNIT(R4),NIPMFG CALL SETUP BR NIDONE 10$: MOV #RC.EXC,-(SP) JMP SPERR SPDPM.: CLR NIPMFG CALL SETUP .ASSUME Q$BLKN EQ 0 MOV #1,(R4) .BR .SPPT .DSABL LSB .SBTTL .SPPT - Enable/Disable Protocol Type .ENABL LSB .SPPT: .ASSUME UP.ESZ EQ 2,<;Change the ASL> ASL R5 .ADDR #NIUPT,R5,ADD MOV @#KISAR1,-(SP) MOV Q$PAR(R4),@#KISAR1 MOV Q$BUFF(R4),R0 MOV 2(R0),PROTMP MOV (SP)+,@#KISAR1 .ASSUME Q$BLKN EQ 0 TST (R4) BEQ SPDPT. SPEPT.: TST (R5) BEQ 10$ MOV #RC.RES,-(SP) JMP SPERR 10$: .ADDR #NIUPT,R0 MOV #UP.TSZ,R1 20$: CMP PROTMP,(R0)+ BEQ 30$ DEC R1 BGT 20$ MOV PROTMP,(R5) JMP NIDONE 30$: MOV #RC.PRO,-(SP) JMP SPERR SPDPT.: CMP PROTMP,(R5) BNE 40$ CLR (R5) 40$: JMP NIDONE .DSABL LSB .SBTTL .SPMA - Enable/Disable Multicast Address .ENABL LSB .SPMA: MUL #UA.ESZ,R5 .ADDR #NIUAT,R5,ADD MOV @#KISAR1,-(SP) MOV Q$PAR(R4),@#KISAR1 MOV Q$BUFF(R4),R0 TST (R0)+ .ADDR #ADDTMP,R1 MOV (R0)+,(R1)+ MOV (R0)+,(R1)+ MOV (R0)+,(R1)+ MOV (SP)+,@#KISAR1 .ASSUME Q$BLKN EQ 0 TST (R4) BEQ SPDMA. SPEMA.: MOV (R5)+,-(SP) BIS (R5)+,(SP) BIS (R5)+,(SP)+ BEQ 20$ 15$: MOV #RC.RES,-(SP) JMP SPERR 20$: .ADDR #ADDTMP+UA.ESZ,R0 MOV -(R0),-(R5) MOV -(R0),-(R5) MOV -(R0),-(R5) BR 50$ SPDMA.: MOV R5,-(SP) .ADDR #ADDTMP,R0 MOV #3,R1 30$: CMP (R0)+,(R5)+ BNE 40$ DEC R1 BGT 30$ MOV (SP),R5 CLR (R5)+ CLR (R5)+ CLR (R5)+ 40$: TST (SP)+ 50$: CALL SETUP JMP NIDONE .DSABL LSB .SBTTL .SPXMT - Transmit Ethernet Frame MNBFSZ == 32. MXBFSZ == 759. .SPXMT: CMP Q$WCNT(R4),#MNBFSZ BGE 20$ 10$: MOV #,-(SP) JMP SPERR 20$: CMP Q$WCNT(R4),#MXBFSZ BGT 10$ MOV SP,NOQCHG JSR R5,ENQ NIOCQE: .WORD 0 NIOLQE: .WORD 0 CLR NOQCHG CALLR XMIT .SBTTL .SPRCV - Receive Ethernet Frame .SPRCV: MOV SP,NIQCHG JSR R5,ENQ NIICQE: .WORD 0 NIILQE: .WORD 0 CLR NIQCHG CALLR RECV .SBTTL SAV30 - Save Registers R0 to R3 SAV30: MOV R0,-(SP) MOV R1,-(SP) MOV R2,-(SP) MOV R3,-(SP) MOV 10(SP),-(SP) CALL @(SP)+ MOV (SP)+,R3 MOV (SP)+,R2 MOV (SP)+,R1 MOV (SP)+,R0 TST (SP)+ RETURN .SBTTL SAVPAR - Save PAR1 Mapping Context SAVPAR: MOV (SP),-(SP) MOV @#KISAR1,2(SP) CALL @(SP)+ MOV (SP)+,@#KISAR1 RETURN .SBTTL FIXPAR - Normalize Address/Par Information in Queue Element FIXPAR: CMP Q$BUFF(R4),#20000 BGE 10$ ADD #20000,Q$BUFF(R4) SUB #200,Q$PAR(R4) BR FIXPAR 10$: CMP Q$BUFF(R4),#20000+ BLO 20$ SUB #,Q$BUFF(R4) INC Q$PAR(R4) BR 10$ 20$: RETURN .SBTTL ENQ - Place Queue Element on Internal Queue ENQ: MOV Q$LINK(R4),NICQE BNE 5$ CLR NILQE 5$: CLR Q$LINK(R4) TST (R5) BNE 10$ MOV R4,(R5)+ MOV R4,(R5)+ BR 20$ 10$: TST (R5)+ MOV R4,-(SP) MOV (R5),R4 MOV (SP),Q$LINK(R4) MOV (SP)+,(R5)+ 20$: RTS R5 .SBTTL NIIDEQ - Remove Queue Element from Internal Receive Queue NIIDEQ: MOV R0,-(SP) MOV SP,NIQCHG .ADDR #NIICQE-Q$LINK,R0 10$: CMP Q$LINK(R0),R4 BEQ 20$ MOV Q$LINK(R0),R0 BNE 10$ HALT BR .-2 20$: MOV Q$LINK(R4),Q$LINK(R0) BNE 30$ MOV R0,NIILQE 30$: CLR Q$LINK(R4) CLR NIQCHG MOV (SP)+,R0 .BR NIFIN .SBTTL NIFIN - Internal Queue Element Completion NIFIN: BIS #340,@#PSW TST NICQE-4 BPL 10$ MOV (SP),-(SP) MOV @#PSW,2(SP) BIC #340,2(SP) .INTEN NI$PRI,PIC .FORK NIFBLK BIS #340,@#PSW 10$: MOV NICQE,-(SP) MOV NILQE,-(SP) MOV R4,NICQE MOV R4,NILQE CLR Q$LINK(R4) .ADDR #NICQE,R4 MOV @#SYSPTR,R5 CALL @QCOMP(R5) MOV (SP)+,NILQE MOV (SP)+,NICQE RETURN .SBTTL NIABRT - Class Handler Abort Code NIABRT: CALL SAV30 MOV SP,NIQCHG JSR R4,60$ .WORD NIICQE-70$-Q$LINK CLR NIQCHG MOV SP,NOQCHG JSR R4,60$ .WORD NIOCQE-70$-Q$LINK CLR NOQCHG .ADDR #NIUOT,R0 MOV #UO.TSZ,R1 10$: MOV (R0),R2 BEQ 15$ MOV R2,-(SP) BIC #^C,(SP) BIC #^C,R2 ASR R2 ASR R2 ASR R2 CMPB R2,R4 BNE 14$ CLR (R0) .ASSUME UP.ESZ EQ UO.ESZ CLR NIUPT-NIUOT(R0) MOV (SP),R3 MUL #UA.ESZ,R3 .ADDR #NIUAT,R3,ADD CLR (R3)+ CLR (R3)+ CLR (R3)+ 14$: TST (SP)+ 15$: TST (R0)+ DEC R1 BGT 10$ MOV PORTCT,-(SP) MOV #-1,PORTCT .ADDR #NIUOT,R0 MOV #UO.TSZ,R1 20$: TST (R0)+ BEQ 30$ INC PORTCT 30$: DEC R1 BGT 20$ MOV NIPMFG,R0 BEQ 40$ BIC #^C,R0 ASR R0 ASR R0 ASR R0 CMPB R0,R4 BNE 40$ CLR NIPMFG 40$: CMP PORTCT,(SP)+ BEQ 50$ TST PORTCT BPL 45$ CLR NIPMFG CALL DISABL BR 50$ 45$: CALL SETUP 50$: TST NICQE BNE 55$ RETURN 55$: .DRFIN NI SP.CCB = 4 SP.JOB = 6 60$: MOV R5,-(SP) MOV (R4)+,R5 MOV R4,-(SP) ADD PC,R5 70$: MOV R5,-(SP) 80$: MOV Q$LINK(R5),R4 BEQ 110$ TST SP.CCB(SP) BEQ 82$ CMP Q$CSW(R4),SP.CCB(SP) BNE 100$ BR 84$ 82$: MOVB Q$JNUM(R4),R0 BIC #^C,R0 ASR R0 ASR R0 ASR R0 CMP R0,SP.JOB(SP) BNE 100$ 84$: MOV Q$LINK(R4),Q$LINK(R5) CLR Q$LINK(R4) CLR Q$COMP(R4) TST NICQE BNE 90$ MOV R4,NICQE MOV R4,NILQE BR 80$ 90$: MOV NILQE,R0 MOV R4,Q$LINK(R0) MOV R4,NILQE BR 80$ 100$: MOV R4,R5 BR 80$ 110$: MOV (SP)+,R4 MOV R5,Q$LINK+2(R4) MOV (SP)+,R4 MOV (SP)+,R5 RTS R4 .SBTTL Class Handler Impure Data Area .PSECT NIDAT NIXADR: .BLKW NICHFG: .WORD 0 PORTCT: .WORD -1 NIPMFG: .WORD 0 NIAMFG: .WORD 0 NOQCHG: .WORD 0 NIQCHG: .WORD 0 PROTMP: .BLKW ADDTMP: .BLKW 3 NIUOT: .REPT 8. .WORD 0 .ENDR UO.TSZ = <.-NIUOT>/UO.ESZ NIUPT: .REPT 8. .WORD 0 .ENDR UP.TSZ = <.-NIUPT>/UP.ESZ NIPHAD: .BLKB 6 NIBROD: .WORD 177777,177777,177777 NIUAT: .REPT 8. .WORD 0,0,0 .ENDR UA.TSZ = <.-NIUAT>/UA.ESZ NIFBLK: .WORD 0,0,0,0 .MCALL .MODULE .MODULE NL,VERSION=05,COMMENT=,AUDIT=YES ; COPYRIGHT (c) 1986 BY ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. ; ALL RIGHTS RESERVED. ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED ; ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE ; INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER ; COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY ; OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY ; TRANSFERRED. ; ; THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE ; AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT ; CORPORATION. ; ; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS ; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL. .SBTTL CONDITIONAL ASSEMBLY SUMMARY .MCALL .DRDEF .ASSUME .DRDEF NL,25,0,0,0,0 .DRPTR .DREST CLASS=DVC.NL .DRBEG NL MOV NLCQE,R5 TST Q$WCNT(R5) BMI NLEXIT BIS #EOF$,@-(R5) BR NLEXIT RETURN: RTS PC NLINT:: .Assume .-2 EQ RETURN,MESSAGE=<;INT entry must be just after a RETURN> NLEXIT::.DRFIN NL .DREND NL .END .MCALL .MODULE .MODULE NQ,VERSION=15,COMMENT=,AUDIT=NO ; COPYRIGHT (c) 1986 BY ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. ; ALL RIGHTS RESERVED. ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED ; ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE ; INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER ; COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY ; OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY ; TRANSFERRED. ; ; THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE ; AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT ; CORPORATION. ; ; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS ; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL. NI$QNA = 1 .INCLUDE "SRC:NI.MAC" .SBTTL DEQNA Port Handler Edit History .ENABL LC .SBTTL DEQNA Port Handler Definitions .AUDIT .NI .AUDIT .NQ .MCALL .ADDR, .BR .MCALL .INTEN, .FORK .MCALL .TIMIO, .CTIMI RBCNT = 6. BUFSZ =: 1600. IATSZ =: <14.*UA.ESZ> SETSZ =: 200 EMEMSZ = <<+IATSZ+SETSZ>/2+>/KTGRAN .IIF LT RBCNT-2 .ERROR .IIF NDF NQ$WDT NQ$WDT = 0 C.JNUM =: 6 C.COMP =: 14 .MACRO BEQ. DST,?LOC BNE LOC JMP DST LOC: .ENDM .MACRO BNE. DST,?LOC BEQ LOC JMP DST LOC: .ENDM .SBTTL DEQNA Port Handler Device Definitions QN$SAR =: 0 QN$RAL =: 4 QN$RAH =: 6 QN$TAL =: 10 QN$TAH =: 12 QN$VEC =: 14 QN$CSR =: 16 CS.RI =: 100000 CS.CA =: 020000 CS.OK =: 010000 CS.SE =: 002000 CS.EL =: 001000 CS.ILD =: 000400 CS.XI =: 000200 CS.IE =: 000100 CS.RLI =: 000040 CS.XLI =: 000020 CS.BD =: 000010 CS.NXM =: 000004 CS.SR =: 000002 CS.REN =: 000001 MAXMLT =: 14. .SBTTL DEQNA Port Handler Data Structure Definitions BD.FLG =: 0 BD.ADH =: 2 BD.ADL =: 4 BD.LEN =: 6 BD.SW1 =: 10 BD.SW2 =: 12 BD.ESZ =: 14 FL.INI =: 100000 FL.USE =: 040000 AH.VLD =: 100000 AH.CHN =: 040000 AH.EOM =: 020000 AH.SET =: 010000 AH.TER =: 000200 AH.STA =: 000100 AH.HOM =: 000077 S1.LN =: 100000 S1.ERU =: 040000 S1.LOC =: 010000 S1.NOC =: 004000 S1.STE =: 002000 S1.ABO =: 001000 S1.FAI =: 000400 S1.CCM =: 000360 S1.ESE =: 020000 S1.DIS =: 010000 S1.RNT =: 004000 S1.RBL =: 003400 S1.FE =: 000004 S1.CRC =: 000002 S1.OV =: 000001 .SBTTL DEQNA Port Handler Installation Code .ENABL LSB .DRINS NI BR 10$ BR O.BAD 10$: MOV @#SYSPTR,R0 BIT #PROS$,CONFG2(R0) BNE O.BAD MOV INSCSR,R0 BIC #CS.SE,QN$CSR(R0) BIT #CS.OK,QN$CSR(R0) BEQ O.BAD MOV @#SYSPTR,R1 MOV MEMPTR(R1),R0 ADD R1,R0 MOV CORPTX(R0),R5 ADD R1,R5 20$: CMP (R5)+,#-1 BNE 20$ 30$: CMP (R5),#-1 BEQ O.BAD TST (R5) BEQ 40$ ADD #GR.ESZ,R5 BR 30$ 40$: MOV P1EXT(R1),R0 MOV (PC)+,R2 NIXSIZ: .WORD EMEMSZ CALL XALLOC(R0) BCS O.BAD MOV R2,(R5)+ MOV R1,(R5)+ MOV #GR.PVT,(R5)+ MOV (PC)+,(R5)+ .WORD NI$HND MOV #<^R$ >,(R5) BR O.GOOD .DSABL LSB .IIF GT .-400 .ERROR .SBTTL DEQNA Port Handler Set Code .DRSET CSR, 160000, O.CSR, OCT .DRSET VECTOR, 500, O.VEC, OCT .DRSET SHOW, NOP, O.SHOW O.CSR: CMP R0,R3 BLO O.BAD MOV R0,INSCSR MOV R0,DISCSR MOV R0,NICSR O.GOOD: TST (PC)+ O.BAD: SEC RETURN O.VEC: CMP R0,R3 BHIS O.BAD MOV R0,NISTRT MOV R0,NIVEC BR O.GOOD .MCALL .ADDR, .PRINT, .TTYOU .MCALL .TRPSE O.SHOW: .ADDR #TSAREA,R0 .ADDR #NQNXM,R1 .TRPSE R0,R1 TST @INSCSR NOP BCS O.BAD .ADDR #M.PADD,R0 .PRINT MOV INSCSR,R1 MOV #6.,R2 BR 20$ 10$: .TTYOU #'- 20$: MOV (R1)+,-(SP) MOVB (SP),R0 ASR R0 ASR R0 ASR R0 ASR R0 BIC #^C<17>,R0 .ADDR #HEX,R0,ADD .TTYOU (R0) MOVB (SP)+,R0 BIC #^C<17>,R0 .ADDR #HEX,R0,ADD .TTYOU (R0) DEC R2 BGT 10$ .ADDR #M.CRLF,R0 .PRINT RETURN TSAREA: .BLKW 2 NQNXM: BIS #1,2(SP) RTI M.PADD: .ASCII /Station address = /<200> M.CRLF: .BYTE 0 HEX: .ASCII /0123456789ABCDEF/ .IIF GT .-1000 .ERROR .SBTTL INIT - OnceOnly Initialization Code .PSECT NIDVR INIT: MOV NICSR,R0 BIS #CS.SR,QN$CSR(R0) BIC #CS.SR,QN$CSR(R0) MOV NIVEC,QN$VEC(R0) .ADDR #NIPHAD,R1 MOV #6.,R2 10$: MOV (R0)+,-(SP) MOVB (SP)+,(R1)+ DEC R2 BGT 10$ CLC RETURN .SBTTL RESRNG - Reset Receive Ring Structure .PSECT NIDVR RESRNG: CALL SAV30 .ADDR #RCVBDL,R1 .ADDR #BUFADR,R2 CLR RCVIDX MOV #RBCNT,R3 .ADDR #FQELEM,R4 MOV #20000,Q$BUFF(R4) MOV NIXADR,Q$PAR(R4) MOV R1,-(SP) BR 20$ 10$: ADD #BD.ESZ,R1 20$: MOV Q$BUFF(R4),(R2)+ MOV Q$PAR(R4),(R2)+ .ASSUME BD.FLG EQ 0 MOV #FL.INI,(R1) MOV R4,R5 ADD #Q$BUFF-Q$BLKN,R5 CALL @$MPPTR MOV (SP)+,BD.ADL(R1) MOV (SP)+,R0 ASH #-4,R0 BIC #^C,R0 BIS #AH.VLD,R0 MOV R0,BD.ADH(R1) MOV #-,BD.LEN(R1) MOV #S1.LN,BD.SW1(R1) MOV #S1.LN,BD.SW2(R1) ADD #BUFSZ,Q$BUFF(R4) CALL FIXPAR DEC R3 BGT 10$ MOV Q$BUFF(R4),(R2)+ MOV Q$PAR(R4),(R2)+ MOV R1,RCVINV BIC #AH.VLD,BD.ADH(R1) ADD #BD.ESZ,R1 MOV (SP)+,BD.ADL(R1) CLR BD.ADH(R1) .ASSUME BD.FLG EQ 0 MOV #FL.INI,(R1)+ .ASSUME BD.ADH EQ 2 BIS #,(R1) MOV NICSR,R0 CALL GETADR MOV R1,QN$RAL(R0) CLR QN$RAH(R0) BIS #,QN$CSR(R0) RETURN .SBTTL ENABLE - Enable Interrupts .PSECT NIDVR ENABLE: CALL RESRNG MOV #-1,XMITFG MOV #-1,RECVFG CALL SETUP CLC RETURN .SBTTL SETUP - Update Address Filtering Table .PSECT NIDVR SETUP: CALL SAV30 CALL SAVPAR MOV SETADR+2,@#KISAR1 MOV SETADR,R1 MOV #MAXMLT,R2 10$: .ADDR #NIPHAD,R0 MOV (R0)+,(R1)+ MOV (R0)+,(R1)+ MOV (R0)+,(R1)+ DEC R2 BGT 10$ ADD #,R1 MOV (R0)+,(R1)+ MOV (R0)+,(R1)+ MOV (R0)+,(R1)+ MOV #UA.TSZ,R2 CLR R3 20$: MOV (R0)+,-(SP) BIS (R0)+,(SP) BIS (R0)+,(SP)+ BEQ 30$ SUB #UA.ESZ,R0 MOV (R0)+,(R1)+ MOV (R0)+,(R1)+ MOV (R0)+,(R1)+ INC R3 CMP R3,#MAXMLT BLE 30$ SEC RETURN 30$: DEC R2 BGT 20$ MOV SETADR,R0 MOV R0,R1 ADD #IATSZ,R1 MOV #2.,R3 40$: MOV #7.,R2 50$: INC R1 MOVB (R0)+,(R1) MOVB (R0)+,10(R1) MOVB (R0)+,20(R1) MOVB (R0)+,30(R1) MOVB (R0)+,40(R1) MOVB (R0)+,50(R1) DEC R2 BGT 50$ ADD #71,R1 DEC R3 BGT 40$ .BR SNDSET .SBTTL SNDSET - Build and Send SETUP Packet SNDSET: MOV SP,SETUFG INC XMITFG BNE 20$ .ADDR #FQELEM,R4 MOV SETADR,Q$BUFF(R4) ADD #IATSZ,Q$BUFF(R4) MOV SETADR+2,Q$PAR(R4) CALL FIXPAR MOV #SETSZ,R5 TST NIPMFG BEQ 10$ BIS #2,R5 10$: ASR R5 MOV R5,Q$WCNT(R4) CALLR XMTCOM 20$: RETURN .SBTTL DISABL - Disable Interrupts .PSECT NIDVR DISABL: CALL SAV30 MOV NICSR,R0 BIC #,QN$CSR(R0) .IF NE TIM$IT .IF NE NQ$WDT CALL CTIMER .ENDC .ENDC RETURN .SBTTL NQABRT - Port Handler Abort Code .PSECT NIDVR NQABRT: .IF NE TIM$IT .IF NE NQ$WDT MOV R5,-(SP) MOV NIOCQE,R5 BEQ 10$ MOVB Q$JNUM(R5),-(SP) BIC #^C,(SP) ASR (SP) ASR (SP) ASR (SP) CMPB R4,(SP)+ BNE 10$ CALL CTIMER 10$: MOV (SP)+,R5 .ENDC .ENDC CALLR NIABRT .SBTTL NIINT - Interrupt Entry Point .PSECT NIDVR .DRAST NI,NI$PRI,NQABRT MOV NICSR,R5 MOV QN$CSR(R5),R4 MOV R4,QN$CSR(R5) BIT #CS.RI,R4 BEQ 10$ CALL NQIINT 10$: BIT #CS.XI,R4 BEQ 20$ CALL NQOINT 20$: RETURN .SBTTL NQIINT - Routine to Process Receive Interrupts .PSECT NIDVR .ENABL LSB NQIINT: TST NIQCHG BNE. 190$ RECV: INC RECVFG BNE. 190$ CALL SAV30 CALL SAVPAR MOV R4,-(SP) MOV R5,-(SP) 10$: CALL GETADR .ASSUME BD.FLG EQ 0 BIT #FL.USE,(R1) BEQ. 170$ BIT #S1.LN,BD.SW1(R1) BEQ 30$ BIT #S1.ERU,BD.SW1(R1) BEQ. 170$ 20$: CMPB BD.SW2(R1),BD.SW2+1(R1) BNE. 170$ 30$: BIT #,BD.SW1(R1) BNE. 140$ MOV NIICQE,R4 BEQ. 140$ TST NIPMFG BNE 120$ MOV RCVIDX,R2 ASL R2 ASL R2 .ADDR #BUFADR,R2,ADD MOV (R2)+,R0 MOV (R2)+,@#KISAR1 .ADDR #NIUPT,R3 MOV R3,-(SP) MOV #UP.TSZ,R2 40$: .ASSUME UO.ESZ EQ UP.ESZ TST NIUOT-NIUPT(R3) BEQ 45$ CMP EF.TYP(R0),(R3) BEQ 50$ 45$: TST (R3)+ DEC R2 BGT 40$ TST (SP)+ BR 140$ 50$: MOV R3,R2 SUB (SP)+,R3 .ASSUME UP.ESZ EQ 2 ASR R3 .ASSUME UO.ESZ EQ UP.ESZ ADD #NIUOT-NIUPT,R2 .ASSUME UO.JOB EQ 0 .ASSUME UO.OFG EQ 1 TST (R2) BEQ 140$ .ADDR #NQADDR,R4 MOV R4,-(SP) MOV R3,-(SP) .ADDR #NIPHAD,R3 MOV #*2,R5 60$: MOV (R3)+,(R4)+ DEC R5 BGT 60$ MOV (SP)+,R3 MUL #UA.ESZ,R3 .ADDR #NIUAT,R3,ADD MOV #,R5 70$: MOV (R3)+,(R4)+ DEC R5 BGT 70$ MOV (SP)+,R3 MOV #3,R4 80$: CMP EF.DST+4(R0),4(R3) BNE 90$ CMP EF.DST+2(R0),2(R3) BNE 90$ .ASSUME EF.DST EQ 0 CMP (R0),(R3) BEQ 100$ 90$: ADD #UA.ESZ,R3 DEC R4 BGT 80$ BR 140$ 100$: .ADDR #NIICQE-Q$LINK,R4 110$: MOV Q$LINK(R4),R4 BEQ 140$ CMPB (R2),Q$UNIT(R4) BNE 110$ 120$: MOV BD.SW1(R1),-(SP) BIC #^C<3400>,(SP) CLR R5 BISB BD.SW2(R1),R5 BIS (SP)+,R5 ADD #60.,R5 MOV R5,-(SP) ADD #2,Q$BUFF(R4) CALL @$PTWRD SUB #4,Q$BUFF(R4) INC R5 ASR R5 MOV Q$WCNT(R4),R2 SUB #2,R2 CMP R5,R2 BLE 130$ MOV #RC.TRU,-(SP) CALL @$PTWRD SUB #2,Q$BUFF(R4) BIS #HDERR$,@Q$CSW-Q$BLKN(R4) MOV R2,R5 130$: MOV RCVIDX,R2 ASL R2 ASL R2 .ADDR #BUFADR,R2,ADD MOV 2(R2),R1 MOV (R2),R2 MOV Q$PAR(R4),R3 MOV R4,-(SP) MOV Q$BUFF(R4),R4 ADD #4,R4 MOV @#SYSPTR,R0 MOV P1EXT(R0),R0 CALL BLKMOV(R0) MOV (SP)+,R4 CALL NIIDEQ 140$: CALL GETADR .ASSUME BD.FLG EQ 0 MOV #FL.INI,(R1) BIC #AH.VLD,BD.ADH(R1) MOV #S1.LN,BD.SW1(R1) MOV #S1.LN,BD.SW2(R1) MOV RCVINV,R3 BIS #AH.VLD,BD.ADH(R3) 150$: MOV R1,RCVINV MOV RCVIDX,R1 INC R1 CMP R1,#RBCNT BLT 160$ SUB #RBCNT,R1 160$: MOV R1,RCVIDX JMP 10$ 170$: MOV NICSR,R0 BIT #CS.RLI,QN$CSR(R0) BEQ 180$ CALL GETADR MOV R1,QN$RAL(R0) CLR QN$RAH(R0) 180$: MOV (SP)+,R5 MOV (SP)+,R4 MOV #-1,RECVFG 190$: RETURN .DSABL LSB .SBTTL GETADR - Get Buffer Descriptor Address GETADR: MOV RCVIDX,R1 MUL #BD.ESZ,R1 .ADDR #RCVBDL,R1,ADD RETURN .SBTTL NQOINT - Routine to Process Transmit Interrupts .PSECT NIDVR .ENABL LSB NQOINT: CALL SAV30 .ADDR #XMTBDL,R5 .IF NE TIM$IT .IF NE NQ$WDT CALL CTIMER .ENDC .ENDC MOV #-1,XMITFG BIT #AH.SET,BD.ADH(R5) BNE 70$ BIT #S1.ABO,BD.SW1(R5) BEQ 20$ 20$: MOV NIOCQE,R4 BEQ 70$ MOV Q$LINK(R4),NIOCQE CLR Q$LINK(R4) BIT #S1.ERU,BD.SW1(R5) BEQ 65$ 30$: BIT #S1.ABO,BD.SW1(R5) BEQ 40$ MOV #,-(SP) BR 60$ 40$: BIT #S1.NOC,BD.SW1(R5) BEQ 65$ MOV #,-(SP) BR 60$ 60$: BIS #HDERR$,@Q$CSW-Q$BLKN(R4) CALL @$PTWRD 65$: CALL NIFIN XMIT: 70$: CALL SAV30 CALL SAVPAR TST SETUFG BEQ 80$ CALLR SNDSET 80$: TST NOQCHG BNE 130$ MOV NIOCQE,R4 BEQ 130$ INC XMITFG BNE 130$ TST (PC)+ XMTCOM: SEC ROL (PC)+ LSETFG: .WORD 0 .ADDR #XMTBDL,R0 MOV R0,-(SP) .ASSUME BD.FLG EQ 0 MOV #FL.INI,(R0)+ TST LSETFG BNE 90$ ADD #4,Q$BUFF(R4) CALL FIXPAR MOV Q$PAR(R4),@#KISAR1 MOV Q$BUFF(R4),R2 ADD #EF.SRC,R2 MOV (R2),-(SP) BIS 2(R2),(SP) BIS 4(R2),(SP)+ BNE 90$ .ADDR #NIPHAD,R1 MOV (R1)+,(R2)+ MOV (R1)+,(R2)+ MOV (R1)+,(R2)+ 90$: MOV R4,R5 ADD #Q$BUFF-Q$BLKN,R5 CALL @$MPPTR SUB #4,Q$BUFF(R4) CALL FIXPAR MOV (SP)+,R2 MOV (SP)+,R1 ASH #-4,R1 BIC #^C,R1 BIS #,R1 TST LSETFG BEQ 100$ BIS #AH.SET,R1 100$: .ASSUME BD.ADH EQ 2 MOV R1,(R0)+ .ASSUME BD.ADL EQ 4 MOV R2,(R0)+ MOV Q$WCNT(R4),R1 TST LSETFG BNE 110$ SUB #2,R1 110$: NEG R1 .ASSUME BD.LEN EQ 6 MOV R1,(R0)+ .ASSUME BD.SW1 EQ 10 MOV #S1.LN,(R0)+ .ASSUME BD.SW2 EQ 12 CLR (R0)+ .ASSUME BD.FLG EQ 0 MOV #FL.INI,(R0)+ .ASSUME BD.ADH EQ 2 CLR (R0) TST LSETFG BEQ 120$ CLR SETUFG CLR LSETFG 120$: MOV (SP)+,R0 MOV NICSR,R1 .IF NE TIM$IT .IF NE NQ$WDT CALL TIMER .ENDC .ENDC MOV R0,QN$TAL(R1) CLR QN$TAH(R1) BIS #CS.REN,QN$CSR(R1) 130$: CLC RETURN .DSABL LSB .IF NE TIM$IT .IF NE NQ$WDT .SBTTL DEQNA Port Handler Watchdog routines TIMER: TST XMTWBK+C.COMP BNE 10$ MOV NIOCQE,R4 MOVB Q$JNUM(R4),R4 BIC #^C,R4 ASR R4 ASR R4 ASR R4 MOV R4,XMTWBK+C.JNUM .ADDR #XMTTMO,R4 MOV R4,XMTWBK+C.COMP MOV (SP),-(SP) MOV @#PSW,2(SP) BIC #340,2(SP) .INTEN NI$PRI,PIC .FORK NQFBLK .TIMIO XMTWBK,0,2*60. 10$: RETURN CTIMER: TST XMTWBK+C.COMP BEQ 10$ MOV (SP),-(SP) MOV @#PSW,2(SP) BIC #340,2(SP) .INTEN NI$PRI,PIC .FORK NQFBLK .CTIMI XMTWBK CLR XMTWBK+C.COMP 10$: RETURN XMTTMO: CALL SAV30 MOV R4,-(SP) MOV R5,-(SP) CALL INIT CALL ENABLE CALL XMIT MOV (SP)+,R5 MOV (SP)+,R4 RETURN .ENDC .ENDC .SBTTL Port Handler Impure Data Area .PSECT NIDAT NINAME: .WORD NI$HND .RAD50 /$ / RCVIDX: .BLKW RCVINV: .BLKW RCVBDL: .BLKB *BD.ESZ BUFADR: .BLKW SETADR: .BLKW 2 SETUFG: .WORD 0 RECVFG: .WORD -1 XMITFG: .WORD -1 NQECFG: .WORD 0 XMTBDL: .BLKB BD.ESZ*2 FQELEM: .BLKW 6 NQADDR: .BLKW 3*UA.ESZ .IF NE TIM$IT .IF NE NQ$WDT NQFBLK: .WORD 0,0,0,0 XMTWBK: .WORD 0,0,0 .WORD 0 .WORD 177000+NI$COD .WORD -1 .WORD 0 .ENDC .ENDC .END .MCALL .MODULE .MODULE NU,VERSION=05,COMMENT=,AUDIT=NO ; COPYRIGHT (c) 1986 BY ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. ; ALL RIGHTS RESERVED. ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED ; ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE ; INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER ; COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY ; OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY ; TRANSFERRED. ; ; THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE ; AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT ; CORPORATION. ; ; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS ; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL. .SBTTL CONDITIONAL ASSEMBLY SUMMARY NI$UNA = 1 .INCLUDE "SRC:NI.MAC" .SBTTL DEUNA Port Handler Edit History .SBTTL DEUNA Port Handler Definitions .AUDIT .NI .AUDIT .NU .MCALL .ADDR, .ASSUME, .BR .MCALL .WAIT, .READC .IIF NDF RBUFCT RBUFCT = 6. RBUFSZ =: 1600. XBUFCT =: 1 XBUFSZ =: 1600. UDBBSZ =: <32.*2> EMEMSZ = <++UDBBSZ>/2 EMEMSZ = >/KTGRAN .ASSUME RBUFCT GE 1 .ASSUME XBUFCT EQ 1 .MACRO BEQ. DST,?LOC BNE LOC JMP DST LOC: .ENDM .MACRO BNE. DST,?LOC BEQ LOC JMP DST LOC: .ENDM BLOCK0 =: 0 BLOCK1 =: 1000 .SBTTL DEUNA Port Handler Device Definitions UN$CS0 =: 0 UN$CS1 =: 2 UN$CS2 =: 4 UN$CS3 =: 6 C0.SEI =: 100000 C0.CEI =: 040000 C0.RXI =: 020000 C0.TXI =: 010000 C0.DNI =: 004000 C0.BUI =: 002000 C0.FEI =: 001000 C0.SCI =: 000400 C0.IS =: 000200 C0.IE =: 000100 C0.RSE =: 000040 C0.CMK =: 000017 PC.NOP =: 00 PC.GP =: 01 PC.GC =: 02 PC.ST =: 03 PC.STA =: 04 PC.BOO =: 05 PC.PD =: 10 PC.HLT =: 16 PC.STO =: 17 C1.XOK =: 100000 C1.COK =: 040000 C1.EMK =: 037400 C1.TMO =: 000200 C1.DID =: 000160 C1.SMK =: 000017 PS.RES =: 00 PS.PL =: 01 PS.RDY =: 02 PS.RUN =: 03 PS.UH =: 05 PS.NH =: 06 PS.NUH =: 07 PS.PH =: 10 PS.SL =: 17 .SBTTL DEUNA Port Handler Data Structure Definitions PCB.F0 =: 0 PCB.F1 =: 1 PCB.F2 =: 2 PCB.F4 =: 4 PCB.F6 =: 6 PCB.SZ =: 10 PF.NOP =: 00 PF.LSM =: 01 PF.RDA =: 02 PF.RPA =: 04 PF.WPA =: 05 PF.RMA =: 06 PF.WMA =: 07 PF.RRF =: 10 PF.WRF =: 11 PF.RC =: 12 PF.RCC =: 13 PF.RM =: 14 PF.WM =: 15 PF.RS =: 16 PF.RSC =: 17 PF.DIM =: 20 PF.LIM =: 21 PF.RID =: 22 PF.WID =: 23 PF.RLA =: 24 PF.WLA =: 25 F2.PM =: 100000 F2.AM =: 040000 F2.DDC =: 020000 F2.TPE =: 010000 F2.ECT =: 004000 F2.DMM =: 001000 F2.ILM =: 000100 F2.DTC =: 000010 F2.LOP =: 000004 F2.HDM =: 000001 F2.ES =: 100000 F2.ME =: 040000 F2.BBL =: 020000 F2.CTE =: 010000 F2.TE =: 004000 F2.RRE =: 001000 F2.TRE =: 000400 F2.PAT =: 000200 F2.RMO =: 000100 F2.RMK =: 000077 TD.LEN =: 0 TD.ADL =: 2 TD.ADH =: 4 TD.STA =: 6 TD.ESZ =: 10 AH.OWN =: 100000 AH.ERS =: 040000 AH.MAT =: 020000 AH.MRT =: 010000 AH.ONE =: 004000 AH.DEF =: 002000 AH.STP =: 001000 AH.ENP =: 000400 AH.HOM =: 000003 ST.BLE =: 100000 ST.UTO =: 040000 ST.UF =: 020000 ST.LCO =: 010000 ST.LCA =: 004000 ST.RTY =: 002000 ST.TDR =: 001777 RD.LEN =: 0 RD.ADL =: 2 RD.ADH =: 4 RD.STA =: 6 RD.ESZ =: 10 AH.FE =: 020000 AH.OVF =: 010000 AH.CRC =: 004000 ST.NCH =: 020000 ST.OE =: 010000 ST.LMK =: 007777 .SBTTL DEUNA Port Handler Installation Code .ENABL LSB .DRINS NI BR 10$ 5$: SEC RETURN 10$: MOV R0,-(SP) .WAIT #0 MOV (SP)+,R0 BCC 5$ 20$: MOV #INSOVR/2,R3 JMP GETOVR .DSABL LSB .ASSUME . LE 400,<;INSTALL area overflow> .SBTTL DEUNA Port Handler Set Options .DRSET CSR, 160000, O.CSR, OCT .DRSET VECTOR, 500, O.VEC, OCT .DRSET SHOW, O.SHOW/2, GETOVR .SBTTL DEUNA Port Handler Set Code O.CSR: CMP R0,R3 BLO O.ERR MOV R0,INSCSR MOV R0,DISCSR MOV R0,NICSR BR O.NORM O.VEC: CMP R0,R3 BHIS O.ERR MOV R0,NISTRT MOV R0,NIVEC BR O.NORM .SBTTL DEUNA Port Handler Set/Install Code Overlay Handler .ENABL LSB GETBK1: MOV #O.EXIT/2,R3 SWAB R3 MOV #1,SEMTBK BR 5$ GETOVR: CMPB -(R3),-(R3) NOP .ASSUME . EQ GETOVR+4,<;NO entry out of place> CMPB (R3)+,(R3)+ SWAB R3 MOVB R3,SEMTBK 5$: HNDBLK =: .+2 ADD #.-.,SEMTBK .ADDR #BLOCK1,R5,PUSH MOV R5,SEMTBF MOV (SP)+,R5 JSR R0,10$ SEMTCH: .BYTE 17 SEMTFN: .BYTE 10 SEMTBK: .BLKW SEMTBF: .BLKW .WORD 256. .WORD 0 10$: .READC CODE=NOSET MOV (SP)+,R0 BCS O.ERR CLRB R3 SWAB R3 ASL R3 ADD SEMTBF,R3 CMP SEMTBK,#1 BNE 20$ ADD #,R3 20$: JMP @R3 .DSABL LSB O.NORM: TST (PC)+ O.ERR: SEC RETURN O.EXIT: ROR R2 RETURN .ASSUME . LE 1000,<;SET area overflow> .SBTTL INIT - OnceOnly Initialization code .PSECT NIDVR INIT: MOV NICSR,R0 .ADDR #PCB,R1 MOV R1,UN$CS2(R0) CLR UN$CS3(R0) .ASSUME UN$CS0 EQ 0 MOVB #PC.GP,@R0 CALL ISWAIT MOV #PF.RDA,PCB+PCB.F0 .ASSUME UN$CS0 EQ 0 MOVB #PC.GC,@R0 CALL ISWAIT MOV #PF.WPA,PCB+PCB.F0 .ASSUME UN$CS0 EQ 0 MOVB #PC.GC,@R0 CALL ISWAIT .ADDR #PCB+PCB.F2,R0 .ADDR #NIPHAD,R1 MOV #6.,R2 10$: MOVB (R0)+,(R1)+ SOB R2,10$ MOV NICSR,R0 MOV #PF.RS,PCB+PCB.F0 .ASSUME UN$CS0 EQ 0 MOVB #PC.GC,@R0 CALL ISWAIT CLR MAXMLT MOVB PCB+PCB.F4,MAXMLT TST (PC)+ 20$: SEC RETURN .SBTTL ENABLE - Enables Interrupts .PSECT NIDVR ENABLE: CALL RESRNG MOV #-1,XMITFG MOV #-1,RECVFG MOV NICSR,R0 .ASSUME UN$CS0 EQ 0 MOVB #PC.STA,@R0 CALL ISWAIT MOV UN$CS1(R0),-(SP) BIC #^C,(SP) CMP (SP)+,#PS.RUN BNE 10$ .ASSUME UN$CS0 EQ 0 MOVB #,@R0 TST (PC)+ 10$: SEC RETURN .SBTTL DISABL - Disable Interrupts .PSECT NIDVR DISABL: MOV NICSR,R0 .ASSUME UN$CS0 EQ 0 MOVB #PC.NOP,@R0 .ASSUME UN$CS0 EQ 0 MOVB #PC.STO,@R0 CALL ISWAIT RETURN .SBTTL RESRNG - Reset Ring Structures .ENABL LSB RESRNG: CALL SAV30 CALL SAVPAR MOV R4,-(SP) .ADDR #RCVBDL,R1 .ADDR #RBUFAD,R2 CLR RCVIDX MOV #RBUFCT,R3 .ADDR #FQELEM,R4 MOV #20000,Q$BUFF(R4) MOV NIXADR,Q$PAR(R4) 10$: MOV Q$BUFF(R4),(R2)+ MOV Q$PAR(R4),(R2)+ .ASSUME RD.LEN EQ 0 MOV #RBUFSZ,(R1) MOV R4,R5 ADD #Q$BUFF-Q$BLKN,R5 CALL @$MPPTR MOV (SP)+,RD.ADL(R1) MOV (SP)+,R0 ASH #-4,R0 BIC #^C,R0 BIS #AH.OWN,R0 MOV R0,RD.ADH(R1) CLR RD.STA(R1) ADD #RD.ESZ,R1 ADD #RBUFSZ,Q$BUFF(R4) CALL FIXPAR DEC R3 BGT 10$ MOV Q$BUFF(R4),(R2)+ MOV Q$PAR(R4),(R2)+ MOV R4,R5 ADD #Q$BUFF-Q$BLKN,R5 CALL @$MPPTR MOV (SP)+,TD.ADL(R1) MOV (SP)+,R0 ASH #-4,R0 BIC #^C,R0 MOV R0,TD.ADH(R1) ADD #XBUFSZ,Q$BUFF(R4) CALL FIXPAR MOV Q$BUFF(R4),(R2)+ MOV Q$PAR(R4),(R2)+ MOV R4,R5 ADD #Q$BUFF-Q$BLKN,R5 CALL @$MPPTR MOV (SP)+,(R2)+ MOV (SP)+,R0 ASH #-4,R0 BIC #<^C3>,R0 MOV R0,(R2)+ MOV UDBBAD+2,@#KISAR1 MOV UDBBAD,R0 .ADDR #XMTBDL,R1 MOV R1,(R0)+ MOV #*400,(R0)+ MOV #XBUFCT,(R0)+ .ADDR #RCVBDL,R1 MOV R1,(R0)+ MOV #*400,(R0)+ MOV #RBUFCT,(R0)+ MOV UDBADR,PCB+PCB.F2 MOV UDBADR+2,PCB+PCB.F4 MOV #PF.WRF,PCB+PCB.F0 MOV NICSR,R0 .ASSUME UN$CS0 EQ 0 MOVB #PC.GC,@R0 CALL ISWAIT MOV (SP)+,R4 RETURN .DSABL LSB .SBTTL SETUP - Update Address Filtering .PSECT NIDVR .ENABL LSB SETUP: CALL SAV30 CALL SAVPAR MOV UDBBAD+2,@#KISAR1 MOV UDBBAD,R1 .ADDR #NIBROD,R0 MOV #UA.TSZ+1,R2 CLR R3 10$: MOV (R0)+,-(SP) BIS (R0)+,(SP) BIS (R0)+,(SP)+ BEQ 20$ SUB #UA.ESZ,R0 MOV (R0)+,(R1)+ MOV (R0)+,(R1)+ MOV (R0)+,(R1)+ INC R3 CMPB R3,MAXMLT BGT 50$ 20$: DEC R2 BGT 10$ MOV UDBADR,PCB+PCB.F2 MOVB UDBADR+2,R5 SWAB R3 BIS R3,R5 MOV R5,PCB+PCB.F4 MOV #PF.WMA,PCB+PCB.F0 MOV NICSR,R0 .ASSUME UN$CS0 EQ 0 MOVB #PC.NOP,@R0 .ASSUME UN$CS0 EQ 0 MOVB #PC.GC,@R0 CALL ISWAIT CLR R5 TST NIPMFG BEQ 30$ BIS #F2.PM,R5 30$: TST NIAMFG BEQ 40$ BIS #F2.AM,R5 40$: BIS #,R5 MOV R5,PCB+PCB.F2 MOV #PF.WM,PCB+PCB.F0 .ASSUME UN$CS0 EQ 0 MOVB #PC.GC,@R0 CALL ISWAIT .ASSUME UN$CS0 EQ 0 MOVB #,@R0 .ASSUME UN$CS0 EQ 0 MOVB #,@R0 TST (PC)+ 50$: SEC RETURN .DSABL LSB .SBTTL ISWAIT - Wait for Command Completion ISWAIT: .ASSUME UN$CS0 EQ 0 .ASSUME C0.IS EQ 200 TSTB @R0 BPL ISWAIT MOVB UN$CS0+1(R0),UN$CS0+1(R0) RETURN .SBTTL NUABRT - Port Handler Abort Code .PSECT NIDVR NUABRT: CALLR NIABRT .SBTTL NIINT - Interrupt Entry Point .PSECT NIDVR .ENABL LSB .DRAST NI,NI$PRI,NUABRT MOV NICSR,R5 .ASSUME UN$CS0 EQ 0 MOV (R5),R4 MOVB UN$CS0+1(R5),UN$CS0+1(R5) BIT #C0.RXI,R4 BEQ 20$ CALL NUIINT 20$: BIT #C0.TXI,R4 BEQ 30$ CALL NUOINT 30$: BIT #C0.BUI,R4 BEQ 40$ .ASSUME UN$CS0 EQ 0 MOVB #,(R5) 40$: RETURN .DSABL LSB .SBTTL NUIINT - Routine to Process Receive Interrupts .PSECT NIDVR .ENABL LSB NUIINT: TST NIQCHG BNE. 160$ RECV: INC RECVFG BNE. 160$ CALL SAV30 CALL SAVPAR MOV R4,-(SP) MOV R5,-(SP) 10$: CALL GETADR BIT #AH.OWN,RD.ADH(R1) BNE. 150$ BIT #AH.ERS,RD.ADH(R1) BNE. 130$ MOV NIICQE,R4 BEQ. 130$ TST NIPMFG BNE 110$ MOV RCVIDX,R2 ASL R2 ASL R2 .ADDR #RBUFAD,R2,ADD MOV (R2)+,R0 MOV (R2)+,@#KISAR1 .ADDR #NIUPT,R3 MOV R3,-(SP) MOV #UP.TSZ,R2 20$: .ASSUME UO.ESZ EQ UP.ESZ TST NIUOT-NIUPT(R3) BEQ 30$ CMP EF.TYP(R0),(R3) BEQ 40$ 30$: TST (R3)+ DEC R2 BGT 20$ TST (SP)+ BR 130$ 40$: MOV R3,R2 SUB (SP)+,R3 .ASSUME UP.ESZ EQ 2 ASR R3 .ASSUME UO.ESZ EQ UP.ESZ ADD #NIUOT-NIUPT,R2 .ASSUME UO.JOB EQ 0 .ASSUME UO.OFG EQ 1 TST (R2) BEQ 130$ .ADDR #NUADDR,R4 MOV R4,-(SP) MOV R3,-(SP) .ADDR #NIPHAD,R3 MOV #*2,R5 50$: MOV (R3)+,(R4)+ DEC R5 BGT 50$ MOV (SP)+,R3 MUL #UA.ESZ,R3 .ADDR #NIUAT,R3,ADD MOV #,R5 60$: MOV (R3)+,(R4)+ DEC R5 BGT 60$ MOV (SP)+,R3 MOV #3,R4 70$: CMP EF.DST+4(R0),4(R3) BNE 80$ CMP EF.DST+2(R0),2(R3) BNE 80$ .ASSUME EF.DST EQ 0 CMP (R0),(R3) BEQ 90$ 80$: ADD #UA.ESZ,R3 DEC R4 BGT 70$ BR 130$ 90$: .ADDR #NIICQE-Q$LINK,R4 100$: MOV Q$LINK(R4),R4 BEQ 130$ CMPB (R2),Q$UNIT(R4) BNE 100$ 110$: MOV RD.STA(R1),R5 BIC #^C,R5 SUB #4,R5 MOV R5,-(SP) ADD #2,Q$BUFF(R4) CALL @$PTWRD SUB #4,Q$BUFF(R4) INC R5 ASR R5 MOV Q$WCNT(R4),R2 SUB #2,R2 CMP R5,R2 BLE 120$ MOV #RC.TRU,-(SP) CALL @$PTWRD SUB #2,Q$BUFF(R4) BIS #HDERR$,@Q$CSW(R4) MOV R2,R5 120$: MOV RCVIDX,R2 ASL R2 ASL R2 .ADDR #RBUFAD,R2,ADD MOV 2(R2),R1 MOV (R2),R2 MOV Q$PAR(R4),R3 MOV R4,-(SP) MOV Q$BUFF(R4),R4 ADD #4,R4 MOV @#SYSPTR,R0 MOV P1EXT(R0),R0 CALL BLKMOV(R0) MOV (SP)+,R4 CALL NIIDEQ 130$: CALL GETADR CLR RD.STA(R1) MOVB #,RD.ADH+1(R1) MOV RCVIDX,R1 INC R1 CMP R1,#RBUFCT BLT 140$ SUB #RBUFCT,R1 140$: MOV R1,RCVIDX JMP 10$ 150$: MOV (SP)+,R5 MOV (SP)+,R4 MOV #-1,RECVFG 160$: RETURN .DSABL LSB .SBTTL GETADR - Get Buffer Descriptor Address GETADR: MOV RCVIDX,R1 MUL #RD.ESZ,R1 .ADDR #RCVBDL,R1,ADD RETURN .SBTTL NUOINT - Routine to Process Transmit Interrupts .PSECT NIDVR .ENABL LSB NUOINT: CALL SAV30 CALL SAVPAR MOV R4,-(SP) MOV R5,-(SP) .ADDR #XMTBDL,R5 MOV #-1,XMITFG MOV NIOCQE,R4 BEQ 70$ MOV Q$LINK(R4),NIOCQE CLR Q$LINK(R4) BIT #AH.ERS,TD.ADH(R5) BEQ 40$ BIT #ST.LCA,TD.STA(R5) BEQ 10$ MOV #,-(SP) BR 30$ 10$: BIT #ST.RTY,TD.STA(R5) BEQ 20$ MOV #,-(SP) BR 30$ 20$: MOV #,-(SP) .BR 30$ 30$: BIS #HDERR$,@Q$CSW(R4) CALL @$PTWRD 40$: CALL NIFIN BR 50$ XMIT: CALL SAV30 CALL SAVPAR MOV R4,-(SP) MOV R5,-(SP) 50$: TST NOQCHG BNE 70$ MOV NIOCQE,R4 BEQ 70$ INC XMITFG BNE 70$ MOV Q$PAR(R4),@#KISAR1 MOV Q$BUFF(R4),R2 ADD #<4+EF.SRC>,R2 MOV (R2),-(SP) BIS 2(R2),(SP) BIS 4(R2),(SP)+ BNE 60$ .ADDR #NIPHAD,R1 MOV (R1)+,(R2)+ MOV (R1)+,(R2)+ MOV (R1)+,(R2)+ 60$: MOV Q$PAR(R4),R1 MOV Q$BUFF(R4),R2 ADD #4,R2 MOV Q$WCNT(R4),R5 SUB #2,R5 MOV R5,-(SP) MOV XBUFAD+2,R3 MOV XBUFAD,R4 MOV @#SYSPTR,R0 MOV P1EXT(R0),R0 CALL BLKMOV(R0) .ADDR #XMTBDL,R0 ASL (SP) .ASSUME TD.LEN EQ 0 MOV (SP)+,@R0 CLR TD.STA(R0) MOVB #</400>,TD.ADH+1(R0) MOVB #,@NICSR 70$: MOV (SP)+,R5 MOV (SP)+,R4 RETURN .DSABL LSB .SBTTL Port Handler Inpure Data Area .PSECT NIDAT NINAME: .WORD NI$HND .RAD50 /$ / PCB: .WORD PF.RDA .WORD 0,0,0 RBUFAD: .BLKW XBUFAD: .BLKW 2 UDBBAD: .BLKW 2 UDBADR: .BLKW 2 RCVBDL: .BLKB XMTBDL: .BLKB TD.ESZ RCVIDX: .BLKW RECVFG: .WORD -1 XMITFG: .WORD -1 FQELEM: .BLKW 6 NUADDR: .BLKW 3*UA.ESZ NUFBLK: .WORD 0,0,0,0 MAXMLT: .WORD 0 .SBTTL Installation code overlay .PSECT SETOVR OVRBK0 =: . .ENABL LSB INSOVR: MOV @#SYSPTR,R1 BIT #,CONFG2(R1) BNE I.ERR MOV +INSCSR,R0 .ASSUME UN$CS0 EQ 0 MOV #C0.RSE,@R0 .ASSUME UN$CS0 EQ 0 5$: BIT #C0.DNI,@R0 BEQ 5$ MOVB UN$CS0+1(R0),UN$CS0+1(R0) MOVB UN$CS1(R0),-(SP) BIC #^C,(SP) CMPB (SP)+,#PS.RDY BNE I.ERR ASL #100000 BCC 6$ .ASSUME UN$CS0 EQ 0 MOVB #PC.ST,@R0 BR 5$ 6$: MOV MEMPTR(R1),R0 ADD R1,R0 MOV CORPTX(R0),R0 ADD R1,R0 CLR -(SP) MOV #-1,-(SP) 10$: CMP (R0),#-1 BEQ 30$ TST (R0) BEQ 20$ CMP (R0),#EMEMSZ BLO 20$ MOV 2(R0),-(SP) ADD #EMEMSZ,(SP) CMP (SP)+,#10000 BHI 20$ CMP (R0),(SP) BHIS 20$ MOV R0,2(SP) MOV (R0),(SP) 20$: ADD #4,R0 BR 10$ 30$: TST (R0)+ MOV R0,R2 TST (SP)+ MOV (SP)+,R0 BEQ I.ERR 50$: CMP (R2),#-1 BEQ I.ERR TST (R2) BEQ 60$ ADD #GR.ESZ,R2 BR 50$ 60$: MOV #EMEMSZ,(R2)+ SUB #EMEMSZ,(R0)+ MOV (R0),(R2)+ ADD #EMEMSZ,(R0) MOV #GR.PVT,(R2)+ MOV #NI$HND,(R2)+ MOV #<^R$ >,(R2)+ I.NORM: TST (PC)+ I.ERR: SEC RETURN .DSABL LSB .ASSUME <.-OVRBK0> LE 1000,<;INSTALL overlay overflow> .SBTTL Set Code Overlay .PSECT SETOVR . = OVRBK0 + 1000 OVRBK1 =: . .MCALL .DSTAT, .LOOKU, .SPFUN .MCALL .TRPSE, .PRINT, .TTYOU .MCALL .CLOSE, .PURGE ..DSTA =: 342 ..LKUP =: 375 ..SPFN =: 375 .ENABL LSB O.SHOW: .ADDR #OVRBK1,R0 ADD R0,LKAREA+2 ADD R0,SPAREA+4 .ADDR #DBLK,R0 .ADDR #DSAREA+1,-(SP) EMT ..DSTA BCS 10$ TST DSAREA+4 BEQ 10$ CALL DEVTYP .PURGE #0 .ADDR #LKAREA,R0 EMT ..LKUP BCS S.ERR .ADDR #SPAREA,R0 EMT ..SPFN ROL -(SP) .ADDR #SPAREA,R0 CLR SPAREA+2 EMT ..SPFN .PURGE #0 ROR (SP)+ BCS S.ERR BR 20$ 10$: .ADDR #TSAREA,R0 .ADDR #NUNXM,R1 .TRPSE R0,R1 MOV +INSCSR,R0 TST @R0 NOP BCS S.ERR CALL DEVTYP .ADDR #SPCB,R1 MOV R1,UN$CS2(R0) CLR UN$CS3(R0) .ASSUME UN$CS0 EQ 0 MOVB #PC.GP,@R0 CALL SWAIT MOV #PF.RDA,SPCB+PCB.F0 .ASSUME UN$CS0 EQ 0 MOVB #PC.GC,@R0 CALL SWAIT 20$: .ADDR #M.PADD,R0 .PRINT .ADDR #SPCB+PCB.F2,R1 MOV #6.,R2 BR 40$ 30$: .TTYOU #'- 40$: MOVB (R1)+,-(SP) MOVB (SP),R0 ASR R0 ASR R0 ASR R0 ASR R0 BIC #^C<17>,R0 .ADDR #HEX,R0,ADD .TTYOU @R0 MOVB (SP)+,R0 BIC #^C<17>,R0 .ADDR #HEX,R0,ADD .TTYOU @R0 DEC R2 BGT 30$ .ADDR #M.CRLF,R0 .PRINT S.NORM: TST (PC)+ S.ERR: SEC ROL R2 JMP +GETBK1 .DSABL LSB DEVTYP: MOV R0,-(SP) MOV +INSCSR,R0 MOV UN$CS1(R0),R0 BIC #^C,R0 BNE 10$ .ADDR #M.DEUN,R0 BR 20$ 10$: .ADDR #M.DELU,R0 20$: .PRINT MOV (SP)+,R0 RETURN NUNXM: BIS #1,2(SP) RTI SWAIT: .ASSUME UN$CS0 EQ 0 .ASSUME C0.IS EQ 200 TSTB @R0 BPL SWAIT MOVB UN$CS0+1(R0),UN$CS0+1(R0) RETURN DBLK: .WORD NI$HND .WORD 0,0,0 DSAREA: .BLKW 4 LKAREA: .BYTE 0 .BYTE 1 .WORD DBLK-OVRBK1 .WORD 0 SPAREA: .BYTE 0 .BYTE 32 .WORD 1 .WORD SPCB-OVRBK1 .WORD 0 .BYTE 377,SP.POR .WORD 0 SPCB: .WORD PF.RDA .WORD 0,0,0 TSAREA: .BLKW 2 M.DEUN: .ASCII /DEUNA, /<200> M.DELU: .ASCII /DELUA, /<200> M.PADD: .ASCII /Station address = /<200> M.CRLF: .BYTE 0 HEX: .ASCII /0123456789ABCDEF/ .EVEN .ASSUME <.-OVRBK1> LE 1000,<;SET overlay overflow> .END .MCALL .MODULE .MODULE PC,VERSION=05,COMMENT=,AUDIT=YES ; COPYRIGHT (c) 1986 BY ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. ; ALL RIGHTS RESERVED. ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED ; ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE ; INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER ; COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY ; OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY ; TRANSFERRED. ; ; THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE ; AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT ; CORPORATION. ; ; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS ; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL. .SBTTL CONDITIONAL ASSEMBLY SUMMARY .SBTTL EDIT HISTORY .SBTTL MACROS AND DEFINITIONS .MCALL .DRDEF .IIF NDF PR11$X, PR11$X=0 .IIF NE PR11$X, PR11$X=1 .DRDEF PC,7,,0,177550,70 .DRPTR .DREST CLASS=DVC.UK PCB == PC$CSR+2 .IIF NDF PP$VEC, PP$VEC == PC$VEC+4 .IIF NDF PP$CSR, PP$CSR == PC$CSR+4 PPB = PP$CSR+2 PRGO = 1 PINT = 101 .SBTTL DRIVER ENTRY .DRBEG PC MOV PCCQE,R4 ASL Q$WCNT(R4) BCS PP BEQ PCDONE MOV #PC$CSR,R5 TST (R5)+ BPL PCGORD BIS #EOF$,@-(R4) BR PCFIN PP: .IF EQ PR11$X BIS #100,@#PP$CSR RTS PC .DRVTB PC,PC$VEC,PCINT .DRVTB ,PP$VEC,PPINT .DRAST PP,4,PCDONE MOV PCCQE,R4 MOV #PP$CSR,R5 TST (R5)+ BMI PPERR .IF EQ MMG$T ADD #Q$WCNT,R4 TST @R4 BEQ PCDONE INC @R4 MOVB @-(R4),@R5 INC @R4 .IFF TST Q$WCNT(R4) BEQ PCDONE INC Q$WCNT(R4) JSR PC,@$GTBYT MOVB (SP)+,@R5 .ENDC RTS PC .ENDC PPERR: BIS #HDERR$,@-(R4) BR PCFIN .DRAST PC,4,PCDONE MOV PCCQE,R4 .IF EQ MMG$T ADD #Q$WCNT,R4 .ENDC MOV #PC$CSR,R5 TST (R5)+ BMI PREOF .IF EQ MMG$T MOVB @R5,@-(R4) INC (R4)+ DEC @R4 .IFF MOVB @R5,-(SP) JSR PC,@$PTBYT DEC Q$WCNT(R4) .ENDC BEQ PCDONE PCGORD: BIS #PINT,-(R5) RTS PC PREOF: CLR -(R5) .FORK PCFBLK 1$: .IF EQ MMG$T CLRB @-(R4) INC (R4)+ DEC @R4 .IFF CLR -(SP) JSR PC,@$PTBYT DEC Q$WCNT(R4) .ENDC BNE 1$ PCDONE: CLR @#PC$CSR .IF EQ PR11$X CLR @#PP$CSR .ENDC CLR PCFBLK+2 PCFIN: .DRFIN PC PCFBLK: .WORD 0,0,0,0 .DREND PC .END .MCALL .MODULE .MODULE PD,VERSION=08,COMMENT=,AUDIT=YES ; COPYRIGHT (c) 1986 BY ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. ; ALL RIGHTS RESERVED. ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED ; ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE ; INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER ; COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY ; OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY ; TRANSFERRED. ; ; THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE ; AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT ; CORPORATION. ; ; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS ; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL. .SBTTL CONDITIONAL ASSEMBLY SUMMARY .SBTTL BOOTSTRAP ROUTINE DEFINITIONS .LIST MEB .MCALL .DRDEF .ADDR .ASSUME .DRDEF PD,36,FILST$,512.,0,0 .DRPTR .DREST CLASS=DVC.DK,MOD=DVM.DX .DSTATUS=:342 ROMS$T =:173000 ROM$ID =:ROMS$T+6 ROM$TP =:ROM$ID+2 ROM$DT =:ROM$TP+2 RD$NDP =:0 RD$NT =:RD$NDP+2 RD$ASC =:RD$NT+2 RD$IMP =:RD$ASC+2 RD$BST =:RD$IMP+2 RD$BSR =:RD$BST+2 RD$DID =:RD$BSR+2 RD$SIO =:RD$DID+2 RD$ABT =:RD$SIO+2 RD$PUP =:RD$ABT+2 RD$ISR =:RD$PUP+2 BT$IMP =:10000 DX$COD =:22 DD$COD =:34 P3$COD =:36 P5$COD =:37 .SBTTL INSTALLATION ROUTINE .ASECT . = 200 .ENABL LSB PDINST: BR O.BAD JSR R4,1$ DEVTBL: .WORD DEVEND-DEVTBL/2 DV$UNT: .BLKW DV$ASC: .BLKW DV$R50: .BLKW DV$IMS: .BLKW DV$DST: .BLKW DV$LOS: .BLKW DV$HIS: .BLKW DV$PAG: .BLKW DV$VEC: .BLKW DV$ISR: .BLKW DV$PS: .BLKW DV$PRI: .BLKW DEVEND: 1$: MOV @#B$DEVU,R0 MOV @#ROM$DT,R1 ADD #RD$ISR,R1 MOV @R1,.INTRP TST -(R1) MOV -(R1),.ABORT MOV -(R1),.STARI CALL @-(R1) MOV (SP)+,R4 BCS O.BAD .ADDR #DV$PRI,R2 SWAB @R2 ASR @R2 ASR @R2 ASR @R2 BIC @R2,PDPRMS CMP -(R2),-(R2) MOV -(R2),R1 TST -(R2) TST -(R2) BNE O.BAD MOV -(R2),54 BR INCONT .DSABL LSB .ASSUME . LE 400,<;INSTALL area overflow> .SBTTL SET OPTIONS .DRSET WRITE, 1, O.WP, NO O.WP: NOP CLR R3 N.WP: .ASSUME O.WP+4 EQ N.WP,<;NO option out of place> MOV R3,O.WPF CMP R1,#1 BHI O.BAD .ADDR #PDWPRO,R0 ADD R1,R0 MOVB (PC)+,(R0) O.WPF: .BLKW 1 .ADDR #DEVNAM,R0 .ADDR #DAREA+1,@SP EMT .DSTATUS BCS O.BAD MOV DAREA+4,R0 BEQ O.GOOD ADD #PDW1-PDLQE,R0 MOV #100000,@R0 ADD R1,R0 MOVB O.WPF,PDWPRO-PDW1(R0) O.GOOD: TST (PC)+ O.BAD: SEC RETURN DAREA: .BLKW 4 DEVNAM: .RAD50 /PD / .SBTTL INSTALLATION CODE (CONT.) .ENABL LSB INCONT: 2$: MOV -(R2),R0 .IF NE ERL$G MOVB R0,EL$COD+1 .ENDC CMPB R0,#DX$COD BNE 3$ ADD #P5$COD-DX$COD,R0 3$: CMPB R0,#DD$COD BNE 4$ ADD #P3$COD-DD$COD,R0 4$: MOV R0,56 MOV -(R2),R0 ASL R0 ADD R0,$INOFF ADD R0,$FKOFF .IF NE ERL$G ADD R0,$ELOFF .ENDC SUB R0,R4 MOV R4,10.(SP) SUB R0,6.(SP) .ADDR #RELOC,R2 SUB #<1000+RELOCE-RELOC>,R4 MOV #/2,R3 55$: MOV (R2)+,(R4)+ DEC R3 BNE 55$ MOV 52,R3 ADD #1000,R3 CLC ROR R3 MOV R4,R5 ADD R0,R5 CALL RELOC-RELOCE(R4) .ADDR #.DDL,R5 ADD R4,@R5 CLR @(R5)+ CLR (R5)+ MOV #.DDLEN-.DDLCP/2,R3 5$: ADD R4,(R5)+ DEC R3 BNE 5$ MOV R1,R2 BIC #^C<3>,R2 BIC R2,R1 6$: MOV R1,(R5)+ CMP (R5)+,(R5)+ CMP (R1)+,(R1)+ DEC R2 BPL 6$ BR O.GOOD RELOC: MOV (R5)+,(R4)+ DEC R3 BNE RELOC SUB R0,@SP RETURN RELOCE: .ASSUME . LE 1000,<;SET area overflow> .DSABL LSB .SBTTL START I/O ENTRY .ENABL LSB .DRBEG PD BR 5$ PDWPRO: .BYTE 0,0 .ASSUME . LE PDSTRT+1000,<;SET object not in block 1> 5$: MOV PDCQE,R4 TST Q$WCNT(R4) BPL 10$ ASL (PC)+ PDW1: .WORD .-. .ASSUME . LE PDSTRT+1000,<;SET object not in block 1> BCS 10$ MOVB Q$UNIT(R4),R4 BIC #<^C7>,R4 .ADDR #PDWPRO,R4,ADD TSTB (R4) BNE ERROR 10$: .ADDR #.DDL,R5 MOV PDCQE,.DDLQ CALL @(PC)+ .STARI: .WORD 0 .ASSUME . LE PDSTRT+1000,<;SET object not in block 1> ERROR: MOV PDCQE,R4 BIS #HDERR$,@-(R4) BR PDEXIT .SBTTL INTERRUPT ENTRY .ENABL LSB BR PDABRT PDINT:: BCS 1$ $INOFF = .+2 JSR R5,@$INPTR PDPRMS: .WORD 340 .ASSUME . LE PDSTRT+1000,<;SET object not in block 1> CLR FKFLG .ADDR #.DDL,R5 JMP @(PC)+ .INTRP: .WORD 0 1$: MOV R4,-(SP) MOV R5,-(SP) .ADDR #.DDL,R5 CALL @.INTRP MOV (SP)+,R5 MOV (SP)+,R4 RTI .DSABL LSB .SBTTL COMPLETION EXIT COMPLT: BCS ERROR .IF NE ERL$G CALL FORK MOV (PC)+,R4 EL$COD: .BYTE -1,0 .ASSUME . LE PDSTRT+1000,<;SET object not in block 1> CALL ERLOG .ENDC PDEXIT: .DRFIN PD PDABRT: .ADDR #.DDL,R5 CALL @(PC)+ .ABORT: .WORD 0 .ASSUME . LE PDSTRT+1000,<;SET object not in block 1> CLR PDFBLK+2 BR PDEXIT .SBTTL FORK ROUTINE FORK: TST (PC)+ FKFLG: .WORD 0 BNE 1$ MOV (SP)+,FKFLG $FKOFF = .+2 JSR R5,@$FKPTR .WORD PDFBLK-. MOV FKFLG,-(SP) 1$: RETURN PDFBLK: .BLKW 4 .SBTTL ERROR LOGGER ERLOG: .IF NE ERL$G MOV R5,-(SP) MOV PDCQE,R5 $ELOFF = .+2 CALL @$ELPTR MOV (SP)+,R5 .ENDC SYNCH: TIMOUT: XPGLNK: ERRPT: RETURN .SBTTL DEVICE DRIVER LIST .DDL: .WORD ENDCOD-IMPUR .DDLQ: .WORD 0 .DDLCP: .WORD COMPLT-IMPUR .DDLFR: .WORD FORK-IMPUR .DDLSY: .WORD SYNCH-IMPUR .DDLEL: .WORD ERLOG-IMPUR .DDLTM: .WORD TIMOUT-IMPUR .DDLXP: .WORD XPGLNK-IMPUR .DDLER: .WORD ERRPT-IMPUR .DDLOP: .WORD OPTLST-IMPUR .DDLEN: .ASSUME . LE PDSTRT+1000,<;SET object not in block 1> .DRVTB PD,0,PDINT .DRVTB ,0,PDINT .DRVTB ,0,PDINT .DRVTB ,0,PDINT OPTLST: .WORD 0 ENDCOD: .SBTTL BOOTSTRAP DRIVER .DRBOT PD,BOOT1,READ IMPUR == PDEND . = PDBOOT+40 BOOT1: JMP @#BOOT-PDBOOT . = PDBOOT+550 READ: MOV @#ROM$DT,R4 MOV #BT$IMP+2,R5 MOV @#B$DEVU,R3 CALL @RD$BSR(R4) BCS BIOERR RETURN BOOT: MOV #10000,SP MOV R0,-(SP) BIC #^C<7>,@SP MOV @SP,@#B$DEVU MOV #2,R0 MOV #<4*400>,R1 MOV #1000,R2 CALL READ MOV #READ-PDBOOT,@#B$READ MOV #B$DNAM,@#B$DEVN MOV (SP)+,@#B$DEVU JMP @#B$BOOT .DREND PD .END .MCALL .MODULE .MODULE RF,VERSION=06,COMMENT=,AUDIT=YES ; COPYRIGHT (c) 1986 BY ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. ; ALL RIGHTS RESERVED. ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED ; ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE ; INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER ; COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY ; OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY ; TRANSFERRED. ; ; THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE ; AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT ; CORPORATION. ; ; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS ; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL. .SBTTL CONDITIONAL ASSEMBLY SUMMARY .MCALL .DRDEF .ASSUME .GLOBL $RFNUM .IIF NDF $RFNUM, $RFNUM=1 .DRDEF RF,12,100012,2000*$RFNUM,177460,204 .DRPTR .DREST CLASS=DVC.DK RFCS = RF$CSR RFWC = RFCS+2 RFMA = RFCS+4 RFDA = RFCS+6 RFAE = RFCS+10 CMAINH = 400 RD = 105 WR = 103 RFIDEN = 5000 RFIDS = 5377 RFRCNT = 3400 RFNREG = 10 RFREGA = 177460 .SBTTL INSTALLATION CHECK .DRINS RF NOP MOV INSCSR,R0 TSTB -20(R0) BCS 1$ BPL 1$ MOV #-2,-6(R0) BCS 1$ CMP #-2,-6(R0) BNE 2$ 1$: TST (PC)+ 2$: SEC RTS PC .ASSUME . LE 400,<;INSTALL area overflow> .SBTTL DRIVER ENTRY POINT .DRBEG RF ENTRY: MOV #7,(PC)+ RFTRY: .WORD 0 AGAIN: JSR R0,RFCOMN ZERO: .WORD 0 .IF EQ MMG$T MOV (R5)+,-(R4) .IFF JSR PC,@$MPPTR MOV (SP)+,-(R4) MOV (SP)+,R3 BIT #1700,R3 BNE RFHER .ENDC MOV (R5)+,-(R4) MOV #WR,R5 TST @R4 BEQ RFEXIT BMI 1$ MOV #RD,R5 NEG @R4 1$: .IF NE MMG$T BIS R3,R5 .ENDC MOV R5,-(R4) RTS PC .DRAST RF,5,RFABORT MOV RFCQE,R5 TST @#RFCS BPL RFFILL .FORK RFFBLK .IF NE ERL$G BIT #6000,@#RFCS BNE RFHER BIT #2000,@#RFAE BNE RFHER MOV PC,R1 ADD #RFRBUF-.,R1 MOV R1,R2 MOV #RFNREG,R4 MOV #RFREGA,R3 RFRREG: MOV (R3)+,(R1)+ DEC R4 BNE RFRREG MOV #RFNREG,R3 ADD #RFRCNT,R3 MOVB RFTRY,R4 DEC R4 ADD #RFIDEN,R4 JSR PC,@$ELPTR .ENDC RFRETY: DEC RFTRY BGT AGAIN RFHER: MOV RFCQE,R5 BIS #HDERR$,@-(R5) .IF NE ERL$G BR RFEXIT RFHOME: .FORK RFFBLK MOV #RFIDS,R4 MOV RFCQE,R5 JSR PC,@$ELPTR .IFF RFHOME: .ENDC RFEXIT: .DRFIN RF RFABORT:MOV #400,@#RFCS CLR RFFBLK+2 BR RFEXIT RFFILL: JSR R0,RFCOMN .WORD CMAINH MOV 2(R5),R5 BPL RFHOME TSTB R5 BEQ RFHOME NEG R5 ADD R5,@R4 ADC 2(R4) BIS #177400,R5 MOV PC,-(R4) ADD #ZERO-.,@R4 MOV R5,-(R4) MOV #WR,-(R4) RTS PC POPHOM: MOV (SP)+,R0 BR RFHOME RFCOMN: MOV #RFAE,R4 BIT @R0,@R4 BNE POPHOM MOV #400,@#RFCS MOV RFCQE,R5 MOV (R5)+,-(SP) SWAB @SP MOV @SP,@R4 BIC #177740,@R4 BIS (R0)+,@R4 CLRB @SP MOV (SP)+,-(R4) TST (R5)+ RTS R0 RFFBLK: .WORD 0,0,0,0 .IF NE ERL$G RFRBUF: .BLKW RFNREG .ENDC .SBTTL BOOTSTRAP DRIVER .DRBOT RF,BOOT1,READ . = RFBOOT+40 BOOT1: JMP BOOT . = RFBOOT+120 READ: MOV #RFDA,R3 MOV R0,R5 SWAB R5 MOV R5,R4 CLRB R5 MOV R5,(R3)+ BIC #177740,R4 MOV R4,@R3 TST -(R3) MOV R2,-(R3) MOV R1,-(R3) NEG @R3 MOV #5,-(R3) 3$: TSTB @R3 BPL 3$ TST @R3 BMI 4$ CLC RETURN 4$: JMP BIOERR . = RFBOOT+614 BOOT: MOV #10000,SP MOV #2,R0 MOV #<4*400>,R1 MOV #1000,R2 MOV #READ-RFBOOT,@#B$READ MOV #B$DNAM,@#B$DEVN JSR PC,READ CLR @#B$DEVU JMP @#B$BOOT .DREND RF .END .MCALL .MODULE .MODULE RK,VERSION=10,COMMENT=,AUDIT=YES ; COPYRIGHT (c) 1986 BY ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. ; ALL RIGHTS RESERVED. ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED ; ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE ; INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER ; COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY ; OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY ; TRANSFERRED. ; ; THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE ; AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT ; CORPORATION. ; ; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS ; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL. .SBTTL CONDITIONAL ASSEMBLY SUMMARY .SBTTL MACROS AND DEFINITIONS .MCALL .DRDEF .ASSUME .DRDEF RK,0,FILST$,4800.,177400,220 .DRPTR .DREST CLASS=DVC.DK RKDS = RK$CSR RKER = RKDS+2 RKCS = RKDS+4 RKWC = RKDS+6 RKBA = RKDS+10 RKDA = RKDS+12 RKCNT = 8. RKNREG = 7 DSID = 160000 DSDPL = 10000 DSRK05 = 4000 DSDRU = 2000 DSSIN = 1000 DSSOK = 400 DSDRY = 200 DSREDY = 100 DSWPS = 40 DSSCOK = 20 DSSC = 17 ERDRE = 100000 EROVR = 40000 ERWLO = 20000 ERSKE = 10000 ERPGE = 4000 ERNXM = 2000 ERDLT = 1000 ERTE = 400 ERNXD = 200 ERNXC = 100 ERNXS = 40 ERCSE = 2 ERWCK = 1 CSERR = 100000 CSHE = 40000 CSSCP = 20000 CSINHB = 4000 CSFMT = 2000 CSSSE = 400 CSRDY = 200 CSIE = 100 CSBA67 = 60 CSBA16 = 20 CSFUN = 16 CSGO = 1 FNRST = 0*2 FNWRITE = 1*2 FNREAD = 2*2 FNWCHK = 3*2 FNSEEK = 4*2 FNRCHK = 5*2 FNDRST = 6*2 FNWLK = 7*2 DAUNIT = 160000 DACYL = 17740 DASUR = 20 DASC = 17 SYSPTR =: 54 CONFG2 =: 370 QBUS$ =: 000100 .SBTTL Installation Code .DRINS RK .SBTTL SET OPTIONS .DRSET CSR, 160000, O.CSR, OCT .DRSET VECTOR, 500, O.VEC, OCT .DRSET RETRY, 127., O.RTRY, NUM .IF NE ERL$G .DRSET SUCCES, -1, O.SUCC, NO .ENDC BTCSR = ++1000 O.CSR: CMP R0,R3 BLO O.BAD MOV R0,INSCSR MOV R0,DISCSR MOV PC,R1 ADD #BAREA-.+4,R1 MOV PC,R2 ADD #1000-.,R2 MOV R2,(R1) MOV #BTCSR/1000,-(R1) TST -(R1) MOV R0,R3 ADD #RKDA-RKDS,R3 MOV R1,R0 EMT 375 BCS O.BAD MOV R3,(R2) MOV R1,R0 INCB 1(R0) EMT 375 BCS O.BAD MOV R1,R0 DECB 1(R0) MOV #1,2(R0) EMT 375 BCS O.BAD MOV R3,RKCSR O.GOOD: TST (PC)+ O.BAD: SEC RTS PC O.VEC: CMP R0,R3 BHIS O.BAD BIT #3,R0 BNE O.BAD MOV R0,RKSTRT BR O.GOOD O.RTRY: CMP R0,R3 BHI O.BAD MOV R0,DRETRY BNE O.GOOD BR O.BAD .IF NE ERL$G O.SUCC: MOV #0,R3 MOV R3,SCSFLG BR O.GOOD .ENDC BAREA: .BYTE 17,10 .BLKW .BLKW .WORD 256. .WORD 0 .ASSUME . LE 1000,<;SET area overflow> .SBTTL DRIVER ENTRY .DRBEG RK MOV (PC)+,(PC)+ DRETRY: .WORD RKCNT .ASSUME . LE RKSTRT+1000,<;SET object not in block 1> RETRY: .WORD 0 MOV RKCQE,R5 MOV @R5,R2 MOV Q$UNIT-1(R5),R4 ASR R4 ASR R4 ASR R4 SWAB R4 BIC #^C,R4 BR 2$ 1$: ADD R2,R4 ASR R2 ASR R2 ADD R3,R2 2$: MOV R2,R3 BIC #^C<17>,R3 BIC R3,R2 BNE 1$ CMP #12.,R3 BGT 3$ ADD #4,R3 3$: ADD R3,R4 MOV R4,DISKAD AGAIN: MOV RKCQE,R5 MOV #CSIE!FNWRITE!CSGO,R3 MOV (PC)+,R4 RKCSR: .WORD RKDA .ASSUME . LE RKSTRT+1000,<;SET object not in block 1> MOV (PC)+,@R4 DISKAD: .WORD 0 CMP (R5)+,(R5)+ .IF EQ MMG$T MOV (R5)+,R1 CLR R2 .IFF CALL @$MPPTR MOV (SP)+,R1 MOV (SP)+,R2 MOV R2,R0 ASH #-4,R2 .ENDC MOV R1,-(R4) MOV (R5),-(SP) BPL 46$ NEG (SP) 46$: ADD (SP),R1 ADC R2 ADD (SP)+,R1 ADC R2 MOV #<^B11>,-(SP) MOV @#SYSPTR,R1 BIT #QBUS$,CONFG2(R1) BEQ 47$ CLR (SP) 47$: BIC (SP)+,R2 BNE HERROR MOV (R5)+,-(R4) BEQ 7$ BMI 5$ NEG @R4 MOV #CSIE!FNREAD!CSGO,R3 5$: .IF NE MMG$T BIS R0,R3 .ENDC MOV R3,-(R4) 6$: RTS PC 7$: MOV #CSIE!FNSEEK!CSGO,-(R4) BR 6$ .IF NE ERL$G SCSFLG: .WORD 0 .ASSUME . LE RKSTRT+1000,<;SET object not in block 1> .ENDC .SBTTL INTERRUPT ENTRY POINT .DRAST RK,5 MOV RKCSR,R5 ADD #RKER-RKDA,R5 MOV (R5)+,R4 TST RETRY BPL NORMAL TST @R5 BMI NORMAL BIT #CSSCP,@R5 BEQ RTSPC .FORK RKFBLK RKRETR: CLRB RETRY+1 BR AGAIN NORMAL: CMP @R5,#CSRDY!CSIE!FNSEEK BEQ RTSPC TST @R5 BPL DONE .FORK RKFBLK .IF NE ERL$G BIT #EROVR!ERWLO!ERNXM!ERNXD!ERNXC!ERNXS,R4 BNE RKERR MOV PC,R5 ADD #RKRBUF-.,R5 MOV R5,R2 MOV RKCSR,R3 ADD #RKDS-RKDA,R3 MOV #RKNREG,R4 RKRREG: MOV (R3)+,(R5)+ DEC R4 BNE RKRREG MOV DRETRY,R3 SWAB R3 ADD #RKNREG,R3 MOV RKCQE,R5 MOVB RETRY,R4 DEC R4 JSR PC,@$ELPTR MOV RKCSR,R5 ADD #RKER-RKDA,R5 MOV (R5)+,R4 .ENDC RKERR: MOV #FNRST!CSGO,@R5 3$: TSTB @R5 BPL 3$ DECB RETRY BEQ HERROR BIT #ERDRE!ERSKE,R4 BEQ RKRETR MOV DISKAD,@RKCSR BIS #100000,RETRY MOV #CSIE!FNDRST!CSGO,@R5 RTSPC: RTS PC HERROR: MOV RKCQE,R5 BIS #HDERR$,@-(R5) .IF NE ERL$G BR RKEXIT DONE: .FORK RKFBLK TST SCSFLG BNE RKEXIT MOV (PC)+,R4 .BYTE 377,RK$COD MOV RKCQE,R5 JSR PC,@$ELPTR .IFF DONE: .ENDC RKEXIT: CLR RETRY .DRFIN RK RKFBLK: .WORD 0,0,0,0 .IF NE ERL$G RKRBUF: .BLKW RKNREG .ENDC .SBTTL BOOTSTRAP DRIVER .DRBOT RK,BOOT1,READ . = RKBOOT+40 BOOT1: JMP @#BOOT-RKBOOT . = RKBOOT+210 READ: MOV #12.,R3 BR 2$ 1$: ADD #20,R3 2$: SUB #12.,R0 BPL 1$ ADD R3,R0 MOV BOTCSR,R3 BIC #^C,@R3 BIS R0,@R3 MOV R2,-(R3) MOV R1,-(R3) NEG @R3 MOV #FNREAD!CSGO,-(R3) 3$: TSTB @R3 BPL 3$ TST @R3 BMI BIOERR RTS PC . = RKBOOT+574 BOOT: MOV #10000,SP MOV @(PC)+,-(SP) BOTCSR: .WORD RKDA ROL @SP ROL @SP ROL @SP ROL @SP BIC #^C<7>,@SP MOV #2,R0 MOV #<4*400>,R1 MOV #1000,R2 JSR PC,READ MOV #READ-RKBOOT,@#B$READ MOV #B$DNAM,@#B$DEVN MOV (SP)+,@#B$DEVU JMP @#B$BOOT .DREND RK .END .MCALL .MODULE .MODULE SP,VERSION=10,COMMENT=,AUDIT=YES ; COPYRIGHT (c) 1984,1985,1986 BY ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. ; ALL RIGHTS RESERVED. ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED ; ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE ; INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER ; COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY ; OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY ; TRANSFERRED. ; ; THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE ; AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT ; CORPORATION. ; ; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS ; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL. .SBTTL CONDITIONAL ASSEMBLY SUMMARY .SBTTL CREDITS .SBTTL MACROS AND DEFINITIONS .ENABLE LC .NLIST BEX .MCALL .DRDEF, .ADDR, .ASSUME .MCALL .BR .IIF NDF SP$FLG SP$FLG = 0 .IIF NE SP$FLG SP$FLG=1 .IIF NDF SP$DEC SP$DEC = 0 .IIF NE SP$DEC SP$DEC=1 .DRDEF SP,55,WONLY$!,0,0,110 .DRPTR .DREST CLASS=DVC.LP .MACRO SFR MOV (SP)+,(PC)+ .WORD 0 .ENDM .MACRO RFS ROUTINE JMP @ROUTINE+2 .ENDM .SBTTL CONSTANT AND PARAMETER DEFINITION NEXT = 000010 OFF = 000020 ON = 000040 KILL = 000100 ACTIVE = 000200 BPOVER = 003400 SHOW = 004000 PRTSCR = 010000 DATIME = 020000 INTEN = 040000 ERROR = 100000 SYSPTR = 000054 P1EXT = 000432 SPSTAT = 000414 $DATE = 000262 YEAR$ = 000037 DAY$ = 001740 MONTH = 036000 CLO$SE = 000001 DELE$TE = 000002 LOOK$UP = 000003 ENT$ER = 000004 MASK.U = 177770 BPTINS = 000003 NOPINS = 000240 WIDOFF = 000006 .SBTTL SET OPTIONS .DRSET WAIT,ON,S.WAIT, .DRSET NEXT,NEXT,S.BIT .DRSET KILL,KILL,S.BIT .IF NE SP$FLG .DRSET FLAG,4,S.FLAG, .DRSET WIDE,WIDOFF,S.WIDE, .DRSET FORM0,-1,S.FRM0, .DRSET METSCH,-1,S.JIM, .DRSET ENDPAG,4,S.ENDP, .ENDC .DRSET DEBUG,BPTINS,S.DEBUG, .SBTTL SET CODE S.DEBUG:MOV R3,R0 BR 10$ MOV #NOPINS,R0 10$: MOV R0,DBGINS RTS PC S.WAIT: MOV #OFF,R3 S.BIT: MOV @#SYSPTR,R0 BISB R1,R3 BIS R3,SPSTAT(R0) CLR R3 RTS PC .IF NE SP$FLG S.FLAG: CMP R0,R3 BHI S.ERR BIC #MASK.U,R1 .ADDR #FLGCNT,R1,ADD MOVB R0,@R1 S.OK: TST (PC)+ S.ERR: SEC RETURN S.FRM0: CLR R3 NOP COM R3 BIC #MASK.U,R1 .ADDR #FRM0ST,R1,ADD MOVB R3,@R1 BR S.OK S.WIDE: CLR R3 NOP .ADDR #WIDTAB,R3,ADD .ADDR #WIDFIL,R0 MOV (R3)+,(R0)+ MOV (R3)+,(R0)+ MOV (R3)+,(R0)+ BR S.OK WIDTAB: .WORD 10.,9.,8.,6.,6.,5. S.JIM: CLR R3 NOP COM R3 MOV R3,JIM BR S.OK S.ENDP: CMP R0,R3 BHI S.ERR BIC #MASK.U,R1 .ADDR #ENDPTB,R1,ADD MOVB R0,(R1) BR S.OK .ENDC .ASSUME . LT 1000 .SBTTL DRIVER ENTRY .DRBEG SP BR SPGO DBGINS: NOP .Assume . LE SPSTRT+1000,MESSAGE=<;Set object not in block 1> RETURN .IF NE SP$FLG FLGCNT: .REPT 8. .BYTE 2 .ENDR .Assume . LE SPSTRT+1000,MESSAGE=<;Set object not in block 1> FRM0ST: .REPT 8. .BYTE 0 .ENDR .Assume . LE SPSTRT+1000,MESSAGE=<;Set object not in block 1> ENDPTB: .REPT 8. .BYTE 0 .ENDR .Assume . LE SPSTRT+1000,MESSAGE=<;Set object not in block 1> WIDFIL: .WORD 10. WIDDAT: .WORD 9. WIDTIM: .WORD 8. .Assume . LE SPSTRT+1000,MESSAGE=<;Set object not in block 1> JIM: .WORD 1. .Assume . LE SPSTRT+1000,MESSAGE=<;Set object not in block 1> .ENDC SPGO: CALL DBGINS SETPTR: MOV @#SYSPTR,R4 .IF NE MMG$T MOV P1EXT(R4),(PC)+ $P1EXT: .WORD 0 .ENDC ADD #SPSTAT,R4 MOV R4,SPCSR DETFUN: MOV SPCQE,R4 MOV @R4,SP$BNR MOV Q$FUNC(R4),SP$JAF .IF NE SP$FLG MOVB Q$FUNC(R4),R5 BEQ IOREQ .IFF .BR IOREQ .ENDC .SBTTL PROCESS SPECIAL FUNCTION REQUESTS .IF NE SP$FLG SPFUN: CMPB R5,#ENT$ER BNE 10$ CALL GETFIL MOVB Q$UNIT(R4),R0 BIC #MASK.U,R0 MOV R0,-(SP) .ADDR #FRM0ST,R0,ADD MOVB @R0,FRM0FLG MOV (SP),R0 .ADDR #ENDPTB,R0,ADD MOVB (R0),ENDPCT MOV @SPCSR,R0 BIT #BPOVER,R0 BEQ 5$ COM R0 BIC #^C,R0 SWAB R0 MOVB R0,BANFLG TST (SP)+ BR 8$ 5$: MOV (SP)+,R0 .ADDR #FLGCNT,R0,ADD MOVB @R0,BANFLG BEQ 100$ 8$: .ADDR #BANNER,R5 MOV R5,INTVEC BIS #INTEN!DATIME,@SPCSR RTS PC 10$: CMPB R5,#LOOK$UP BNE 20$ CALL GETFIL TST SP$FNR BEQ 100$ CLR SP$FNR JMP SPERR 20$: CMPB R5,#CLO$SE BNE 100$ TST SP$FNR BEQ 100$ CLR SP$FNR .ADDR #ENDPAG,R5 MOV R5,INTVEC BIS #INTEN,@SPCSR RTS PC 100$: BR SPEXIT .ENDC .SBTTL PROCESS I/O REQUESTS IOREQ: TST Q$WCNT(R4) BEQ SPEXIT BGT SPERR .IF NE SP$FLG .ADDR #IOINT,R5 MOV R5,INTVEC .ENDC CLR (PC)+ BLKSC: .WORD 0 BIS #INTEN,@SPCSR RTS PC .SBTTL SPOOLER FIXED OFFSETS .IF NE SP$FLG SP$DAT: .BLKB 10. .ASSUME SP$DAT EQ SPINT-42 SP$TIM: .BLKB 8. .ASSUME SP$TIM EQ SPINT-30 SP$FNR: .WORD 0,0,0 .ASSUME SP$FNR EQ SPINT-20 .ENDC SP$BNR: .WORD 0 .ASSUME SP$BNR EQ SPINT-12 SP$JAF: .WORD 0 .ASSUME SP$JAF EQ SPINT-10 SP$WCR: .WORD 0 .ASSUME SP$WCR EQ SPINT-6 SP$BPR: .WORD 0 .ASSUME SP$BPR EQ SPINT-4 .SBTTL INTERRUPT SERVICE ROUTINE .DRAST SP,4,SPEXIT CALL DBGINS MOV SPCQE,R4 TST @SPCSR BMI SPERR .IF NE SP$FLG JSR R3,SAVE30 JMP @INTVEC INTVEC: .WORD 0 .IFF .BR IOINT .ENDC .SBTTL POST INTERRUPT I/O PROCESSING IOINT: CLR SP$WCR ADD BLKSC,SP$BNR .IF NE MMG$T 1$: MOV Q$PAR(R4),10$ JSR R0,@$P1EXT .WORD 10$-. MOV @Q$BUFF(R4),R5 10$: .WORD 0 MOV R5,@SP$BPR .IFF 1$: MOV @Q$BUFF(R4),@SP$BPR .ENDC ADD #2,SP$BPR ADD #2,Q$BUFF(R4) .IF NE MMG$T CMP Q$BUFF(R4),#40000 BLO 2$ SUB #20000,Q$BUFF(R4) ADD #200,Q$PAR(R4) .ENDC 2$: INC SP$WCR INC Q$WCNT(R4) BEQ SPEXIT CMP SP$WCR,#256. BNE 1$ INC BLKSC RTS PC .SBTTL ENDPAG - Handles trailing form feeds .IF NE SP$FLG ENDPAG: CLR SP$WCR MOV (PC)+,R1 ENDPCT: .WORD 0 BEQ 20$ 10$: MOV #FF,R0 CALL CHROUT DEC R1 BGT 10$ BIT #1,SP$WCR BEQ 20$ CLR R0 CALL CHROUT 20$: ASR SP$WCR BR SPEXIT .ENDC .SBTTL ERROR AND NORMAL EXITS SPERR: BIS #HDERR$,@-(R4) SPEXIT: BIC #INTEN,@SPCSR BIC #ERROR,@(PC)+ SPCSR: .WORD 0 .DRFIN SP .SBTTL GET FILENAME SUBROUTINE .IF NE SP$FLG GETFIL: MOV R4,-(SP) MOV R3,-(SP) MOV Q$BUFF(R4),R5 .ADDR #SP$FNR,R3 .IF EQ MMG$T MOV (R5)+,(R3)+ MOV (R5)+,(R3)+ MOV (R5)+,(R3)+ .IFF MOV R2,-(SP) MOV Q$PAR(R4),20$ MOV #3,R2 10$: JSR R0,@$P1EXT .WORD 20$-. MOV (R5)+,R4 20$: .WORD 0 MOV R4,(R3)+ SOB R2,10$ MOV (SP)+,R2 .ENDC MOV (SP)+,R3 MOV (SP)+,R4 RETURN .ENDC .SBTTL SAVE REGISTERS 3-0 .IF NE SP$FLG SAVE30::MOV R2,-(SP) MOV R1,-(SP) MOV R0,-(SP) JSR PC,@R3 MOV (SP)+,R0 MOV (SP)+,R1 MOV (SP)+,R2 MOV (SP)+,R3 RTS PC .ENDC .SBTTL FLAG PAGE CHARACTER DATA .IF NE SP$FLG CR = 015 FF = 014 LF = 012 A.SPACE = 040 A.STAR = 052 A.DASH = 055 A.DOT = 056 A.0 = 060 A.COLON = 072 A.A = 101 A.Z = 132 BANFLG: .WORD 0 FRM0FLG: .WORD 0 BANNER: CLR SP$BNR CLR SP$WCR MOV #6,R1 .ADDR #SP$FNR,R4 .ADDR #ASCFIL,R5 CALL R50ASC MOV #3,R1 .ADDR #SP$FNR+4,R4 .ADDR #ASCEXT,R5 CALL R50ASC MOV @#SYSPTR,R1 MOV $DATE(R1),-(SP) MOV @SP,R5 BIC #^C,R5 .REPT 5 ASR R5 .ENDR .ADDR #SP$DAT,R4 CALL PUTNUM MOVB #'-,(R4)+ MOV @SP,R5 BIC #^C,R5 SWAB R5 SUB #4,R5 .ADDR #MOTAB,R5,ADD MOVB (R5)+,(R4)+ MOVB (R5)+,(R4)+ MOVB (R5)+,(R4)+ MOVB #'-,(R4)+ MOV (SP)+,R5 BIC #^C,R5 ADD #110,R5 CALL PUTNUM CLRB (R4)+ CALL FRM0FF TST BANFLG BEQ 50$ 10$: CALL RT.11 CALL CRLF MOV WIDFIL,R1 .ADDR #ASCFIL,R5 CALL BIGGY TST JIM BEQ 30$ MOV #30.,R1 20$: MOV #12,R0 CALL CHROUT DEC R1 BNE 20$ .ADDR #PRION,R5 CALL STROUT .ADDR #SP$DAT,R5 CLRB 9.(R5) CALL STROUT .ADDR #PRIAT,R5 CALL STROUT .ADDR #SP$TIM,R5 CLRB 8.(R5) CALL STROUT CALL CRLF CALL CRLF BR 40$ 30$: CALL CRLF MOV WIDDAT,R1 .ADDR #SP$DAT,R5 CALL BIGGY CALL CRLF MOV WIDTIM,R1 .ADDR #SP$TIM,R5 CALL BIGGY CALL CRLF 40$: CALL RT.11 MOV #FF,R0 CALL CHROUT DEC BANFLG BGT 10$ 50$: BIT #1,SP$WCR BEQ 100$ CLR R0 CALL CHROUT 100$: ASR SP$WCR JMP SPEXIT MOTAB: .ASCIZ "JAN" .ASCIZ "FEB" .ASCIZ "MAR" .ASCIZ "APR" .ASCIZ "MAY" .ASCIZ "JUN" .ASCIZ "JUL" .ASCIZ "AUG" .ASCIZ "SEP" .ASCIZ "OCT" .ASCIZ "NOV" .ASCIZ "DEC" ASCFIL: .ASCII "FILENA." ASCEXT: .ASCII "EXT" .EVEN .SBTTL SUBROUTINE TO PRINT BIG CHARACTERS BIGGY: SFR .ADDR #CHRADR,R2 MOV R1,(PC)+ NUMCHR: .WORD 0 MOV R5,(PC)+ BUFPTR: .WORD 0 10$: MOVB (R5)+,R0 .ADDR #A,R4 JSR R5,RANGE .WORD A.A, A.Z BCC 20$ .ADDR #ZERO,R4 JSR R5,RANGE .WORD A.0, A.COLON BCC 20$ .ADDR #DASH,R4 JSR R5,RANGE .WORD A.DASH, A.DOT BCC 20$ .ADDR #BLANK,R4 JSR R5,RANGE .WORD A.SPACE,A.SPACE BCC 20$ CLR (R2)+ BR 30$ 20$: SUB R3,R0 ASL R0 ASL R0 MOV R0,-(SP) ASL R0 ASL R0 ADD R0,@SP MOV R4,R0 ADD (SP)+,R0 MOV R0,(R2)+ 30$: DEC R1 BNE 10$ OUTPUT: MOV #1,R3 10$: CALL CRLF 20$: .ADDR #CHRADR,R2 MOV NUMCHR,R1 MOV BUFPTR,R5 25$: .REPT 2 MOV #A.SPACE,R0 CALL CHROUT .ENDR 28$: MOV #10.,(PC)+ 29$: .WORD 10. MOVB (R5)+,R0 CMP R0,#A.DASH BEQ 295$ CMPB R0,#A.DOT BEQ 295$ CMPB R0,#A.COLON BNE 297$ 295$: MOV #A.STAR,R0 297$: MOV (R2)+,R4 BEQ 50$ 30$: MOV R0,(PC)+ 31$: .WORD 0 BIT R3,(R4)+ BNE 40$ MOV #A.SPACE,R0 40$: CALL CHROUT MOV 31$,R0 DEC 29$ BNE 30$ 50$: DEC R1 BNE 25$ 60$: ASL R3 CMP R3,#40000 BLO 10$ CALL CRLF CALL CRLF RFS BIGGY .SBTTL RANGE - Range check a character RANGE: MOV (R5)+,R3 CMP R0,(R5)+ BHI 20$ CMP R0,R3 BLO 20$ 10$: TST (PC)+ 20$: SEC RTS R5 .SBTTL RT.11 - Print an RT banner page RT.11: SFR MOV #6412,SITEND-26. CLRB SITEND-24. .ADDR #SITE+22.,R5 CMP WIDFIL,#10. BNE 5$ MOV #"**,SITEND-26. MOVB #'*,SITEND-24. MOVB #'*,SITE+22. .ADDR #SITE,R5 5$: MOV R5,(PC)+ 55$: .WORD 0 MOVB #40,@R5 MOV #3,R4 10$: MOV 55$,R5 20$: MOVB (R5)+,R0 BEQ 30$ CALL CHROUT BR 20$ 30$: DEC R4 BNE 10$ RFS RT.11 .SBTTL FRM0FF - Print a form feed if FORM0 set FRM0FF: SFR TSTB FRM0FLG BEQ 20$ MOV #14,R0 CALL CHROUT 20$: RFS FRM0FF .SBTTL SUBROUTINE TO OUTPUT A CARRIAGE RETURN AND LINE FEED CRLF: SFR MOV #CR,R0 CALL CHROUT MOV #LF,R0 CALL CHROUT RFS CRLF .SBTTL OUTPUT A STRING. STROUT: SFR 10$: MOVB (R5)+,R0 BEQ 20$ CALL CHROUT BR 10$ 20$: RFS STROUT .SBTTL STORE A TWO DIGIT ASCII NUMBER PUTNUM: MOV #'0,R0 MOVB R0,(R4)+ MOVB R0,@R4 10$: INCB @R4 CMPB @R4,#': BNE 20$ MOVB R0,@R4 INCB -1(R4) 20$: DEC R5 BNE 10$ INC R4 RETURN .SBTTL OUTPUT A CHARACTER TO THE SPOOLER JOB CHROUT: SFR MOVB R0,@SP$BPR INC SP$BPR INC SP$WCR CMP SP$WCR,#512. BLO CHEXIT ASR SP$WCR JSR R0,REGSAV REGS: .BLKW 6 REGSAV: MOV R5,(R0)+ MOV R4,(R0)+ MOV R3,(R0)+ MOV R2,(R0)+ MOV R1,(R0)+ MOV (SP)+,(R0)+ .ADDR #CHRCON,R0 MOV R0,INTVEC BIS #INTEN,@SPCSR RTS PC CHRCON: .ADDR #REGS,R0 MOV (R0)+,R5 MOV (R0)+,R4 MOV (R0)+,R3 MOV (R0)+,R2 MOV (R0)+,R1 MOV (R0)+,R0 CLR SP$WCR INC SP$BNR CHEXIT: RFS CHROUT .SBTTL RADIX 50 TO ASCII CONVERSION R50ASC::.ADDR #DIVTAB,R3 MOV (R4)+,R2 2$: TST -(R3) BEQ R50ASC MOV #-1,R0 CMP #174777,R2 BLO 4$ 3$: INC R0 SUB @R3,R2 BCC 3$ ADD @R3,R2 TST R0 BEQ 5$ CMP #33,R0 BLO 6$ BEQ 7$ 4$: ADD #40,R0 5$: ADD #16,R0 6$: ADD #11,R0 7$: ADD #11,R0 8$: MOVB R0,(R5)+ DEC R1 BNE 2$ RTS PC .WORD 0 .WORD 1 .WORD 50 .WORD 3100 DIVTAB= . .SBTTL CHARACTER FONTS AND FACILITY IDENTIFIER PRION: .ASCIZ " PRINTED ON " PRIAT: .ASCIZ " AT " .EVEN .IF NE SP$DEC SITE:: .ASCII " ***********************" .ASCII " Digital Equiment Corporation," .ASCII " 146 Main Street, Maynard Mass.," .ASCII " U.S.A. " .ASCIZ " ***********************"<15><12> .EVEN SITEND = . .IFF SITE:: .ASCII " ************************" .ASCII " RT-11 **** RT-11 ****" .ASCII " RT-11 **** RT-11 ****" .ASCII " RT-11 " .ASCIZ " ************************"<15><12> .EVEN SITEND = . .ENDC .EVEN CHRADR: .BLKW 10. .RADIX 2 .IFTF .NLIST .IFT A: .WORD 11111111111100 .WORD 11111111111110 .WORD 00000110000011 .WORD 00000110000011 .WORD 00000110000011 .WORD 00000110000011 .WORD 00000110000011 .WORD 00000110000011 .WORD 11111111111110 .WORD 11111111111100 B: .WORD 11111111111111 .WORD 11111111111111 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11111111111111 .WORD 01111100111110 C: .WORD 01111111111110 .WORD 11111111111111 .WORD 11000000000011 .WORD 11000000000011 .WORD 11000000000011 .WORD 11000000000011 .WORD 11000000000011 .WORD 11000000000011 .WORD 11110000001111 .WORD 01110000001110 D: .WORD 11111111111111 .WORD 11111111111111 .WORD 11000000000011 .WORD 11000000000011 .WORD 11000000000011 .WORD 11000000000011 .WORD 11000000000011 .WORD 11000000000011 .WORD 11111111111111 .WORD 01111111111110 E: .WORD 11111111111111 .WORD 11111111111111 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000000000011 .WORD 11000000000011 F: .WORD 11111111111111 .WORD 11111111111111 .WORD 00000011000011 .WORD 00000011000011 .WORD 00000011000011 .WORD 00000011000011 .WORD 00000011000011 .WORD 00000011000011 .WORD 00000000000011 .WORD 00000000000011 G: .WORD 01111111111110 .WORD 11111111111111 .WORD 11000000000011 .WORD 11000000000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11111111001111 .WORD 01111110001110 H: .WORD 11111111111111 .WORD 11111111111111 .WORD 00000011000000 .WORD 00000011000000 .WORD 00000011000000 .WORD 00000011000000 .WORD 00000011000000 .WORD 00000011000000 .WORD 11111111111111 .WORD 11111111111111 I: .WORD 00000000000000 .WORD 11000000000011 .WORD 11000000000011 .WORD 11000000000011 .WORD 11111111111111 .WORD 11111111111111 .WORD 11000000000011 .WORD 11000000000011 .WORD 11000000000011 .WORD 00000000000000 J: .WORD 00000000000000 .WORD 00110000000000 .WORD 01110000000011 .WORD 11000000000011 .WORD 11000000000011 .WORD 01111111111111 .WORD 00111111111111 .WORD 00000000000011 .WORD 00000000000011 .WORD 00000000000000 K: .WORD 11111111111111 .WORD 11111111111111 .WORD 00000011000000 .WORD 00000111100000 .WORD 00001100110000 .WORD 00011000011000 .WORD 00110000001100 .WORD 01100000000110 .WORD 11000000000011 .WORD 10000000000001 L: .WORD 11111111111111 .WORD 11111111111111 .WORD 11000000000000 .WORD 11000000000000 .WORD 11000000000000 .WORD 11000000000000 .WORD 11000000000000 .WORD 11000000000000 .WORD 11000000000000 .WORD 11000000000000 M: .WORD 11111111111111 .WORD 11111111111110 .WORD 00000000111100 .WORD 00000001110000 .WORD 00000011100000 .WORD 00000011100000 .WORD 00000001110000 .WORD 00000000111100 .WORD 11111111111110 .WORD 11111111111111 N: .WORD 11111111111111 .WORD 11111111111111 .WORD 00000000001110 .WORD 00000000111100 .WORD 00000011110000 .WORD 00001111000000 .WORD 00111100000000 .WORD 01110000000000 .WORD 11111111111111 .WORD 11111111111111 O: .WORD 01111111111110 .WORD 11111111111111 .WORD 11000000000011 .WORD 11000000000011 .WORD 11000000000011 .WORD 11000000000011 .WORD 11000000000011 .WORD 11000000000011 .WORD 11111111111111 .WORD 01111111111110 P: .WORD 11111111111111 .WORD 11111111111111 .WORD 00000110000011 .WORD 00000110000011 .WORD 00000110000011 .WORD 00000110000011 .WORD 00000110000011 .WORD 00000110000011 .WORD 00000111111111 .WORD 00000011111110 Q: .WORD 01111111111110 .WORD 11111111111111 .WORD 11000000000011 .WORD 11000000000011 .WORD 11000000000011 .WORD 11010000000011 .WORD 11110000000011 .WORD 01100000000011 .WORD 11111111111111 .WORD 11011111111110 R: .WORD 11111111111111 .WORD 11111111111111 .WORD 00000110000011 .WORD 00000110000011 .WORD 00001110000011 .WORD 00011110000011 .WORD 00110110000011 .WORD 01100110000011 .WORD 11000111111111 .WORD 10000011111110 S: .WORD 01110001111110 .WORD 11110011111111 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11111111001111 .WORD 01111110001110 T: .WORD 00000000000011 .WORD 00000000000011 .WORD 00000000000011 .WORD 00000000000011 .WORD 11111111111111 .WORD 11111111111111 .WORD 00000000000011 .WORD 00000000000011 .WORD 00000000000011 .WORD 00000000000011 U: .WORD 01111111111111 .WORD 11111111111111 .WORD 11000000000000 .WORD 11000000000000 .WORD 11000000000000 .WORD 11000000000000 .WORD 11000000000000 .WORD 11000000000000 .WORD 11111111111111 .WORD 01111111111111 V: .WORD 00000000000111 .WORD 00000000111111 .WORD 00000111111000 .WORD 00111111000000 .WORD 11111000000000 .WORD 11111000000000 .WORD 00111111000000 .WORD 00000111111000 .WORD 00000000111111 .WORD 00000000000111 W: .WORD 00111111111111 .WORD 11111111111111 .WORD 11111100000000 .WORD 00001110000000 .WORD 00000011100000 .WORD 00000011100000 .WORD 00001110000000 .WORD 11111100000000 .WORD 11111111111111 .WORD 00111111111111 X: .WORD 11000000000011 .WORD 11100000001111 .WORD 00111000011100 .WORD 00011100110000 .WORD 00000111100000 .WORD 00000111100000 .WORD 00011100110000 .WORD 00111000011100 .WORD 11100000001111 .WORD 11000000000011 Y: .WORD 00000000000011 .WORD 00000000001111 .WORD 00000000111100 .WORD 00000011110000 .WORD 11111111000000 .WORD 11111111000000 .WORD 00000011110000 .WORD 00000000111100 .WORD 00000000001111 .WORD 00000000000011 Z: .WORD 10000000000011 .WORD 11000000000011 .WORD 11110000000011 .WORD 11111100000011 .WORD 11001111000011 .WORD 11000011110011 .WORD 11000000111111 .WORD 11000000001111 .WORD 11000000000011 .WORD 11000000000001 ZERO: .WORD 01111111111110 .WORD 11111111111111 .WORD 11000000000011 .WORD 11000000000011 .WORD 11000000000011 .WORD 11000000000011 .WORD 11000000000011 .WORD 11000000000011 .WORD 11111111111111 .WORD 01111111111110 ONE: .WORD 00000000000000 .WORD 11000000000100 .WORD 11000000000110 .WORD 11000000000011 .WORD 11111111111111 .WORD 11111111111111 .WORD 11000000000000 .WORD 11000000000000 .WORD 11000000000000 .WORD 00000000000000 TWO: .WORD 11110000000110 .WORD 11111000000111 .WORD 11001100000011 .WORD 11000110000011 .WORD 11000011000011 .WORD 11000001100011 .WORD 11000000110011 .WORD 11000000011011 .WORD 11000000001111 .WORD 11000000000110 THREE: .WORD 01100000000011 .WORD 11100000000011 .WORD 11000000000011 .WORD 11000000000011 .WORD 11000001100011 .WORD 11000011110011 .WORD 11000011011011 .WORD 11000011001111 .WORD 11111110000111 .WORD 01111100000011 FOUR: .WORD 00000011111111 .WORD 00000011111111 .WORD 00000011000000 .WORD 00000011000000 .WORD 00000011000000 .WORD 00000011000000 .WORD 11111111111111 .WORD 11111111111111 .WORD 00000011000000 .WORD 00000011000000 FIVE: .WORD 01110011111111 .WORD 11110011111111 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11111111000011 .WORD 01111110000011 SIX: .WORD 01111111111110 .WORD 11111111111111 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11111111000111 .WORD 01111110000110 SEVEN: .WORD 11111000000111 .WORD 11111100000111 .WORD 00000110000011 .WORD 00000011000011 .WORD 00000001100011 .WORD 00000000110011 .WORD 00000000011011 .WORD 00000000001111 .WORD 00000000000111 .WORD 00000000000011 EIGHT: .WORD 01111100111110 .WORD 11111111111111 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11111111111111 .WORD 01111100111110 NINE: .WORD 01100000111110 .WORD 11100011111111 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11000011000011 .WORD 11111111111111 .WORD 01111100111110 COLON: .WORD 00000000000000 .WORD 00000000000000 .WORD 00000000000000 .WORD 00011100011100 .WORD 00011100011100 .WORD 00011100011100 .WORD 00000000000000 .WORD 00000000000000 .WORD 00000000000000 .WORD 00000000000000 DASH: .WORD 00000011000000 .WORD 00000011000000 .WORD 00000011000000 .WORD 00000011000000 .WORD 00000011000000 .WORD 00000011000000 .WORD 00000011000000 .WORD 00000011000000 .WORD 00000011000000 .WORD 00000011000000 PERIOD: .WORD 00000000000000 .WORD 00000000000000 .WORD 00000000000000 .WORD 11100000000000 .WORD 11100000000000 .WORD 11100000000000 .WORD 00000000000000 .WORD 00000000000000 .WORD 00000000000000 .WORD 00000000000000 BLANK: .WORD 00000000000000 .WORD 00000000000000 .WORD 00000000000000 .WORD 00000000000000 .WORD 00000000000000 .WORD 00000000000000 .WORD 00000000000000 .WORD 00000000000000 .WORD 00000000000000 .WORD 00000000000000 .RADIX 8. .ENDC .LIST .SBTTL HANDLER TERMINATION .DREND SP .END .MCALL .MODULE .MODULE TJ,VERSION=14,COMMENT= ; COPYRIGHT (c) 1987 BY ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. ; ALL RIGHTS RESERVED. ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED ; ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE ; INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER ; COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY ; OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY ; TRANSFERRED. ; ; THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE ; AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT ; CORPORATION. ; ; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS ; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL. .SBTTL RT-11 MM (TJU16) MAGTAPE HANDLER .SBTTL NOTES ON TJU16 HANDLER .SBTTL HARDWARE DEFINITIONS .MCALL .DRDEF, .ADDR .IIF NE MMG$T .MCALL .SYNCH .IIF NDF MM$FSM MM$FSM = 0 .IIF NDF MM$UN, MM$UN == 1 .DRDEF MM,20,SPECL$!SPFUN$!HNDLR$,0,172440,224 .IIF EQ MMG$T .DRPTR .DREST CLASS=DVC.MT .DRSPF <-1> .DRSPF <-2> .DRSPF <-3> .DRSPF <-4> .DRSPF <-5> .DRSPF <-6> .DRSPF <-7> .DRSPF <-8.> .IIF NE MM$FSM .DRSPF <-20.> .IIF EQ MM$FSM .FSM = 100000 .AUDIT .TJ .AUDIT .FSM SC = 100000 TRE = 040000 MCPE = 020000 DVA = 004000 PSEL = 002000 A17 = 001000 A16 = 000400 RDY = 000200 IE = 000100 FNOOP = 000000 FOFF = 000002 FREWIND = 000006 FDRCLR = 000010 FERASE = 000024 FWRTTM = 000026 FSPFOR = 000030 FSPBAK = 000032 FWRTCF = 000050 FWRTCR = 000056 FWRITE = 000060 FREADF = 000070 FREADR = 000076 GO = 000001 DLT = 100000 WCE = 040000 UPE = 020000 NED = 010000 NEM = 004000 PGE = 002000 MXF = 001000 MDPE = 000400 OR = 000200 IR = 000100 CLR = 000040 PAT = 000020 BAI = 000010 DRIVEBIT= 000001 DRIVE = 0 ATA = 100000 ERR = 040000 PIP = 020000 MOL = 010000 WRL = 004000 EOT = 002000 DPR = 000400 DRY = 000200 SSC = 000100 PES = 000040 SDWN = 000020 IDB = 000010 TM = 000004 BOT = 000002 SLA = 000001 CORCRC = 100000 UNS = 040000 OPI = 020000 DTE = 010000 NEF = 004000 CSITM = 002000 FCE = 001000 NSG = 000400 PEFLRC = 000200 INCVPE = 000100 DPAR = 000040 FMT = 000020 CPAR = 000010 RMR = 000004 ILR = 000002 ILF = 000001 ACCL = 100000 FCS = 040000 TCW = 020000 EAODTE = 010000 D7$200 = 0 D7$556 = 000400 D7$800 = 001000 D9$800 = 001400 D9$1600 = 002000 NORMAL = 000300 COREDP = 000320 EVPAR = 000010 ODDPAR = 0 EPCOMBO = EVPAR+NORMAL+D9$800 .SBTTL SOFTWARE DEFINITIONS RENAME = 5 ENTER = 4 LOOKUP = 3 DELETE = 2 CLOSE = 1 REDWRT = 0 WRTEOF = -1 FWDSPC = -2 BKSPC = -3 ERASE = -4 REWIND = -5 OFFLINE = -6 WRITE = -7 READF = -8. STR100 = -9. FN = 8. ILLARG = 5 DEVINUSE= 2 ERRGAPS = -100. REDREC = -1 WRIREC = -2 NOQUAL = 0 DRIVEGONE = 1 POSERR = 2 MEMERR = 3 WRITELOK = 4 RECERR = 5 SMLREC = 6 NOQUAL = 0 EOFCODE = 1 EOTCODE = 2 EOFEOT = 3 BOTCODE = 4 SYSPTR = 54 QCOMP = 270 SPUSR = 272 UNITMK = 7 NRETRY = 8. .SBTTL Install Code .DRINS MM .SBTTL SET COMMANDS .DRSET DENSE, NOP, O.DENS, NUM .DRSET ODDPAR, EVPAR, O.PAR, NO .DRSET DEFALT, NOP, O.DFLT, NUM .DRSET CSR, 160000, O.CSR, OCT .DRSET VECTOR, 500, O.VEC, OCT .DRSET RETRY, 127., O.RTRY, NUM O.DENS: CMP #809.,R0 BEQ 1$ CMP #800.,R0 BEQ 1$ CMP #1600.,R0 BEQ 2$ SEC RTS PC 1$: MOV #D9$800,R3 BR 3$ 2$: MOV #D9$1600,R3 BIC #EVPAR,DENSE 3$: BIC #3400,DENSE BIS R3,DENSE CLC RTS PC O.PAR: BR 2$ NOP MOV DENSE,R1 BIC #^C<3400>,R1 CMP #D9$1600,R1 BNE 1$ SEC RTS PC 1$: BIS R3,DENSE BR 3$ 2$: BIC R3,DENSE 3$: CLC RTS PC O.DFLT: CMP #9.,R0 BNE 1$ MOV #D9$800+NORMAL+ODDPAR,DENSE CLC RTS PC 1$: SEC RTS PC O.CSR: CMP R0,R3 BLO O.BAD MOV R0,INSCSR MOV R0,DISCSR .ADDR #MMCS1,R1 MOV #NREGS,R2 10$: MOV R0,(R1)+ ADD #2,R0 DEC R2 BGT 10$ O.GOOD: TST (PC)+ O.BAD: SEC RETURN O.VEC: CMP R0,R3 BHIS O.BAD MOV R0,MMSTRT BR O.GOOD O.RTRY: CMP R0,R3 BHI O.BAD MOV R0,RTRYCT BEQ O.BAD BR O.GOOD .IIF GT .-1000 .ERROR .SBTTL Global Definitions .IF NE MM$FSM .GLOBL FSMDIS, FSMABT, FSMDON .GLOBL FSMERR, CODE, DVTBL .GLOBL FSMSIZ, RESTOR .GLOBL MMCQE .IF NE MMG$T .GLOBL OLDBA, XBUMP, EXTADR .GLOBL JOBNM, SYNBLK, TEMP .GLOBL SINK, ERBSAV .ENDC .ENDC .SBTTL Handler Entry Point .DRBEG MM BR MM MMCS1: .WORD MM$CSR MMWC: .WORD MM$CSR+2 MMBA: .WORD MM$CSR+4 MMFC: .WORD MM$CSR+6 MMCS2: .WORD MM$CSR+10 MMDS: .WORD MM$CSR+12 MMER: .WORD MM$CSR+14 MMAS: .WORD MM$CSR+16 MMCC: .WORD MM$CSR+20 MMDB: .WORD MM$CSR+22 MMMR: .WORD MM$CSR+24 MMDT: .WORD MM$CSR+26 MMSN: .WORD MM$CSR+30 MMTC: .WORD MM$CSR+32 NREGS = <.-MMCS1>/2 RTRYCT: .WORD NRETRY MMUSED: .BYTE 1 .EVEN MM: .IF NE MMG$T MOV MMCQE,R5 CMP (R5)+,(R5)+ JSR PC,@$MPPTR MOV (SP)+,OLDBA BIT #1700,@SP BEQ 10$ TST (SP)+ MOV MMCQE,R5 BIS #HDERR$,@-(R5) JMP MMDONE 10$: ASL @SP ASL @SP ASL @SP ASL @SP MOV (SP)+,EXTADR .ENDC .IF EQ MM$FSM MOV MMCQE,R3 .IFF JMP FSMDIS $MT:: MOV MTCQ,R3 .ENDC TSTB MMUSED BEQ 12$ CALL CONCLR CLRB MMUSED 12$: CALL DRICLR TST (R3)+ MOV @R3,R0 MOVB R0,R4 SWAB R0 BIC #^C,R0 MOV R0,R1 BIS (PC)+,R0 DENSE: .WORD D9$800+NORMAL+ODDPAR MOV R0,@MMTC MOV #0,@MMCS2 CLR NFSREAD MOV PC,R0 ADD #RECOVE-.,R0 MOV R1,R5 ADD PC,R5 ADD #$TBL-.,R5 MOV @R3,R2 SWAB R2 ASR R2 ASR R2 ASR R2 BIC #177740,R2 .IF NE MMG$T MOVB R2,JOBNM .ENDC .ENABL LSB CMP #LOOKUP,R4 BNE 7$ .FOO = 0 .IF NE MMG$T .IF EQ MM$FSM .FOO = 1 MOV MMCQE,R4 JSR PC,@$GTBYT TSTB (SP)+ BNE 5$ JSR PC,@$GTBYT TSTB (SP)+ BNE 5$ .ENDC .ENDC .IF EQ .FOO TST @2(R3) BNE 10$ .ENDC CMPB #-1,@R5 BEQ 3$ .IF EQ MM$FSM MOV #DEVINUSE,R0 2$: MOV @#SYSPTR,R1 MOV R0,SPUSR(R1) .IFF MOV @#SYSPTR,R1 MOV #DEVINUSE,SPUSR(R1) .ENDC .IF NE MM$FSM JSR PC,RESTOR JMP $DONE .IFF BR 11$ .ENDC 3$: CLR 4(R3) MOVB R2,@R5 .IF NE MM$FSM BR 11$ .IFF 4$: MOV -2(R3),R1 BEQ 6$ BGT 5$ INC R1 BEQ 11$ 5$: MOVB #-1,@R5 MOV #ILLARG,R0 BR 2$ 6$: MOV #REWIND,R4 BR 8$ .ENDC 7$: CMP #CLOSE,R4 BNE 8$ MOVB #-1,@R5 BR 11$ 8$: MOV (PC)+,(R0)+ .BYTE -1,ERRGAPS MOV @MMDS,@R0 BIC #^C,(R0)+ CMP #STR100,R4 BEQ 11$ CMP #READF,R4 BLOS 12$ TST R4 BNE 10$ MOV R3,R1 CLR -2(R1) CMP (R1)+,(R1)+ MOV #READF,R4 TST @R1 BPL 9$ NEG @R1 INC R4 BR 20$ 9$: COM NFSREAD 20$: .IF NE MM$FSM MOV R4,CODE .ENDC BR 12$ 10$: TST -(R3) BIS #HDERR$,@-(R3) 11$: .IF NE MM$FSM JSR PC,RESTOR .ENDC mmdon1: JMP MMDONE 12$: ADD #FUNTAB-TABLE,R4 MOV R4,(R0)+ .IF NE MMG$T MOV 4(R3),R1 MOV R1,4(R0) .IFF TST (R3)+ MOV (R3)+,(R0)+ MOV @R3,@R0 MOV @R3,R1 .ENDC .DSABL LSB NEG R1 LOADGO: JSR PC,DISPAT TABLE: .BYTE /2 .BYTE /2 .BYTE /2 .BYTE /2 .BYTE /2 .BYTE /2 .BYTE /2 .BYTE /2 FUNTAB: .BYTE FREADF+IE+GO .BYTE FWRITE+IE+GO .BYTE FOFF+IE+GO .BYTE FREWIND+IE+GO .BYTE FERASE+IE+GO .BYTE FSPBAK+IE+GO .BYTE FSPFOR+IE+GO .BYTE FWRTTM+IE+GO REDEF: RIGHT: .IF NE MMG$T MOV (R0)+,@MMBA BIS @R0,R5 .IFF MOV -(R3),@MMBA .ENDC MOV R1,@MMWC ASL R1 mov r1,@mmfc br rightm FORSPA: BAKSPA: MOV R1,@MMFC AWFLINE: REWHINED: mov #5000.,r0 90$: dec r0 beq mmdon1 bit #sdwn,@mmds bne 90$ ERACE: RIGHTM: MOV R5,@MMCS1 CLRB CMDINI .IF NE MM$FSM JSR PC,RESTOR .ENDC RTS PC .SBTTL ABORT ENTRY POINT MMABRT: MOVB #-1,$FLG MOV R3,-(SP) MOV PC,R5 ADD #$TBL-.,R5 MOV MMCQE,R3 BEQ 7$ MOVB Q$JNUM(R3),-(SP);GET JOB NUMBER MOVB (SP)+,R3 ASR R3 ASR R3 ASR R3 BIC #177740,R3 CMP R3,R4 BNE 7$ CLRB $FLG CALL CONCLR 5$: .IF NE MM$FSM MOV R0,-(SP) MOV DVTBL,R0 BEQ 6$ MOV #-1,(R0)+ MOV #-1,@R0 6$: MOV (SP)+,R0 .ENDC 7$: CMPB R4,@R5 BNE 10$ MOVB #-1,@R5 10$: CMPB #-2,(R5)+ BNE 7$ MOV (SP)+,R3 JMP $DONE .SBTTL INTERRUPT ENTRY POINT .DRAST MM,5,MMABRT .SBTTL ERROR-ERROR ROUTINE DISPATCHER .ENABL LSB TST MMCQE BNE 114$ JMP $RTS 114$: MOV @MMCS1,R5 BMI 1$ NOERR0: JMP NOERR 1$: BIT #MCPE,R5 BNE NQ1 MOV LASTCOM,R4 BIT #MOL,@MMDS BNE 2$ CMP #FN+OFFLINE,R4 BEQ 2$ MOV #DRIVEGONE,R4 JMP AB1 2$: JSR PC,DISPAT .DSABL LSB .SBTTL TABLEE - DISPATCH TABLE TABLEE: .BYTE /2 .BYTE /2 .BYTE /2 .BYTE /2 .BYTE /2 .BYTE /2 .BYTE /2 .BYTE /2 .SBTTL ERROR-READ COMMAND WAS ISSUED LAST AND SC BIT WAS SET. .ENABL LSB ERREAD: MOV @MMDS,R5 BPL ERWRI1 BIT #ERR,R5 BEQ TMEOTC MOV @MMER,R4 CALL DRICLR BIT #CSITM,R4 BEQ 2$ BIT #PES,R5 BNE 1$ MOV #POSERR,R4 BR AB1 1$: CLR R4 BR ERWRI1 2$: CMP #EPCOMBO,DENSE BNE 26$ BIT #,R4;Isolate 2 error bits BNE 3$ jmp nexti 26$: BIT #,R4 BEQ 4$ 3$: MOV #REDREC,R4 BR ERWRI1 4$: BIT #CORCRC,R4 BEQ 5$ BIT #PES,R5 BNE 1$ BR 3$ 5$: BIT #FCE,R4 BNE 1$ NQ1: JMP NQUAL .DSABL LSB .SBTTL ERROR-WRITE COMMAND WAS ISSUED LAST AND SC BIT WAS SET. .ENABL LSB ERWRIT: TST @MMFC BEQ 1$ MOV #POSERR,R4 BIT #WRL,@MMDS BEQ AB1 MOV #WRITELOK,R4 BR AB1 1$: MOV @MMDS,R5 BPL 5$ BIT #ERR,R5 BEQ TMEOTC MOV @MMER,R4 CALL DRICLR BIT #NEF,R4 BEQ 2$ BR NQ1 2$: BIT #INCVPE+PEFLRC+CORCRC+NSG,R4 BEQ 4$ CMP #EPCOMBO,DENSE BNE 3$ BIC #INCVPE,R4 BNE 3$ NOERR2: JMP NOERR 3$: MOV #WRIREC,R4 BR 5$ 4$: BIT #CSITM,R4 BEQ NQ3 BIT #PES,R5 BEQ NQ3 BR 3$ ERWRI1: 5$: JSR PC,TREFND JMP CONT .DSABL LSB .SBTTL TAPEMARK AND EOT CHECKER TMEOTC: BIT #SSC,R5 BNE DRCLR BIT #TM+EOT,R5 BEQ NQ3 BR DRCLR .SBTTL ERROR-ERASE OR WRITE TAPEMARK COMMAND WAS ISSUED LAST AND SC BIT WAS SET. .ENABL LSB ERERAS: ERWRTM: MOV @MMDS,R5 BMI 4$ NQ3: JMP NQUAL 4$: BIT #ERR,R5 BEQ 10$ BIT #WRL,R5 BNE AB0 MOV @MMER,R4 CMP #EPCOMBO,DENSE BNE 8$ CMP #INCVPE,R4 BEQ NOERR2 8$: BIT #NEF,R4 BEQ NQUAL AB0: MOV #WRITELOK,R4 AB1: BR ABORT 10$: JSR PC,ONLINE CALL DRICLR CMP #FN+ERASE,LASTCOM BNE NOERR1 MOV #FN+WRITE,LASTCOM MOV OLDWC,R4 NEG R4 MOV MMWC,R5 MOV R4,(R5)+ MOV OLDBA,(R5)+ ASL R4 MOV R4,(R5)+ .IF NE MMG$T MOVB FUNTAB+1,R4 BIS EXTADR,R4 MOV R4,@MMCS1 .IFF MOVB FUNTAB+1,@MMCS1 .ENDC JMP ASTEXI .DSABL LSB .SBTTL ERROR-SPACING COMMAND WAS ISSUED LAST AND SC BIT WAS SET. .ENABL LSB ERBKSP: ERFWSP: MOV @MMDS,R5 BIT #,R5 BNE NEXTI TST R5 BPL NQUAL TSTB CMDINI BNE 2$ BIT #ERR,R5 BEQ 2$ MOV @MMER,R4 BIT #NEF,R4 BEQ 1$ BIT #BOT,R5 BNE NOERR BR NQUAL 1$: BIT #FCE,R4 BEQ NQUAL NOERR1: BR NOERR 2$: JSR PC,ONLINE BR DRCLR .DSABL LSB .SBTTL ERROR-REWIND OR REWIND/OFFLINE COMMAND WAS ISSUED LAST AND SC BIT WAS SET. .ENABL LSB ERREWD: EROFFL: MOV @MMDS,R5 BIT #ERR,R5 BEQ 1$ BIT #OPI,@MMER BEQ NQUAL BR 3$ 1$: TSTB RECOVERY BPL 4$ CMP #FN+OFFLINE,LASTCOM BEQ NOERR MOVB LASTCOM,RECOVERY NEXTI: MOV #DRIVEBIT,@MMAS INCB CMDINI 2$: MOV #IE,@MMCS1 BIT #PIP,@MMDS BEQ 3$ ASTX2: JMP ASTEXI DRCLR: 3$: CALL DRICLR BR NOERR 4$: BIT #SLA,R5 BNE 3$ CALL CONCLR BR 2$ .DSABL LSB .SBTTL ERROR-ABORT OPERATION IN PROGRESS NQUAL: CLR R4 ABORT: CALL CONCLR MOV #HDERR$,-(SP) EXCEP: .IF NE MM$FSM MOV (SP)+,R5 JMP FSMERR .IFF MOV MMCQE,R5 BIS (SP)+,@Q$CSW(R5) TST @R5 BEQ MMDONE .IF NE MMG$T COM SINK MOV @R5,ERBSAV MOV R4,TEMP MOVB Q$JNUM(R5),R5 ASR R5 ASR R5 ASR R5 MOV R5,JOBNM .IFF MOV R4,@(R5)+ .ENDC .IFTF MMDONE: .IFT JMP FSMDON .ENDC $DONE:: TSTB $FLG BNE $RTS .IF NE MMG$T MOV PC,R4 ADD #MMCQE-.,R4 MOV @#SYSPTR,R5 TST SINK BNE 1$ JMP @QCOMP(R5) 1$: CLR SINK JSR PC,@QCOMP(R5) MOV PC,R4 ADD #SYNBLK-.,R4 .SYNCH BR BADSYN MOV ERBSAV,R1 BIS #30000,@#177776 MOV R0,-(SP) MTPI (R1)+ MOV ERRBL2,-(SP) MTPI (R1)+ BADSYN: BR ASTEXI .IFF .DRFIN MM .ENDC $RTS: CLRB $FLG ASTEXI: RTSPC: RTS PC .SBTTL STATUS REPORTING-COME HERE IF NO ABORTS ISSUED NOERR: CLR R4 CONT: MOV R4,ERRSUM TSTB RECOVERY BPL RECOVR TST ERRSUM BEQ NEXT1 CMP #FN+READF,LASTCOM BNE 1$ MOVB #5,BACK1 MOVB RTRYCT,BACK5 MOV #FN+READF,R4 BR 2$ 1$: MOV #FN+ERASE,R4 2$: MOVB R4,RECOVERY BR REEDF1 NEXT0: CMP #FN+REWIND,R4 BNE NEXT1 MOVB R4,RECOVERY NEXT1: MOV @MMFC,R4 CMP #FN+READF,LASTCOM BNE NEXT2 BIT #TM,@MMDS BNE NEXT3 MOV OLDWC,R5 ASL R5 SUB R4,R5 BEQ NEXT3 BGT 1$ MOV #RECERR,R4 NEG R5 BR 2$ 1$: MOV #SMLREC,R4 2$: ASR R5 .IF NE MMG$T MOV R5,ERRBL2 .IFF MOV R5,-(SP) .IF NE MM$FSM MOV @MTCQ,R5 .IFF MOV @MMCQE,R5 .ENDC BEQ 3$ MOV @SP,2(R5) 3$: TST (SP)+ .ENDC .IF NE MMG$T JMP ABORT .IFF BR ABORT .ENDC NEXT2: CMP #FN+FWDSPC,LASTCOM BEQ 1$ CMP #FN+BKSPC,LASTCOM BNE NEXT3 1$: NEG R4 BEQ NEXT3 .IF NE MMG$T MOV R4,ERRBL2 .IFF .IF NE MM$FSM MOV @MTCQ,R5 .IFF MOV @MMCQE,R5 .ENDC BEQ NEXT3 MOV R4,2(R5) .ENDC .ENABL LSB NEXT3: MOV @MMDS,R5 CLR R4 BIT #BOT,R5 BEQ 1$ CMP #FN+REWIND,LASTCOM MMD1: BEQ MMDONE CMP #FN+OFFLINE,LASTCOM BEQ MMD1 MOV #BOTCODE,R4 BR 4$ 1$: BIT #TM,R5 BEQ 2$ CMP #FN+WRTEOF,LASTCOM BEQ 2$ INC R4 2$: BIT #EOT,R5 BEQ 3$ TST NFSREAD BNE 3$ CMPB (R4)+,(R4)+ 3$: TST R4 BEQ MMD1 4$: MOV #EOF$,-(SP) JMP EXCEP .DSABL LSB .SBTTL RECOVERY IN PROGRESS DISPATCHER RECOVR: MOV LASTCOM,R4 JSR PC,DISPAT TABLER: .BYTE /2 .BYTE /2 .BYTE 0 .BYTE /2 .BYTE 0 .BYTE /2 .BYTE /2 .BYTE 0 .SBTTL RECOVERY-READ WAS THE LAST COMMAND ISSUED .ENABL LSB REEDF: TST ERRSUM BPL NEXT1 DECB BACK1 BEQ 2$ BGT REEDF1 MOVB #5,BACK1 DECB BACK5 BEQ NQ2 REEDF1: MOV #-1,R5 BR 3$ 2$: MOV #-5,R5 3$: MOV R5,@MMFC BR BACH2 .DSABL LSB .SBTTL RECOVERY-WRITE WAS LAST COMMAND RITE: TST ERRSUM BEQ NEXT1 INCB TAPELEN BEQ NQ2 BIT #EOT,@MMDS BEQ REEDF1 NQ2: JMP NQUAL .SBTTL RECOVERY-FORWARD SPACE WAS THE LAST COMMAND FORE: MOV @MMFC,R5 BNE BACH1 FORE1: MOV MMBA,R5 MOV OLDBA,@R5 MOV OLDWC,-(R5) NEG (R5) MOV #FN+READF,LASTCOM .IF NE MMG$T MOVB FUNTAB,R4 BIS EXTADR,R4 MOV R4,-(R5) .IFF MOVB FUNTAB,@MMCS1 .ENDC RTS PC .SBTTL RECOVERY-REWIND WAS THE LAST COMMAND REWHYN: JMP MMDONE .SBTTL RECOVERY-BACKSPACE WAS LAST COMMAND .ENABL LSB BACH: CMPB #FN+READF,RECOVERY BEQ 1$ MOV #FN+ERASE,R4 MOVB FUNTAB+4,R5 BR 4$ 1$: MOV @MMFC,R5 BEQ 6$ BIT #BOT,@MMDS BEQ BACH2 2$: ADD #4,R5 BEQ 8$ 3$: NEG R5 BACH1: CALL DRICLR MOV #FN+FWDSPC,R4 MOV R5,@MMFC MOVB FUNTAB+6,R5 BR 4$ BACH2: CALL DRICLR MOV #FN+BKSPC,R4 MOV R5,@MMFC MOVB FUNTAB+5,R5 4$: MOV R4,LASTCOM MOV R5,@MMCS1 RTS PC 6$: TSTB BACK1 BEQ 2$ 8$: CALL DRICLR BR FORE1 DRICLR: MOV #,@MMCS1 RETURN CONCLR: MOV #CLR,@MMCS2 RETURN .DSABL LSB .SBTTL TRE (TRANSFER ERROR) BIT FOUND SUBROUTINE TREFND: MOV @MMCS2,R5 MOV #TRE,@MMCS1 BIT #NEM,R5 BEQ 1$ MOV #MEMERR,R4 BR 3$ 1$: BIT #NED,R5 BEQ 2$ MOV #DRIVEGONE,R4 BR 3$ 2$: BIT #MXF+MDPE+PGE+UPE+WCE,R5 BEQ 4$ CLR R4 3$: TST (SP)+ JMP ABORT 4$: BIT #DLT,R5 BEQ 5$ MOV #REDREC,R4 5$: RTS PC .IF NE MMG$T .SBTTL XBUMP SUBROUTINE XBUMP: MOV MMCQE,-(SP) ADD #Q$PAR,@SP ADD #10,@(SP)+ ADD #512.,OLDBA ADCB EXTADR+1 RTS PC .ENDC .SBTTL ONLINE SUBROUTINE ONLINE: BIT #SSC,R5 BEQ 1$ MOV #DRIVEBIT,@MMAS TSTB @MMDS BMI 1$ MOV #FNOOP+IE+GO,@MMCS1 TST (SP)+ 1$: RTS PC .SBTTL DISPATCH SUBROUTINE DISPAT: ADD @SP,R4 MOVB FUNTAB-TABLE(R4),R5 MOVB @R4,R4 BIC #177400,R4 ASL R4 ADD (SP)+,R4 JMP @R4 .SBTTL MAGTAPE DATA AREA $TBL: .REPT MM$UN .BYTE -1 .ENDR .BYTE -2 $FLG: .BYTE 0 .EVEN RECOVE: .BYTE -1 TAPELE: .BYTE ERRGAPS OLDEOT: BACK5: .BYTE 0 BACK1: .BYTE 0 .EVEN LASTCO: .WORD 0 OLDBA: .WORD 0 .IIF NE MMG$T, EXTADR: .WORD 0 OLDWC: .WORD 0 ERRSUM: .WORD 0 NFSREA: .WORD 0 .EVEN .IF NE MMG$T SYNBLK: .WORD 0 JOBNM: .WORD 0 .WORD 0,0 TEMP: .WORD 0 .WORD -1,0 SINK: .WORD 0 ERBSAV: .WORD 0 ERRBL2: .WORD 0 .ENDC .IF NE MM$FSM MTCQ:: .WORD 0 DRIVEN==MM$UN DVINFO::.REPT DRIVEN .WORD -1 .WORD -1 .WORD -1 .BYTE 0 .BYTE 0 .WORD 0,0,0 .ENDR .ENDC CMDINI: .BYTE 0 .EVEN .IF EQ MM$FSM .DREND MM .IFF .GLOBL $FKPTR,$INPTR .IIF NE MMG$T, .GLOBL $RLPTR,$MPPTR,$GTBYT,$PTBYT,$PTWRD .IIF NE ERL$G, .GLOBL $ELPTR .IIF NE TIM$IT, .GLOBL $TIMIT .ENDC SIZE=. SIZED=SIZE-MMSTRT/2 MTDONE==MMDONE MTCQE==MMCQE MT==MM MTLQE==MMLQE MTSTRT==MMSTRT .END .MCALL .MODULE .MODULE TM,VERSION=11,COMMENT= ; COPYRIGHT (c) 1986 BY ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. ; ALL RIGHTS RESERVED. ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED ; ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE ; INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER ; COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY ; OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY ; TRANSFERRED. ; ; THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE ; AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT ; CORPORATION. ; ; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS ; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL. .SBTTL CONDITIONAL ASSEMBLY SUMMARY .IIF NDF MT$FSM MT$FSM == 0 .SBTTL Edit History .SBTTL TM11 Magtape Handler Abstract .ENABL LC .SBTTL HARDWARE DEFINITIONS .MCALL .DRDEF, .ADDR .ASSUME .IIF NE MMG$T .MCALL .SYNCH .DRDEF MT,11,SPECL$!SPFUN$!HNDLR$,0,172520,224 .IIF EQ MMG$T .DRPTR .DREST CLASS=DVC.MT .DRSPF <-1> .DRSPF <-2> .DRSPF <-3> .DRSPF <-4> .DRSPF <-5> .DRSPF <-6> .DRSPF <-7> .DRSPF <-8.> .DRSPF <-9.> .IIF NE MT$FSM .DRSPF <-20.> .IIF NDF MT$UN, MT$UN == 1 .IIF EQ MT$FSM .FSM = 100000 .AUDIT .TM .AUDIT .FSM ILC = 100000 EOF = 040000 CRE = 020000 PAE = 010000 BGL = 004000 EOT = 002000 RLE = 001000 BTEOPI = 000400 NXM = 000200 SELR = 000100 BOT = 000040 CH7 = 000020 SDWN = 000010 WRL = 000004 RWS = 000002 TUR = 000001 ERR = 100000 D7$200 = 000000 D7$556 = 020000 D7$800 = 040000 D7$CORE = 060000 D9$800 = 060000 PWRCLR = 010000 PEVN = 004000 UNIT = 003400 CURDY = 000200 INTENB = 000100 FOFF = 000000 FREAD = 000002 FWRITE = 000004 FWRTTM = 000006 FSPFOR = 000010 FSPBAK = 000012 FWRTEXT = 000014 FREWIND = 000016 GO = 000001 GPSDN = 010000 .SBTTL SOFTWARE DEFINITIONS RENAME = 5 ENTER = 4 LOOKUP = 3 DELETE = 2 CLOSE = 1 REDWRT = 0 WRTEOF = -1 FWDSPC = -2 BKSPC = -3 WRTXTD = -4 REWIND = -5 OFFLINE = -6 WRITEPHY= -7 READF = -8. STR100 = -9. FN = 8. ILLARG = 5 DEVINUSE= 2 ERRGAPS = -101. NOQUAL = 0 DRIVEGONE = 1 POSERR = 2 MEMERR = 3 WRITELOK= 4 RECERR = 5 SMLREC = 6 NOQUAL = 0 EOFCODE = 1 EOTCODE = 2 EOFEOT = 3 BOTCODE = 4 SYSPTR = 54 QCOMP = 270 SPUSR = 272 UNITMK = 007 NRETRY = 8. .SBTTL INSTALLATION CHECKS .DRINS MT NOP MOV INSCSR,R0 TSTB 2(R0) BPL 1$ MOV #1000,2(R0) BIT #1000,2(R0) BNE 1$ SEC 1$: RTS PC .SBTTL SET COMMANDS .DRSET DENSE, NOP, O.DENS, NUM .DRSET DUMP, NOP, O.DUMP, NO .DRSET ODDPAR, PEVN, O.PAR, NO .DRSET DEFALT, NOP, O.DFLT, NUM .DRSET CSR, 160000, O.CSR, OCT .DRSET VECTOR, 500, O.VEC, OCT .DRSET RETRY, 127., O.RTRY, NUM O.DENS: CLR R3 CMP #200.,R0 BEQ DENS1 CMP #556.,R0 BEQ 1$ CMP #807.,R0 BEQ 2$ CMP #809.,R0 BEQ 3$ CMP #800.,R0 BEQ 3$ SEC RTS PC 1$: BIS #D7$556,R3 BR DENS1 2$: BIS #D7$800,R3 BR DENS1 3$: BIS #D9$800,R3 DENS1: BIC #D9$800,DENSE BIS R3,DENSE DENS3: CLC RTS PC O.DUMP: CLR R3 BR 1$ BR DFLT1 1$: BIS #D7$CORE,R3 BR DENS1 O.PAR: BR ODD NOP BIS R3,DENSE BR DENS3 ODD: BIC R3,DENSE BR DENS3 .ENABL LSB O.DFLT: CMP #7,R0 BEQ 7$ CMP #9.,R0 BEQ 9$ DFLT1: SEC RTS PC 9$: MOV #D9$800,DENSE BR DENS3 7$: MOV #D7$CORE,DENSE BR DENS3 .DSABL LSB O.CSR: CMP R0,R3 BLO O.BAD MOV R0,INSCSR MOV R0,DISCSR .ADDR #MTS,R1 MOV #NREGS,R2 10$: MOV R0,(R1)+ ADD #2,R0 DEC R2 BGT 10$ O.GOOD: TST (PC)+ O.BAD: SEC RETURN O.VEC: CMP R0,R3 BHIS O.BAD MOV R0,MTSTRT BR O.GOOD O.RTRY: CMP R0,R3 BHI O.BAD MOV R0,RTRYCT BEQ O.BAD BR O.GOOD .Assume . LE 1000,<;SET area overflow> .SBTTL Handler Entry Point .IF NE MT$FSM .GLOBL FSMDIS, FSMABT, FSMDON .GLOBL FSMERR, RESTOR, CODE .GLOBL DVTBL, FSMSIZ .GLOBL MTCQE .IF NE MMG$T .GLOBL OLDBA, XBUMP, EXTADR .GLOBL JOBNM, SYNBLK, TEMP .GLOBL SINK, ERBSAV .ENDC .ENDC .DRBEG MT BR MT MTS: .WORD MT$CSR MTC: .WORD MT$CSR+2 MTBRC: .WORD MT$CSR+4 MTCMA: .WORD MT$CSR+6 MTD: .WORD MT$CSR+10 MTRD: .WORD MT$CSR+12 NREGS = <.-MTS>/2 .Assume . LE MTSTRT+1000,<;SET object not in block 1> RTRYCT: .WORD NRETRY .Assume . LE MTSTRT+1000,<;SET object not in block 1> MT: .IF NE MMG$T MOV MTCQE,R5 CMP (R5)+,(R5)+ JSR PC,@$MPPTR MOV (SP)+,OLDBA BIT #1700,@SP BEQ 10$ TST (SP)+ MOV MTCQE,R5 BIS #HDERR$,@-(R5) JMP MTDONE 10$: MOV (SP)+,EXTADR .ENDC .IF EQ MT$FSM MOV MTCQE,R3 .IFF JMP FSMDIS $MT:: .ENDC TST (R3)+ MOV @R3,R0 MOVB R0,R4 BIC #^C,R0 MOV R0,R1 SWAB R1 BIS (PC)+,R0 DENSE: .WORD D9$800 .Assume . LE MTSTRT+1000,<;SET object not in block 1> MOV R0,@MTC CLR NFSREAD MOV PC,R0 ADD #RECOVE-.,R0 MOV R1,R5 ADD PC,R5 ADD #$TBL-.,R5 MOV @R3,R2 SWAB R2 ASR R2 ASR R2 ASR R2 BIC #177740,R2 .IF NE MMG$T MOVB R2,JOBNM .ENDC CMP #LOOKUP,R4 BNE 7$ .FOO = 0 .IF NE MMG$T .IF EQ MT$FSM .FOO = 1 MOV MTCQE,R4 JSR PC,@$GTBYT TSTB (SP)+ BNE 5$ JSR PC,@$GTBYT TSTB (SP)+ BNE 5$ .ENDC .ENDC .IF EQ .FOO TST @2(R3) BNE 11$ .ENDC CMPB #-1,@R5 BEQ 3$ .IF EQ MT$FSM MOV #DEVINUSE,R0 2$: MOV @#SYSPTR,R1 MOV R0,SPUSR(R1) BR 12$ .IFF MOV @#SYSPTR,R1 MOV #DEVINUSE,SPUSR(R1) JSR PC,RESTOR JMP $DONE .ENDC 3$: CLR 4(R3) MOVB R2,@R5 .IF NE MT$FSM BR 12$ .IFF 4$: MOV -2(R3),R1 BEQ 6$ BGT 5$ INC R1 BEQ 12$ 5$: MOVB #-1,@R5 MOV #ILLARG,R0 BR 2$ 6$: MOV #REWIND,R4 BR 8$ .ENDC 7$: CMP #CLOSE,R4 BNE 8$ MOVB #-1,@R5 BR 12$ 8$: MOV (PC)+,(R0)+ .BYTE -1,ERRGAPS TST (R0)+ CMP #STR100,R4 BEQ 12$ CMP #READF,R4 BLOS 13$ TST R4 BNE 11$ MOV R3,R1 CLR -2(R1) CMP (R1)+,(R1)+ MOV #READF,R4 TST @R1 BPL 9$ NEG @R1 INC R4 BR 10$ 9$: COM NFSREAD 10$: .IF NE MT$FSM MOV R4,CODE .ENDC BR 13$ 11$: TST -(R3) BIS #HDERR$,@-(R3) 12$: .IF NE MT$FSM JSR PC,RESTOR .ENDC JMP MTDONE 13$: ADD #FUNTAB-TABLE,R4 MOV R4,(R0)+ .IF NE MMG$T MOV 4(R3),R1 MOV R1,4(R0) .IFF TST (R3)+ MOV (R3)+,(R0)+ MOV @R3,@R0 MOV @R3,R1 .ENDC NEG R1 JSR PC,DISPAT TABLE: .BYTE REDEF-TABLE .BYTE RIGHT-TABLE .BYTE AWFLINE-TABLE .BYTE REWHINED-TABLE .BYTE RIGHTX-TABLE .BYTE BAKSPA-TABLE .BYTE FORSPA-TABLE .BYTE RIGHTM-TABLE FUNTAB: .BYTE FREAD+INTENB+GO .BYTE FWRITE+INTENB+GO .BYTE FOFF+INTENB+GO .BYTE FREWIND+INTENB+GO .BYTE FWRTEXT+INTENB+GO .BYTE FSPBAK+INTENB+GO .BYTE FSPFOR+INTENB+GO .BYTE FWRTTM+INTENB+GO REDEF: RIGHTX: RIGHT: .IF NE MMG$T MOV (R0)+,@MTCMA BIS @R0,R5 .IFF MOV -(R3),@MTCMA .ENDC ASL R1 FORSPA: BAKSPA: MOV R1,@MTBRC AWFLINE: REWHINED: RIGHTM: MOVB R5,@MTC .IF NE MT$FSM JSR PC,RESTOR .ENDC RTS PC .SBTTL INTERRUPT HANDLER AND ABORT ENTRY POINTS MTABRT: MOVB #-1,$FLG MOV R3,-(SP) MOV PC,R5 ADD #$TBL-.,R5 MOV MTCQE,R3 BEQ 7$ MOVB Q$JNUM(R3),-(SP);GET JOB NUMBER MOVB (SP)+,R3 ASR R3 ASR R3 ASR R3 BIC #177740,R3 CMP R3,R4 BNE 7$ CLRB $FLG MOV #PWRCLR,@MTC 5$: .IF NE MT$FSM MOV R0,-(SP) MOV DVTBL,R0 BEQ 6$ MOV #-1,(R0)+ MOV #-1,@R0 6$: MOV (SP)+,R0 .ENDC 7$: CMPB R4,@R5 BNE 10$ MOVB #-1,@R5 10$: CMPB #-2,(R5)+ BNE 7$ MOV (SP)+,R3 JMP $DONE .SBTTL INTERRUPT ENTRY POINT .DRAST MT,5,MTABRT .SBTTL ERROR-ERROR ROUTINE DISPATCHER TST MTCQE BNE 114$ JMP $RTS 114$: TST @MTC BMI 1$ .IF NE MMG$T JMP NOERR .IFF BR NOERR .ENDC 1$: MOV @MTS,R4 BPL 2$ BIT #SELR,R4 BNE 2$ MOV #DRIVEGONE,R4 BR ABORT 2$: MOV LASTCOM,R4 JSR PC,DISPAT TABLEE: .BYTE ERREAD-TABLEE .BYTE ERWRIT-TABLEE .BYTE EROFFL-TABLEE .BYTE ERREWD-TABLEE .BYTE ERWRTX-TABLEE .BYTE ERBKSP-TABLEE .BYTE ERFWSP-TABLEE .BYTE ERWRTM-TABLEE .SBTTL ERROR-WRITE OR WRITE WITH EXTENDED GAP COMMAND WAS ISSUED LAST AND ERR BIT WAS SET. .ENABL LSB ERWRIT: ERWRTX: BIT #WRL,@MTS BEQ 1$ ERWRI1: MOV #WRITELOK,R4 BR ABORT 1$: JSR PC,ABOCHK MOV R5,ERRSUM BNE CONT BIT #EOT,R4 BNE NOERR BR NQUAL .DSABL LSB .SBTTL ERROR-WRITE TM,FORWARD SPACE, OR BACKSPACE COMMAND GIVEN LAST AND ERR BIT SET ERWRTM: BIT #WRL,@MTS BNE ERWRI1 ERBKSP: ERFWSP: JSR PC,ABOCHK BIT #EOF+EOT,R4 BNE NOERR BR NQUAL .SBTTL ERROR-READ COMMAND WAS ISSUED LAST AND ERR BIT WAS SET. ERREAD: JSR PC,ABOCHK MOV R5,ERRSUM BNE CONT BIT #RLE+EOT+EOF,R4 BNE NOERR BR NQUAL .SBTTL ERROR-ABORT CHECK SUBROUTINE ABOCHK: MOV @MTS,R4 BIT #BTEOPI,R4 BEQ 1$ MOV #POSERR,R4 BR 4$ 1$: BIT #NXM,R4 BEQ 2$ MOV #MEMERR,R4 4$: TST (SP)+ BR ABORT 2$: CLR R5 BIT #CRE+PAE+BGL,R4 BEQ 3$ COM R5 3$: RTS PC .SBTTL ERROR-ABORT OPERATION IN PROGRESS ERREWD: EROFFL: NQUAL: CLR R4 ABORT: MOV #PWRCLR,@MTC MOV #HDERR$,-(SP) EXCEP: .IF NE MT$FSM MOV (SP)+,R5 JMP FSMERR .IFF MOV MTCQE,R5 BIS (SP)+,@Q$CSW(R5) TST @R5 BEQ MTDONE .IF NE MMG$T COM SINK MOV @R5,ERBSAV MOV R4,TEMP MOVB Q$JNUM(R5),R5 ASR R5 ASR R5 ASR R5 MOV R5,JOBNM .IFF MOV R4,@(R5)+ .ENDC .IFTF MTDONE: .IFT JMP FSMDON .ENDC $DONE:: TSTB $FLG BNE $RTS .IF NE MMG$T MOV PC,R4 ADD #MTCQE-.,R4 MOV @#SYSPTR,R5 TST SINK BNE 1$ JMP @QCOMP(R5) 1$: CLR SINK JSR PC,@QCOMP(R5) MOV PC,R4 ADD #SYNBLK-.,R4 .SYNCH BR BADSYN MOV ERBSAV,R1 BIS #30000,@#177776 MOV R0,-(SP) MTPI (R1)+ MOV ERRBL2,-(SP) MTPI (R1)+ BADSYN: RTS PC .IFF .DRFIN MT .ENDC $RTS: CLRB $FLG RTS PC .SBTTL STATUS REPORT COME HERE IF NO ABORTS ISSUED NOERR: CLR ERRSUM CONT: TSTB RECOVERY BPL RECOVR PTCH: MOV @MTS,R4 MOV LASTCOM,R5 TST ERRSUM BEQ NEXT0 CMP #FN+READF,R5 BNE 1$ MOVB #5,BACK1 MOVB RTRYCT,BACK5 BR 2$ 1$: MOV #FN+WRTXTD,R5 2$: MOVB R5,RECOVERY BR REEDF1 NEXT0: CMP #FN+REWIND,R5 BNE NEXT1 BIT #BOT,R4 BNE REWHYN MOVB R5,RECOVERY RTS PC NEXT1: CMP #FN+READF,LASTCOM BNE NEXT2 BIT #EOF,R4 BNE NEXT3 BIT #RLE,R4 BEQ 1$ MOV #RECERR,R4 BR ABORT 1$: MOV @MTBRC,R5 BEQ NEXT2 ASR R5 NEG R5 .IF NE MMG$T MOV R5,ERRBL2 .IFF .IF NE MT$FSM MOV @MTCQ,R4 .IFF MOV @MTCQE,R4 .ENDC BEQ 2$ MOV R5,2(R4) .ENDC 2$: MOV #SMLREC,R4 .IF NE MMG$T JMP ABORT .IFF BR ABORT .ENDC NEXT2: CMP #FN+FWDSPC,LASTCOM BEQ 1$ CMP #FN+BKSPC,LASTCOM BNE NEXT3 1$: MOV @MTBRC,R4 BEQ NEXT3 .IF NE MMG$T MOV R4,ERRBL2 .IFF NEG R4 .IF NE MT$FSM MOV @MTCQ,R5 .IFF MOV @MTCQE,R5 .ENDC BEQ 2$ MOV R4,2(R5) .ENDC 2$: .ENABL LSB NEXT3: MOV @MTS,R5 CLR R4 BIT #BOT,R5 BEQ 1$ CMP #FN+REWIND,LASTCOM MTD1: BEQ MTDONE CMP #FN+OFFLINE,LASTCOM BEQ MTDONE CMP (R4)+,(R4)+ BR 4$ 1$: BIT #EOF,R5 BEQ 2$ CMP #FN+WRTEOF,LASTCOM BEQ 2$ INC R4 2$: BIT #EOT,R5 BEQ 3$ TST NFSREAD BNE 3$ CMPB (R4)+,(R4)+ 3$: TST R4 BEQ MTD1 4$: MOV #EOF$,-(SP) JMP EXCEP .DSABL LSB .SBTTL RECOVERY IN PROGRESS DISPATCHER RECOVR: MOV LASTCOM,R4 JSR PC,DISPAT TABLER: .BYTE REEDF-TABLER .BYTE RITE-TABLER .BYTE 0 .BYTE REWHYN-TABLER .BYTE RITEX-TABLER .BYTE BACH-TABLER .BYTE FORE-TABLER .BYTE 0 .SBTTL RECOVERY-WRITE WAS LAST COMMAND RITEX: RITE: TST ERRSUM BEQ NEXT1 INCB TAPELEN BEQ NQ2 BIT #EOT,@MTS BEQ REEDF1 NQ2: JMP NQUAL .SBTTL RECOVERY-REWIND WAS THE LAST COMMAND REWHYN: MOV #PWRCLR,@MTC JMP MTDONE .SBTTL RECOVERY-READ WAS THE LAST COMMAND ISSUED .ENABL LSB REEDF: TST ERRSUM BEQ FOO DECB BACK1 BEQ 2$ BGT REEDF1 MOVB #5,BACK1 DECB BACK5 BEQ NQ2 REEDF1: MOV #-1,R5 BR 3$ 2$: MOV #-5,R5 3$: MOV R5,@MTBRC BR BACH2 FOO: JMP PTCH .DSABL LSB .SBTTL RECOVERY-FORWARD SPACE WAS THE LAST COMMAND FORE: MOV @MTBRC,R5 BNE BACH1 FORE1: MOV MTCMA,R5 MOV OLDBA,@R5 MOV OLDWC,-(R5) ASL @R5 NEG @R5 MOV #FN+READF,R4 MOVB FUNTAB,R5 BR BACH3 .SBTTL RECOVERY-BACKSPACE WAS LAST COMMAND .ENABL LSB BACH: CMPB #FN+READF,RECOVERY BEQ 1$ MOV OLDWC,R4 ASL R4 NEG R4 MOV R4,@MTBRC MOV OLDBA,@MTCMA MOV #FN+WRTXTD,R4 MOVB FUNTAB+4,R5 BR 4$ 1$: MOV @MTBRC,R5 BEQ 6$ BIT #BOT,@MTS BEQ 5$ 2$: ADD #4,R5 BEQ FORE1 3$: NEG R5 BACH1: MOV R5,@MTBRC MOV #FN+FWDSPC,R4 MOVB FUNTAB+6,R5 BACH3: 4$: MOV R4,LASTCOM .IIF NE MMG$T, BIS EXTADR,R5 MOVB R5,@MTC RTS PC BACH2: 5$: MOV #FN+BKSPC,R4 MOVB FUNTAB+5,R5 BR 4$ 6$: TSTB BACK1 BEQ 2$ BR FORE1 .DSABL LSB .SBTTL XBUMP SUBROUTINE .IF NE MMG$T XBUMP: MOV MTCQE,-(SP) ADD #Q$PAR,@SP ADD #10,@(SP)+ ADD #512.,OLDBA BCC 1$ ADD #20,EXTADR 1$: RTS PC .ENDC .SBTTL DISPATCH SUBROUTINE DISPAT: ADD @SP,R4 MOVB FUNTAB-TABLE(R4),R5 MOVB @R4,R4 ADD (SP)+,R4 JMP @R4 .SBTTL MAGTAPE DATA AREA $TBL: .REPT MT$UN .BYTE -1 .ENDR .BYTE -2 $FLG: .BYTE 0 .EVEN RECOVE: .BYTE -1 TAPELE: .BYTE ERRGAPS BACK5: .BYTE 0 BACK1: .BYTE 0 LASTCO: .WORD 0 OLDBA: .WORD 0 .IIF NE MMG$T, EXTADR: .WORD 0 OLDWC: .WORD 0 ERRSUM: .WORD 0 NFSREA: .WORD 0 .EVEN .IF NE MMG$T SYNBLK: .WORD 0 JOBNM: .WORD 0 .WORD 0,0 TEMP: .WORD 0 .WORD -1,0 SINK: .WORD 0 ERBSAV: .WORD 0 ERRBL2: .WORD 0 .ENDC .IF NE MT$FSM MTCQ:: .WORD 0 DRIVEN==MT$UN DVINFO::.REPT DRIVEN .WORD -1 .WORD -1 .WORD -1 .BYTE 0 .BYTE 0 .WORD 0,0,0 .ENDR .ENDC .IF EQ MT$FSM .DREND MT .IFF .GLOBL $FKPTR,$INPTR .IIF NE MMG$T, .GLOBL $RLPTR,$MPPTR,$GTBYT,$PTBYT,$PTWRD .IIF NE ERL$G, .GLOBL $ELPTR .IIF NE TIM$IT, .GLOBL $TIMIT .ENDC SIZE=. SIZED=SIZE-MTSTRT/2 .END .MCALL .MODULE .MODULE TS,VERSION=18,COMMENT=,AUDIT=NO ; COPYRIGHT (c) 1987 BY ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. ; ALL RIGHTS RESERVED. ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED ; ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE ; INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER ; COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY ; OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY ; TRANSFERRED. ; ; THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE ; AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT ; CORPORATION. ; ; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS ; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL. .SBTTL EDIT HISTORY .SBTTL CONDITIONAL ASSEMBLY SUMMARY .IIF NDF MS$FSM MS$FSM = 0 .IIF NDF MS$UN MS$UN = 1 .IIF NDF MS$CS1 MS$CS1 = 772526 MS$DB1 = MS$CS1-2 .IIF NDF MS$CS2 MS$CS2 = 772532 MS$DB2 = MS$CS2-2 .IIF NDF MS$CS3 MS$CS3 = 772536 MS$DB3 = MS$CS3-2 .IIF NDF MS$CS4 MS$CS4 = 772542 MS$DB4 = MS$CS4-2 .IIF NDF MS$CS5 MS$CS5 = 772546 MS$DB5 = MS$CS5-2 .IIF NDF MS$CS6 MS$CS6 = 772552 MS$DB6 = MS$CS6-2 .IIF NDF MS$CS7 MS$CS7 = 772556 MS$DB7 = MS$CS7-2 .IIF NDF MS$VC1 MS$VC1 = 300 .IIF NDF MS$VC2 MS$VC2 = 304 .IIF NDF MS$VC3 MS$VC3 = 310 .IIF NDF MS$VC4 MS$VC4 = 314 .IIF NDF MS$VC5 MS$VC5 = 320 .IIF NDF MS$VC6 MS$VC6 = 324 .IIF NDF MS$VC7 MS$VC7 = 330 .SBTTL Notes on handler .SBTTL Definitions SYSPTR = 54 QCOMP = 270 SPUSR = 272 CONFG2 = 370 BUS$ = 100 .MCALL .MTPS, .MFPS, .DRDEF .MCALL .SYNCH, .BR, .ADDR .ASSUME .DRDEF MS,35,,0,772522,224 MS$DB == MS$CSR-2 .DRPTR .DREST CLASS=DVC.MT .DRSPF <-1> .DRSPF <-2> .DRSPF <-3> .DRSPF <-4> .DRSPF <-5> .DRSPF <-6> .DRSPF <-7> .DRSPF <-8.> .DRSPF <-9.> .IIF NE MS$FSM .DRSPF <-20.> .IIF EQ MS$FSM .FSM = 100000 .AUDIT .TS .AUDIT .FSM RENAME = 5 ENTER = 4 LOOKUP = 3 DELETE = 2 CLOSE = 1 REDWRT = 0 WRTEOF = -1 FWDSPC = -2 BKSPC = -3 WRTXTD = -4 REWIND = -5 OFFLINE = -6 WRITEPHY= -7 READF = -8. STR100 = -9. FN = 8. ILLARG = 5 DEVINUSE= 2 ERRGAPS = -101. FL$RE1 = 000001 FL$RE2 = 000002 FL$RC0 = 000004 FL$RC1 = 000010 FL$CIP = 000100 NOQUAL = 0 DRIVEGONE = 1 POSERR = 2 MEMERR = 3 WRITELOK= 4 RECERR = 5 SMLREC = 6 EOFCODE = 1 EOTCODE = 2 EOFEOT = 3 BOTCODE = 4 TB$JOB = 0 TB$TSR = 2 TB$CBR = 4 TB$FLG = 6 JOBMK = 174000 UNITMK = 003400 DUMMY = 0 MSDSIZE = 0 V.TRP4 = 4 LKCS = 177546 SR = 177570 NRETRY = 8. .IF NE MS$FSM .GLOBL FSMDIS,FSMABT,FSMDON,FSMERR,RESTOR,CODE,DVTBL,FSMSIZ .GLOBL MTCQ .IF NE MMG$T .GLOBL OLDBA,XBUMP,EXTADR,JOBNM,SYNBLK,TEMP,SINK,ERBSAV .ENDC .ENDC .MACRO TBLINT V,C .WORD -1 .WORD V .WORD C .WORD 0 .ENDM TBLINT .MACRO REIS MOV R3,-(SP) MOV R2,-(SP) MOV $CBUF,R3 MOV PC,R2 ADD #$SCB+2-.,R2 .ENDM REIS .MACRO RESET MOV $CBUF,R3 .MFPS .MTPS #340 CMP (R5)+,(R5)+ MOV R3,@(R5)+ BIS #FL$CIP,@R5 .MTPS MOV (SP)+,R2 MOV (SP)+,R3 MOV SPTMP,SP RETURN .ENDM RESET .SBTTL BIT DEFINITIONS TSXSR0 = 6 TSXSR1 = 10 TSXSR2 = 12 TSXSR3 = 14 TSSRC = 16 MG.ACK = 100000 MG.FMT = 000340 MG.COD = 000037 MC.END = 020 MC.FAL = 021 MC.ERR = 022 MC.ATN = 023 X0.TMK = 100000 X0.RLS = 040000 X0.LET = 020000 X0.RLL = 010000 X0.WLE = 004000 X0.NEF = 002000 X0.ILC = 001000 X0.ILA = 000400 X0.MOT = 000200 X0.ONL = 000100 X0.IE = 000040 X0.VCK = 000020 X0.PED = 000010 X0.WLK = 000004 X0.BOT = 000002 X0.EOT = 000001 X1.DLT = 100000 X1.COR = 020000 X1.CRS = 010000 X1.TIG = 004000 X1.DBF = 002000 X1.NZO = 002000 X1.SCK = 001000 X1.IPR = 000200 X1.SYN = 000100 X1.DRP = 000100 X1.IPO = 000040 X1.ITM = 000040 X1.IED = 000020 X1.LC0 = 000020 X1.POS = 000010 X1.NZN = 000010 X1.POL = 000004 X1.LRC = 000004 X1.UNC = 000002 X1.CRC = 000002 X1.MTE = 000001 X1.VPE = 000001 X2.OPM = 100000 X2.SIP = 040000 X2.BPE = 020000 X2.CAF = 010000 X2.WCF = 002000 X2.XSK = 001000 X2.DTK = 000777 X3.FEC = 177400 X3.LMX = 000200 X3.OPI = 000100 X3.REV = 000040 X3.CRF = 000020 X3.DCK = 000010 X3.NOI = 000004 X3.SGP = 000002 X3.RIB = 000001 SR.SC = 100000 SR.UPE = 040000 SR.SPE = 020000 SR.RMR = 010000 SR.NXM = 004000 SR.NBA = 002000 SR.A17 = 001000 SR.A16 = 000400 SR.SSR = 000200 SR.OFL = 000100 SR.FC1 = 000040 SR.FC0 = 000020 SR.TC2 = 000010 SR.TC1 = 000004 SR.TC0 = 000002 SR.TCN = SR.BAD = CM.ACK = 100000 CM.CVC = 040000 CM.OPP = 020000 CM.SWB = 010000 CM.MOD = 007400 CM.RTY = 001000 CM.RVS = 000400 CM.IE = 000200 CM.COD = 000037 CM.LOW = 000003 CM.NML = CC.RDN = <0001!CM.NML> CC.RDP = <0401!CM.NML> CC.RRP = <1001!CM.NML> CC.RRN = <1401!CM.NML> CC.WRC = <0004!CM.ACK!CM.CVC> CC.WRD = <0005!CM.NML> CC.WDR = <1005!CM.NML> CC.WSM = <0006!CM.NML> CC.SRF = <0010!CM.NML> CC.SRR = <0410!CM.NML!CM.CVC> CC.STF = <1010!CM.NML> CC.STR = <1410!CM.NML> CC.RWD = <2010!CM.NML!CM.CVC> CC.WTM = <0011!CM.NML> CC.ERS = <0411!CM.NML> CC.WTR = <1011!CM.NML> CC.BRL = <0012!CM.ACK> CC.UNL = <0412!CM.NML!CM.CVC> CC.DRI = <0013!CM.NML> CC.GST = <0017!CM.ACK> CC.MST = CH.ESS = 000200 CH.EAI = 000040 CH.ERI = 000020 CH.HSP = 000040 CB$CHR = 0 .SBTTL Installation code .IF EQ MS$UN-1 .DRINS MS .IFF .IF EQ MS$UN-2 .DRINS MS, .IFF .IF EQ MS$UN-3 .DRINS MS, .IFF .IF EQ MS$UN-4 .DRINS MS, .IFF .IF EQ MS$UN-5 .DRINS MS, .IFF .IF EQ MS$UN-6 .DRINS MS, .IFF .IF EQ MS$UN-7 .DRINS MS, .IFF .DRINS MS, .ENDC .ENDC .ENDC .ENDC .ENDC .ENDC .ENDC .Assume . LE 400,<;INSTALL area overflow> .SBTTL Set code .DRSET CSR, <0*2+1>, O.CSR, OCT .DRSET VECTOR, <0*2+1>, O.VEC, OCT .IF GE MS$UN-2 .DRSET CSR2, <1*2+1>, O.CSR, OCT .DRSET VEC2, <1*2+1>, O.VEC, OCT .IF GE MS$UN-3 .DRSET CSR3, <2*2+1>, O.CSR, OCT .DRSET VEC3, <2*2+1>, O.VEC, OCT .IF GE MS$UN-4 .DRSET CSR4, <3*2+1>, O.CSR, OCT .DRSET VEC4, <3*2+1>, O.VEC, OCT .IF GE MS$UN-5 .DRSET CSR5, <4*2+1>, O.CSR, OCT .DRSET VEC5, <4*2+1>, O.VEC, OCT .IF GE MS$UN-6 .DRSET CSR6, <5*2+1>, O.CSR, OCT .DRSET VEC6, <5*2+1>, O.VEC, OCT .IF GE MS$UN-7 .DRSET CSR7, <6*2+1>, O.CSR, OCT .DRSET VEC7, <6*2+1>, O.VEC, OCT .IF GE MS$UN-8. .DRSET CSR8, <7*2+1>, O.CSR, OCT .DRSET VEC8, <7*2+1>, O.VEC, OCT .ENDC .ENDC .ENDC .ENDC .ENDC .ENDC .ENDC .DRSET RETRY, 127., O.RTRY, NUM O.CSR: CMP R0,#160002 BLO O.BAD DEC R3 BNE 10$ MOV R0,INSCSR 10$: MOV R3,R1 NEG R1 .ADDR #DISCSR,R1,ADD MOV R0,(R1) ASL R3 ASL R3 .ADDR #$ADRTB,R3,ADD MOV R0,TB$TSR(R3) SUB #2,R0 MOV R0,TB$CBR(R3) O.GOOD: TST (PC)+ O.BAD: SEC RETURN O.VEC: CMP R0,#500 BHIS O.BAD .IF GT MS$UN-1 DEC R3 MOV R3,-(SP) ASL R3 ADD (SP)+,R3 .ADDR #MS$VTB,R3,ADD .IFF .ADDR #MSSTRT,R3 .ENDC MOV R0,(R3) BR O.GOOD O.RTRY: CMP R0,R3 BHI O.BAD MOV R0,RTRYCT BEQ O.BAD BR O.GOOD .Assume . LE 1000,<;SET area overflow> .SBTTL Handler Entry Point .DRBEG MS JMP MS .SBTTL Controller Impure Data Area $ADRTB: TBLINT MS$CSR,MS$DB .IF GE MS$UN-2 TBLINT MS$CS1,MS$DB1 .IF GE MS$UN-3 TBLINT MS$CS2,MS$DB2 .IF GE MS$UN-4 TBLINT MS$CS3,MS$DB3 .IF GE MS$UN-5 TBLINT MS$CS4,MS$DB4 .IF GE MS$UN-6 TBLINT MS$CS5,MS$DB5 .IF GE MS$UN-7 TBLINT MS$CS6,MS$DB6 .IF GE MS$UN-8. TBLINT MS$CS7,MS$DB7 .ENDC .ENDC .ENDC .ENDC .ENDC .ENDC .ENDC .Assume . LE MSSTRT+1000,<;SET object not in block 1> .WORD -2 .IF GT MS$UN-1 .DRVTB MS,MS$VEC,MSINT .DRVTB ,MS$VC1,MSINT .IIF GT MS$UN-2 .DRVTB ,MS$VC2,MSINT .IIF GT MS$UN-3 .DRVTB ,MS$VC3,MSINT .IIF GT MS$UN-4 .DRVTB ,MS$VC4,MSINT .IIF GT MS$UN-5 .DRVTB ,MS$VC5,MSINT .IIF GT MS$UN-6 .DRVTB ,MS$VC6,MSINT .IIF GT MS$UN-7 .DRVTB ,MS$VC7,MSINT .ENDC .Assume . LE MSSTRT+1000,<;SET object not in block 1> RTRYCT: .WORD NRETRY .Assume . LE MSSTRT+1000,<;SET object not in block 1> .SBTTL I/O Initialization MS:: .IF NE MMG$T MOV MSCQE,R5 MOV Q$BUFF(R5),(PC)+ SPFBUF: .WORD 0 MOV Q$PAR(R5),(PC)+ SPFPAR: .WORD 0 CMP (R5)+,(R5)+ CALL @$MPPTR MOV (SP)+,OLDBA BIT #1700,@SP BEQ 10$ MOV @#SYSPTR,R5 BIT #,CONFG2(R5) BNE 10$ TST (SP)+ MOV MSCQE,R5 BIS #HDERR$,@-(R5) CALLR MSDONE 10$: ASR @SP ASR @SP ASR @SP ASR @SP MOV (SP)+,EXTADR .ENDC .IF EQ MS$FSM MOV MSCQE,R3 .IFF CALLR FSMDIS $MT:: .ENDC MOV SP,SPTMP TST (R3)+ MOV @R3,R1 MOVB R1,R4 BIC #^C,R1 SWAB R1 ASL R1 ASL R1 ASL R1 MOV PC,R5 ADD #$ADRTB-.,R5 ADD R1,R5 MOV @R3,R1 BIC #^C,R1 SWAB R1 .REPT 3 ASR R1 .ENDR .IF NE MMG$T MOV R1,JOBNM .ENDC CLR NFSREAD MOV PC,R0 ADD #BF1-.,R0 BIT #2,R0 BEQ 20$ TST (R0)+ 20$: MOV R0,(PC)+ $CBUF: .WORD 0 MOV PC,R0 ADD #BF2-.,R0 MOV R0,(PC)+ $MBUF: .WORD 0 AJA: TST TS05 BPL 98$ CLR TS05 CMP #<-1>,16(R0) BEQ 98$ BIS #,TS05 98$: CMP R1,(PC)+ LASTIM: .WORD -1 BEQ 99$ MOV R1,LASTIM BIS #GETSTA,TS05 CALL $SCHR 13$: TSTB @TB$TSR(R5) BPL 13$ MOV #<-1>,16(R0) MOV R1,-(SP) MOV $CBUF,R1 MOV #,@R1 MOV R1,@TB$CBR(R5) 14$: TSTB @TB$TSR(R5) BPL 14$ MOV (SP)+,R1 BR AJA 99$: CMP #CLOSE,R4 BEQ 35$ 5$: CMP #LOOKUP,R4 BNE 40$ .IF NE MMG$T .IF EQ MS$FSM MOV MSCQE,R4 CALL @$GTBYT TSTB (SP)+ BNE 25$ CALL @$GTBYT TSTB (SP)+ BNE 25$ .IFF TST @2(R3) BNE 55$ .ENDC .ENDC CMP @R5,#-1 BEQ 15$ MOV #DEVINUSE,R0 10$: MOV @#SYSPTR,R1 MOV R0,SPUSR(R1) .IF NE MS$FSM CALL RESTOR CALLR $DONE .IFF BR 60$ .ENDC 15$: CLR 4(R3) MOV R1,@R5 TST FBDT BNE 20$ INC FBDT BIC #,TS05 CALL $SCHR 20$: .IF NE MS$FSM BR 60$ .IFF MOV -2(R3),R1 BEQ 30$ BGT 25$ INC R1 BEQ 60$ 25$: MOV #-1,@R5 MOV #ILLARG,R0 BR 10$ 30$: MOV #REWIND,R4 BR 40$ .ENDC 35$: MOV #<-1>,@R5 BIT #,TS05 BEQ 60$ BIC #,TS05 CALL $SCHR BR 60$ 40$: MOV PC,R0 ADD #LASTCOM-.,R0 MOVB #ERRGAPS,TAPELEN CMP #,R4 BNE 43$ BIT #,TS05 BEQ 60$ CALL STREAM BR 60$ 43$: CMP #READF,R4 BLOS 65$ TST R4 BNE 55$ MOV R3,R1 CLR -2(R1) CMP (R1)+,(R1)+ MOV #READF,R4 TST @R1 BPL 45$ NEG @R1 INC R4 BR 50$ 45$: COM NFSREAD 50$: .IF NE MS$FSM MOV R4,CODE .ENDC BR 65$ 55$: TST -(R3) BIS #HDERR$,@-(R3) 60$: .IF NE MS$FSM CALL RESTOR .ENDC CALLR MSDONE 65$: ADD #FUNTAB-TABLE,R4 MOV R4,(R0)+ .IF NE MMG$T MOV 4(R3),R1 TST (R0)+ .IFF TST (R3)+ MOV (R3)+,(R0)+ MOV @R3,R1 .ENDC MOV $CBUF,R2 CALL DISPAT TABLE: .BYTE REDEF-TABLE .BYTE WRIT-TABLE .BYTE OFFLN-TABLE .BYTE RWND-TABLE .BYTE WRITX-TABLE .BYTE BCKSPC-TABLE .BYTE FRSPC-TABLE .BYTE WRITM-TABLE FUNTAB: .WORD CC.RDN .WORD CC.WRD .WORD CC.UNL .WORD CC.RWD .WORD CC.WRD .WORD CC.SRR .WORD CC.SRF .WORD CC.WTM WRITX: WRIT: REDEF: .IF NE MMG$T MOV OLDBA,(R2)+ MOV EXTADR,(R2)+ .IFF MOV -2(R3),(R2)+ CLR (R2)+ .ENDC ASL R1 BCKSPC: FRSPC: MOV R1,(R2)+ OFFLN: RWND: WRITM: GSTAT: MOV $CBUF,R2 CALL $DUP 5$: TSTB @TB$TSR(R5) BPL 5$ .MFPS .MTPS #340 CMP (R5)+,(R5)+ BIS #FL$CIP,2(R5) MOV R2,@(R5) .MTPS .IF NE MS$FSM CALL RESTOR .ENDC RETURN .SBTTL DISPATCHER ROUTINE DISPAT: ASL R4 ADD @SP,R4 MOV FUNTAB-TABLE(R4),(R2)+ MOV -4(R0),R4 ADD @SP,R4 MOVB @R4,R4 ADD (SP)+,R4 CALLR @R4 .SBTTL ABORT ENTRY POINT .ENABL LSB MSABRT: MOVB #<-1>,MSFL MOV R3,-(SP) MOV MSCQE,R3 BEQ 5$ MOV Q$FUNC(R3),R3 BIC #^C,R3 SWAB R3 .REPT 3 ASR R3 .ENDR CMP R3,R4 BNE 5$ CLRB MSFL .IF NE MS$FSM MOV DVTBL,R5 BEQ 5$ MOV #<-1>,@R5 MOV (R5)+,@R5 .ENDC 5$: MOV PC,R5 ADD #<$ADRTB-.-10>,R5 10$: CMP (R5)+,(R5)+ CMP (R5)+,(R5)+ CMP R4,@R5 BNE 15$ CLR @TB$TSR(R5) MOV #<-1>,@R5 CLR TB$FLG(R5) 15$: CMP #<-2>,@R5 BNE 10$ MOV (SP)+,R3 BIT #,TS05 BEQ 20$ BIC #,TS05 CALL $SCHR 20$: CALLR $DONE .DSABL LSB .SBTTL INTERRUPT ENTRY POINT .DRAST MS,5,MSABRT MOV SVTB,R5 MOV SP,SPTMP MOV @TB$TSR(R5),R4 BIC #^C,R4 TST (R4)+ ADD PC,R4 ADD @R4,PC ERJTBL: .IRPC X,<01234567> .WORD TCL'X'ER-ERJTBL .ENDM .SBTTL TERMINATION CLASS ROUTINES TCL0ER:BIC FL$CIP,TB$FLG(R5) BIT #FL$RC1,TB$FLG(R5) BEQ 5$ CALL REC1CH 5$: MOV $MBUF,-(SP) ADD #TSXSR0,@SP BIT #X0.EOT,@(SP)+ BNE TCL2ER 10$: CALLR MSDONE TCL1ER: BIT #FL$CIP,TB$FLG(R5) BNE 5$ RETURN 5$: BIC #FL$CIP,TB$FLG(R5) .FORK TSFBLK .IF NE MS$FSM MOV MSCQ,R3 CALLR $MT .IFF CALLR MS .ENDC TCL2ER: BIC #FL$CIP,TB$FLG(R5) BIT #FL$RC1,TB$FLG(R5) BEQ 5$ CALL REC1CH 5$: CLR R4 MOV $MBUF,-(SP) ADD #TSXSR0,@SP BIT #X0.BOT,@(SP) BEQ 7$ MOV #BOTCODE,R4 BR 27$ 7$: TST @(SP) BPL 15$ CMP #FN+WRTEOF,LASTCOM BNE 10$ BIS #10000,R4 BR 15$ 10$: INC R4 15$: BIT #X0.EOT,@(SP) BEQ 25$ TST NFSREAD BEQ 20$ BIS #10000,R4 BR 25$ 20$: CMPB (R4)+,(R4)+ 25$: TST R4 BEQ 45$ BIC #10000,R4 TST R4 BEQ 70$ 27$: CMP #FN+BKSPC,LASTCOM BEQ 30$ CMP #FN+FWDSPC,LASTCOM BNE 35$ 30$: SUB #2,@SP .IF NE MMG$T MOV @(SP),ERRBL2 .IFF .IF NE MS$FSM MOV @MSCQ,R5 .IFF MOV @MSCQE,R5 .ENDC BEQ 35$ MOV @(SP),2(R5) .ENDC 35$: MOV #EOF$,@SP 40$: CALLR EXCEP 45$: BIT #X0.RLL,@(SP) BEQ 50$ MOV #RECERR,R4 BR 65$ 50$: BIT #X0.RLS,@(SP) BEQ 75$ 55$: SUB #2,@SP MOV @(SP),-(SP) ASR @SP .IF NE MMG$T MOV @SP,ERRBL2 .IFF .IF NE MS$FSM MOV @MSCQ,R4 .IFF MOV @MSCQE,R4 .ENDC BEQ 60$ MOV @SP,2(R4) .ENDC 60$: TST (SP)+ MOV #SMLREC,R4 65$: CALLR ABORT 70$: CALLR MSDONE 75$: BR FATAL TCL3ER: BIC #FL$CIP,TB$FLG(R5) BIT #SR.NBA,@TB$TSR(R5) BEQ 5$ .FORK TSFBLK CALL $SCHR .IF NE MS$FSM MOV MSCQ,R3 CALLR $MT .IFF CALLR MS .ENDC 5$: BIT #SR.OFL,@TB$TSR(R5) BEQ 15$ MOV #,R4 10$: MOV #<-1>,@R5 CALLR ABORT 15$: MOV $MBUF,-(SP) ADD #TSXSR0,@SP MOV @(SP),R4 BIT #X0.BOT,R4 BEQ 100$ CMP $SCB,#CC.SRR BNE 100$ MOV (SP)+,R4 MOV $SCB+2,-(R4) CALLR TCL2ER 100$: MOV R4,@SP CLR R4 BIT #,(SP)+ BNE FATAL BIT #X0.WLE,-(SP) BEQ 20$ MOV #WRITELOK,R4 BR 10$ 20$: BR FATAL TCL4ER: BIC #FL$CIP,TB$FLG(R5) BIT #FL$RC0,TB$FLG(R5) BNE FATAL CMP #FN+WRITEPHY,LASTCOM BEQ WREC CMP #FN+WRTXTD,LASTCOM BEQ WREC CMP #FN+WRTEOF,LASTCOM BEQ WREC BIT #FL$RC1,TB$FLG(R5) BEQ 5$ CMP #FN+READF,LASTCOM BEQ RREC BR FATAL 5$: CMP #FN+READF,LASTCOM BNE FATAL BIS #FL$RC1,TB$FLG(R5) MOVB #5.,BACK1 MOVB RTRYCT,BACK5 BR RREC TCL5ER: BIC #FL$CIP,TB$FLG(R5) BIT #FL$RC1,TB$FLG(R5) BNE FATAL BIT #FL$RC0,TB$FLG(R5) BNE 5$ BIS #FL$RC0,TB$FLG(R5) MOV RTRYCT,RCNT 5$: DEC RCNT BEQ FATAL .FORK TSFBLK .IF NE MS$FSM MOV MSCQ,R3 CALLR $MT .IFF CALLR MS .ENDC TCL7ER: CLR @TB$TSR(R5) .BR FATAL FATAL: TCL6ER: CALLR NQUAL .SBTTL RECOVERY ROUTINE - WRITE .ENABL LSB WREC: BIT #FL$RC1,TB$FLG(R5) BNE 5$ MOVB #ERRGAPS,TAPELEN BIS #FL$RC1,TB$FLG(R5) 5$: INCB TAPELEN BEQ FATAL REIS CMP #FN+WRTEOF,LASTCOM BNE 10$ MOV #CC.WTR,(R3)+ BR 15$ 10$: MOV #CC.WDR,(R3)+ 15$: MOV (R2)+,(R3)+ MOV (R2)+,(R3)+ MOV (R2)+,(R3)+ RESET .DSABL LSB .SBTTL RECOVERY CODE - READ .ENABL LSB RREC: TSTB BACK1 BEQ 10$ DECB BACK1 5$: REIS MOV #CC.RRP,(R3)+ MOV (R2)+,(R3)+ MOV (R2)+,(R3)+ MOV (R2)+,(R3)+ BR 25$ 10$: TSTB BACK5 BEQ FATAL BIT #FL$RE2,TB$FLG(R5) BEQ 15$ MOVB #4.,BACK1 DECB BACK5 BIC #,TB$FLG(R5) MOV #5,BCNT BR 5$ 15$: BIT #FL$RE1,TB$FLG(R5) BNE 30$ BIS #FL$RE1,TB$FLG(R5) REIS MOV #CC.SRR,(R3)+ 20$: MOV BCNT,(R3)+ 25$: RESET 30$: REIS MOV #CC.SRF,(R3)+ BIS #FL$RE2,TB$FLG(R5) BR 20$ .DSABL LSB .ENABL LSB REC1CH: TST LASTCOM BNE 5$ BIT #,TB$FLG(R5) BEQ 5$ BR RREC 5$: CLR TB$FLG(R5) RETURN .DSABL LSB .SBTTL $SCHR - Set characteristics .ENABL LSB $SCHR: MOV R1,-(SP) MOV R5,-(SP) MOV $MBUF,R5 MOV R5,-(SP) MOV $CBUF,R1 MOV @SP,(R5)+ MOV (SP)+,2(R1) CLR (R5)+ CLR 4(R1) TST TS05 BPL 5$ MOV #16.,(R5)+ MOV #16.,6(R1) BR 10$ 5$: MOV #14.,(R5)+ MOV #14.,6(R1) 10$: CLR (R5)+ CLR @R5 BIT #,TS05 BEQ 15$ MOV #16.,6(R1) MOV #16.,-4(R5) BIS #CH.HSP,(R5)+ 15$: MOV (SP)+,R5 MOV #CC.WRC,@R1 MOV R1,@TB$CBR(R5) MOV (SP)+,R1 RETURN .DSABL LSB .ENABL LSB STREAM: MOV R1,-(SP) .IF NE MMG$T MOV SPFBUF,2(R3) MOV SPFPAR,10(R3) MOV R4,-(SP) MOV MSCQE,R4 CALL @$GTBYT MOVB (SP)+,R1 MOV (SP)+,R4 TSTB R1 .IFF MOV 2(R3),R1 TSTB @R1 .ENDC BNE 5$ BIC #,TS05 BR 10$ 5$: BIT #,TS05 BNE 15$ BIS #,TS05 10$: CALL $SCHR 15$: MOV (SP)+,R1 RETURN .DSABL LSB $DUP: MOV R5,-(SP) MOV R4,-(SP) MOV $CBUF,R5 MOV PC,R4 ADD #$SCB-.,R4 MOV (R5)+,(R4)+ MOV (R5)+,(R4)+ MOV (R5)+,(R4)+ MOV @R5,@R4 MOV (SP)+,R4 MOV (SP)+,R5 MOV R5,SVTB RETURN .SBTTL COMPLETION ROUTINES .ENABL LSB NQUAL: CLR R4 ABORT: MOV #,-(SP) BIT #,TS05 BEQ EXCEP BIC #,TS05 CALL $SCHR EXCEP: .IF NE MS$FSM MOV (SP)+,R5 MOV SPTMP,SP CALLR FSMERR .IFF MOV MSCQE,R5 BIS (SP)+,@Q$CSW(R5) TST @R5 BEQ MSDONE .IF NE MMG$T COM SINK MOV @R5,ERBSAV MOV R4,TEMP MOV Q$FUNC(R5),R5 BIC #^C,R5 SWAB R5 .REPT 3 ASR R5 .ENDR MOV R5,JOBNM .IFF MOV R4,@(R5)+ .ENDC .BR MSDONE .ENDC .DSABL LSB MSDONE: MOV SPTMP,SP .IF NE MS$FSM CALLR FSMDON .ENDC $DONE:: .IF NE MMG$T TSTB MSFL BNE $RTS MOV PC,R4 ADD #MSCQE-.,R4 MOV @#SYSPTR,R5 TST SINK BNE 10$ CALLR @QCOMP(R5) 10$: CLR SINK CALL @QCOMP(R5) MOV PC,R4 ADD #SYNBLK-.,R4 .SYNCH BR BADSYN MOV ERBSAV,R1 BIS #30000,@#177776 MOV R0,-(SP) MTPI (R1)+ MOV ERRBL2,-(SP) MTPI (R1)+ BADSYN: RETURN .IFF TSTB MSFL BNE $RTS .DRFIN MS .ENDC $RTS: CLRB MSFL RETURN .SBTTL XBUMP SUBROUTINE .IF NE MMG$T XBUMP:: MOV MSCQE,-(SP) ADD #Q$PAR,@SP ADD #10,@(SP)+ ADD #512.,OLDBA ADC EXTADR RETURN .ENDC .SBTTL MAGTAPE DATA AREA MSFL: .BYTE 0 TAPELEN:.BYTE ERRGAPS BACK5: .BYTE 0 BACK1: .BYTE 0 LASTCOM:.WORD DUMMY OLDBA: .WORD DUMMY .IF NE MMG$T EXTADR: .WORD DUMMY .ENDC NFSREAD:.WORD DUMMY SVTB: .WORD 0 SPTMP: .WORD 0 RCNT: .WORD 0 BCNT: .WORD 5 FBDT: .WORD 0 TSFBLK: .WORD 0,0,0,0 BF1: .BLKW 6 BF2: .BLKW 8. $SCB: .BLKW 4 TS05:: .WORD 0 STRTAP = 1 STRON = 2 GETSTA = 100000 .IF NE MMG$T SYNBLK: .WORD DUMMY JOBNM: .WORD DUMMY .WORD DUMMY,DUMMY TEMP: .WORD DUMMY .WORD -1,0 SINK: .WORD DUMMY ERBSAV: .WORD DUMMY ERRBL2: .WORD DUMMY .ENDC .IF EQ MS$FSM .DREND MS .IFF MTCQ: .WORD DUMMY DRIVEN == MS$UN DVINFO:: .REPT DRIVEN .WORD -1 .WORD -1 .WORD -1 .BYTE DUMMY .BYTE 0 .WORD DUMMY,DUMMY,DUMMY .ENDR MSCQ==MTCQ .GLOBL $FKPTR, $INPTR .IF NE MMG$T .GLOBL $RLPTR, $MPPTR, $GTBYT, $PTBYT, $PTWRD .ENDC .IF NE ERL$G .GLOBL $ELPTR .ENDC .IF NE TIM$IT .GLOBL $TIMIT .ENDC .ENDC SIZE = . SIZED = /2 MTDONE == MSDONE MTCQE == MSCQE MT == MS MTLQE == MSLQE MTSTRT == MSSTRT .END .MCALL .MODULE .MODULE MU,VERSION=51,COMMENT=,AUDIT=NO ; COPYRIGHT (c) 1987 BY ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. ; ALL RIGHTS RESERVED. ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED ; ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE ; INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER ; COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY ; OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY ; TRANSFERRED. ; ; THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE ; AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT ; CORPORATION. ; ; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS ; SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL. UM$MU = 1 .IIF NDF MMG$T MMG$T = 0 .IIF NDF MU$EWR MU$EWR= 0 .SBTTL Conditional Assembly Summary .SBTTL TMSCP Magtape Handler Functional Description .SBTTL Special Function Codes .SBTTL SPFUN Code 360 (-20) - TMSCP Bypass .SBTTL SPFUN Code 352 (-26) - Read/Write RT-11/TMSCP Unit Translation Table .SBTTL Explanation of Handler Conditionals .IF NE MU$FSM D.CFSN = 0 D.CBLK = 2 D.HBLK = 4 D.FTYPE = 6 D.EOT = 7 D.FNAM = 10 .ENDC .SBTTL Error Codes Returned by Magtape Operations DRVDEP = 0 UNAVIL = 1 POSLST = 2 NOMEM = 3 WRTLOC = 4 RECERR = 5 SMLREC = 6 EOFFND = 1 EOTFND = 2 EOFEOT = 3 BOTFND = 4 MAXBLK = 77777 .SBTTL TMSCP Commands .SBTTL TMSCP Specific Protocol Definitions OP.CCD =: 21 OP.FLU =: 23 OP.ERG =: 26 OP.WTM =: 44 OP.REP =: 45 MD.CSE =: 20000 MD.CDL =: 10000 MD.ERW =: 20 MD.SWP =: 4 MD.NXU =: 1 MD.RWD =: 2 MD.OBC =: 4 MD.REV =: 10 MD.UNL =: 20 MD.EXC =: 40 MD.IMM =: 100 MD.DLE =: 200 EF.SEX =: 20 EF.EOT =: 10 EF.PLS =: 4 EF.DLS =: 2 UF.CAC =: 100000 UF.WBN =: 100 UF.EWR =: 10 FM.TPE =: 5 FM.STI =: 6 FM.DEL =: 7 FM.FEL =: 10 TF.800 =: 1 TF.PE =: 2 TF.GCR =: 4 TF.BLK =: 10 ST.SUB =: 40 ST.ABO =: 2 ST.MFE =: 5 ST.CMP =: 7 ST.HST =: 11 ST.CNT =: 12 ST.FMT =: 14 ST.BOT =: 15 ST.TM =: 16 ST.RDT =: 20 ST.POL =: 21 ST.SEX =: 22 ST.LED =: 23 ST.DIA =: 37 ST.EOT =: 2000 .SBTTL TMSCP Specific Status/Event Sub-Code Values .SBTTL TMSCP Command Packet Offsets and Field Lengths P.FORM =: 40 P.SPED =: 42 P.RECC =: 14 P.TMGC =: 20 P.POS =: 34 P.TRBC =: 40 P.MEDI =: 34 P.FORM =: 40 P.SPED =: 42 P.FMEN =: 44 P.MEDI =: 34 P.FORM =: 40 P.SPED =: 42 P.MXWR =: 44 P.NREC =: 50 P.RCSK =: 14 P.TMSK =: 20 L.FMTD =: 42 L.GPCT =: 44 L.FSVR =: 50 L.FHVR =: 51 L.SDI =: 54 L.STI =: 54 L.STI =: 54 TAPEID =: 1 DN1600 =: 1600. DN6250 =: 6250. .SBTTL .MCALLs .MCALL .DRDEF, .ADDR, .ASSUME, .INTEN .MCALL .MFPS, .MTPS, .SYNCH, .BR, .PRINT .MCALL .TRPSET,.WAIT .SBTTL Special Function Definitions SP.WTM =: 377 SP.FWD =: 376 SP.BKS =: 375 SP.REW =: 373 SP.ORW =: 372 SP.WRT =: 371 SP.RD =: 370 SP.STR =: 367 SP.BYP =: 360 SP.ASY =: 354 SP.DAT =: 352 .SBTTL Default SET UNIT/PORT Value Definitions UT.AVAL=: 370 .IIF NDF MU$UN MU$UN == 1 MU$PORTS = MU$UN .IIF LE MU$PORTS-1, MU$PORTS = 1 UM$PORTS = MU$PORTS UM$UNITS = MU$PORTS $1=0 .REPT UM$UNITS .IRP Y,\$1 .IIF NDF UM$U'Y UM$U'Y = 0 .IIF NDF UM$O'Y UM$O'Y = $1 .Assume UM$O'Y LE UM$PORTS .Assume UM$O'Y GE 0 .IIF NDF UM$A'Y UM$A'Y = UT.AVAL $1=$1+1 .ENDR .ENDR DN.DEN =: 0 DN.SET =: 200 DN.FLG =: 1 DN.CAC =: 1 DN.CDL =: 2 DN.CSE =: 4 .IF NE MU$EWR DN.EWR =: 10 .ENDC UM$BBR =: 0 UM$BOO =: 0 .SBTTL .DRDEF - Device Definition UM$PRI =: 5 .IIF NDF MU$FSM MU$FSM = 0 .IIF NE MU$FSM MU$FSM = 1 .IIF NDF MU$CSR MU$CSR = 174500 .IIF DF MU$CSR UM$CSR = MU$CSR .IIF NDF MU$VEC MU$VEC = 260 .IIF DF MU$VEC UM$VEC = MU$VEC .DRDEF UM,60,,0,UM$CSR,UM$VEC .IIF NDF MU$GBL MU$GBL = <^RMU > UM$GBL = MU$GBL .IIF NDF MU$CS1, MU$CS1 = MU$CSR+04 UM$CS1 = MU$CS1 .IIF NDF MU$CS2, MU$CS2 = MU$CSR+10 UM$CS2 = MU$CS2 .IIF NDF MU$CS3, MU$CS3 = MU$CSR+14 UM$CS3 = MU$CS3 .IIF NDF MU$VC1, MU$VC1 = 340 UM$VC1 = MU$VC1 .IIF NDF MU$VC2, MU$VC2 = MU$VC1+4 UM$VC2 = MU$VC2 .IIF NDF MU$VC3, MU$VC3 = MU$VC1+10 UM$VC3 = MU$VC3 .SBTTL .DRPTR - .DREST, .DRSPF Macro Invocations .DRPTR FETCH=ONCE,LOAD=ONCE .DREST CLASS=DVC.MT .DRSPF SP.WTM .DRSPF SP.FWD .DRSPF SP.BKS .DRSPF SP.REW .DRSPF SP.ORW .DRSPF SP.WRT .DRSPF SP.RD .DRSPF SP.BYP .IF NE MU$FSM .DRSPF SP.ASY .ENDC .DRSPF SP.DAT .SBTTL Psect Ordering .PSECT UMDVR .PSECT UMLORD LOWBAS:: .PSECT UMLDATA .IF EQ MMG$T .PSECT UMDATA .ENDC .PSECT UMLCODE .IF NE MU$FSM .PSECT MTDVR .ENDC .PSECT SETOVR .IF NE MMG$T .PSECT UMRLST .PSECT UMNDLS .PSECT SETOV1 .PSECT UMXDAT UMXBAS:: UMXDBA:: .PSECT UMDATA DATABA:: .PSECT UMX UMXBA:: .ENDC .PSECT $LAST$ .INCLUDE "SRC:UM.MAC" .TITLE MU - TMSCP Tape Class Handler .SBTTL ************************* .SBTTL * MU * .SBTTL ************************* .AUDIT .UM,.UMGEN,.UMUNI .AUDIT .MU .SBTTL RT-11 Software Definitions ENTER = 4 LOOKUP = 3 DELETE = 2 CLOSE = 1 REDWRT = 0 WRTEOF = SP.WTM FWDSPC = SP.FWD BKSPC = SP.BKS REWIND = SP.REW OFFLINE = SP.ORW WRITEPHY= SP.WRT READF = SP.RD STR100 = SP.STR BPASS = SP.BYP RC.DIE =: 2 RC.INV =: 5 ILLARG = RC.INV DEVINUSE= RC.DIE CSWEOF = 20000 UNIT = 3400 .PSECT UMLORD .SBTTL DNTAB - Magtape Density/Flag Table .ASSUME DN.DEN EQ 0 .ASSUME DN.SET EQ 200 .ASSUME DN.FLG EQ 1 CLONE .DNTAB,<: .WORD 0> CLONE DNTAB,<::> .REPT UM$UNITS CLONE ,< .WORD 0> .ENDR .EVEN .PSECT UMLDATA .IF NE MMG$T .PSECT UMDATA H$RLPT: .WORD 0 .IFTF DENBIT: .BYTE 0 .BYTE TF.800 .BYTE TF.PE .BYTE TF.GCR .BYTE 0 .BYTE 0 .BYTE 0 .BYTE 0 .EVEN .IFT .IF NE MU$FSM .SBTTL H$NQE - High Memory Copy of Queue Element H$NQ.CS:.WORD 0 H$NQE: .WORD 0 .BYTE 0,0 .WORD 0 .WORD 0 .WORD 0 .WORD 0 .WORD 0 .WORD 0 H$NQND= . .ENDC .SBTTL CVPHYS - Convert Buffer Virtual Address to Physical UMPSECT CVPHYS: CMP (R5)+,(R5)+ .ASSUME Q$BUFF EQ 4 CALL @$MPPTR MOV (SP)+,OLDBA MOV (SP)+,R3 ASH #-4,R3 MOV R3,EXTADR SUB #Q$WCNT,R5 RETURN .ENDC .SBTTL MUBEGN - MU Specific Begin Code .IF NE MMG$T UMXPSECT .IFF .PSECT UMLCOD .ENDC .ENABL LSB MUBEGN: .IF EQ MU$FSM MOV R5,R3 .IFF RET2LO FSMDIS UMPSECT .ENDC $MT:: .IF NE MMG$T MOVB Q$JNUM(R3),R5 BIC #^C,R5 ASR R5 ASR R5 ASR R5 .IF NE MU$FSM MOV R5,JOBNM .IFF MOV R5,@#JOBNM $REL .-2 JOBNM UMR .ENDC MOV R3,R5 .IF NE MU$FSM TST -(R3) MOV #,R1 10$: MOV (R3)+,-(SP) SOB R1,10$ .IFTF MOVB Q$UNIT(R5),R3 .IFT LOW2HI H$MT,PSECT=YES H$MT:: MOV #H$NQND,R5 $REL .-2 H$NQND UMX MOV #,R1 20$: MOV (SP)+,-(R5) SOB R1,20$ TST (R5)+ .ENDC MOV R5,H$CQE .IFF .IF NE MU$FSM MOV R3,R5 .ENDC MOVB Q$UNIT(R5),R3 .ENDC BIC #^C,R3 CMP R3,#UM$UNITS-1 BHI 30$ MOV R3,-(SP) .ADDR #DNTAB,@SP,ADD MOV (SP)+,.DNTAB CLR BCKTM CLR LASCOM CALLR BEGN01 30$: CALLR UMHERR .DSABL LSB .SBTTL ISETUC - Internal Set Unit Characteristics (Caching / Set Density) ISETUC: MOV #-1,INTEOP MSCP OP.SUC BICB #DN.SET,@.DNTAB .ASSUME DN.DEN EQ 0 MOVB @.DNTAB,R5 .ADDR #DENBIT,R5,ADD BITB @R5,P.FMEN(R1) BEQ 10$ MOVB @R5,P.FORM(R4) MOVB P.FMEN+1(R1),P.FORM+1(R4) 10$: .BR CASHIT .SBTTL CASHIT - Setup Write-Back Caching if Unit Supports it. .ENABL LSB CASHIT: MOV .DNTAB,R5 BITB #DN.CAC,DN.FLG(R5) BEQ 10$ BIS #UF.WBN,P.UNFL(R4) 10$: RETURN .DSABL LSB .SBTTL CKABRT - Check if Abort in Progress CKABRT: CLR R5 INC INTEXP BGT 20$ MOV ABTFLG,R5 BEQ 30$ MOV INTEXP,R5 BPL 10$ BIS #,MRING+2 BR 30$ 10$: INC R5 20$: CLR ABTFLG 30$: RETURN .SBTTL CDLCK - Check for Cached Data Lost End Flag CDLCK: CLR BCKTM CLR LASCOM MOV .DNTAB,R4 BITB #EF.DLS,P.FLGS(R5) BEQ 10$ BISB #DN.CDL,DN.FLG(R4) 10$: RETURN .SBTTL CASHCK - Check Tape Caching Support / Enhanced Write Error Recovery CASHCK: DO IGETUS,THEN,CKFEAT CKFEAT: .IF EQ MMG$T .ADDR #MBUFF,R1 .IFF MOV #MBUFF,R1 $REL .-2 MBUFF UMX .ENDC MOV .DNTAB,R5 MOV P.UNFL(R1),-(SP) .IF NE MU$EWR BIT #UF.EWR,@SP BEQ 10$ BISB #DN.EWR,DN.FLG(R5) .ENDC 10$: TST (SP)+ BPL 20$ .ASSUME UF.CAC EQ 100000 BISB #DN.CAC,DN.FLG(R5) 20$: DO ISETUC,THEN,DISPAT .SBTTL MUGCBF - Magtape Specific Setup for GETCBF Routine MUGCBF: MOV @R4,CUROPT CMP @R5,#OP.GUS BEQ 30$ CMP @R5,#OP.ABO BEQ 30$ CMP @R5,#OP.SCC BEQ 30$ MOV R5,-(SP) MOV .DNTAB,R5 INC R5 .ASSUME DN.FLG EQ 1 BITB #DN.CDL,@R5 BEQ 10$ BIS #MD.CDL,P.MOD(R4) 10$: BITB #DN.CSE,@R5 BEQ 20$ BIS #MD.CSE,P.MOD(R4) 20$: BICB #DN.CDL!DN.CSE,@R5 MOV (SP)+,R5 30$: MOV #,-2(R4) .ASSUME VC.CMD EQ CBUFF-2 RETURN .SBTTL USRFN - Dispatch for USR Functions .ENABL LSB USRFN: MOVB Q$JNUM(R5),R2 BIC #^C,R2 MOV .UTTAB,R3 ADD #UT.JOB,R3 CMPB #LOOKUP,R4 BNE 40$ .IF NE MMG$T .IF EQ MU$FSM MOV H$CQE,R4 CALL @H$GTBYT TSTB (SP)+ BNE 30$ CALL @H$GTBYT TSTB (SP)+ BNE 30$ .IFF MOV Q$BUFF(R5),R4 .HP1EX P1LOW MOV @R4,R4 .HP1EN TST R4 BNE 40$ .ENDC .IFF TST @Q$BUFF(R5) BNE 40$ .ENDC MOVB @R3,-(SP) BICB #^C,(SP) CMPB (SP)+,#UT.AVAL BEQ 10$ MOV #RC.DIE,R0 SPERR: MOV @#SYSPTR,R1 MOV R0,SPUSR(R1) .IF NE MU$FSM .IF NE MMG$T MOV #$DONE,-(SP) $REL .-2 $DONE UMR .IFF .ADDR #$DONE,-(SP) .ENDC RET2LO RESTOR .IFF BR 50$ .ENDC 10$: CLR Q$WCNT(R5) BICB #JOBMK,@R3 BISB R2,@R3 .IF NE MU$FSM BR 50$ .IFF 20$: MOV @R5,R1 .ASSUME Q$BLKN EQ 0 BEQ 60$ BGT 30$ INC R1 BEQ 50$ 30$: BISB #UT.AVAL,@R3 MOV #RC.INV,R0 BR SPERR .ENDC KLOSE: BISB #UT.AVAL,UT.JOB(R3) BR 50$ 40$: BIS #HDERR$,@-(R5) FNDISP: 50$: .IF NE MU$FSM CLR R4 .IF NE MMG$T MOV #FSMDON,-(SP) $REL .-2 FSMDON UMR .IFF .ADDR #FSMDON,-(SP) .ENDC RET2LO RESTOR .IFF RET2LO $DONE .ENDC RERWRT: GETCQE R5 BR RWRT1 .IF EQ MU$FSM 60$: MOVB #SP.REW,R4 MOVB R4,Q$FUNC(R5) .BR RWRT .ENDC .SBTTL RWRT - Handle READ/WRITE and Most .SPFUNs RWRT: MOV R4,(PC)+ LASCOM: .WORD 0 RWRT1: MOV LASCOM,R4 CMPB #SP.RD,R4 BLOS 90$ TST R4 BNE 40$ MOVB #SP.RD,R4 .ASSUME Q$BLKN EQ 0 CLR (R5) TST Q$WCNT(R5) BPL 70$ NEG Q$WCNT(R5) INC R4 .ASSUME SP.WRT EQ SP.RD+1 BR 80$ 70$: COM NFSREAD 80$: MOV R4,LASCOM .IF NE MU$FSM .IF EQ MMG$T MOV R4,CODE .IFF .HP1EX P1LOW MOV R4,@#CODE $REL .-2 CODE UMR .HP1EN .ENDC .ENDC 90$: ADD #FUNTAB-TABLE,R4 MOV Q$WCNT(R5),R1 CALL DISPCH .BR TABLE .DSABL LSB TABLE: .BYTE REDEF-NULLFN .BYTE WRIT-NULLFN .BYTE OFFLN-NULLFN .BYTE RWND-NULLFN .BYTE WRIT-NULLFN .BYTE BCKSPC-NULLFN .BYTE FRSPC1-NULLFN .BYTE WRITM-NULLFN FUNTAB: .BYTE OP.RD .BYTE OP.WR .BYTE OP.AVL .BYTE OP.REP .BYTE OP.WR .BYTE OP.REP .BYTE OP.REP .BYTE OP.WTM .EVEN .SBTTL DISPCH - Dispatcher Routine DISPCH: MOVB R4,MCODE ADD (SP)+,R4 MOVB @R4,NULLFN MOVB FUNTAB-TABLE(R4),WHAT JSR R5,GETCBF WHAT: .WORD 0 MOV R4,R2 CLR BCKTM MUDO: DO NULLFN,THEN,MUDONE NULLFN =: .-2 .ASSUME NULLFN EQ MUDO+6 .SBTTL xxxx - Final Setup Routines for Specific I/O Operations .ENABL LSB WRIT: .IF NE MU$EWR MOV .DNTAB,R5 BITB #DN.EWR,DN.FLG(R5) BEQ REDEF BIS #MD.ERW,P.MOD(R2) .ENDC REDEF: ASL R1 .IF EQ MMG$T MOV OLDBA,P.BUFF(R2) .IFF .HP1EX P1LOW MOV @#OLDBA,R4 $REL .-2 OLDBA UMR MOV @#EXTADR,R5 $REL .-2 EXTADR UMR .HP1EN MOV R4,P.BUFF(R2) MOV R5,P.BUFF+2(R2) .ENDC .IF NE P.BCNT-P.RECC TST R1 BGE 10$ MOV #MAXBLK,R1 10$: MOV R1,P.BCNT(R2) BR FNSHUP .IFF .ASSUME P.BCNT EQ P.RECC BR FRSPC .ENDC BCKSPC: BIS #MD.REV,P.MOD(R2) FRSPC1: INC R1 BNE 20$ INC R1 MOV R1,P.TMGC(R2) COM (PC)+ BCKTM: .WORD 0 20$: DEC R1 .BR FRSPC FRSPC: MOV R1,P.RECC(R2) BGE FNSHUP MOV #MAXBLK,P.RECC(R2) BR FNSHUP OFFLN: BIS #MD.UNL,P.MOD(R2) .IF NE UM$PORTS-1 MOV .PCTAB,R5 CLR PC.STEP(R5) .IFF CLR ISTEP .ENDC BR FNSHUP RWND: BIS #MD.RWD,P.MOD(R2) BISB #DN.SET,@.DNTAB .ASSUME DN.DEN EQ 0 WRITM: FNSHUP: MOV R2,R4 MOV P.RECC(R2),(PC)+ RBCNT: .WORD 0 .ASSUME P.RECC EQ P.BCNT RETURN .DSABL LSB .SBTTL UM$AB1 - Abort Entry Point .ENABL LSB UM$AB1: CLR BCKTM CLR -(SP) .IF NE MMG$T .HP1EX P1LOW MOV @#UMCQE,R5 $REL .-2 UMCQE UMR .HP1EN TST R5 BEQ 20$ MOV H$CQE,R5 .IFF MOV UMCQE,R5 BEQ 20$ .ENDC MOVB Q$JNUM(R5),R5 BIC #^C,R5 ASR R5 ASR R5 ASR R5 CMP R5,R4 BNE 20$ .IF NE MU$FSM .IF EQ MMG$T MOV DVTBL,R5 .IFF .HP1EX P1LOW MOV @#DVTBL,R5 $REL .-2 DVTBL UMR .IFTF BEQ 10$ MOV #-1,@R5 MOV (R5)+,@R5 10$: .IFF .HP1EN .ENDC .ENDC TST ABTFLG BNE 50$ INC @SP MOV #-1,(PC)+ ABTFLG: .WORD 0 .IF EQ MMG$T CLR UMFBLK+2 .IFF .HP1EX P1LOW CLR @#UMFBLK+2 $REL .-2 UMFBLK+2 UMR .HP1EN .ENDC 20$: .IF EQ MMG$T .ADDR #,R5 .IFF MOV #,R5 $REL .-2 UTTAB+UT.JOB UMX .IFTF MOV R5,-(SP) ADD #UTTBND-UTTAB-UT.JOB,@SP .ENDC 30$: MOVB (R5),-(SP) BIC #^C,(SP) ASR @SP ASR @SP ASR @SP CMPB R4,(SP)+ BNE 40$ BISB #UT.AVAL,(R5) 40$: ADD #UT.ESZ,R5 CMP R5,@SP BLO 30$ TST (SP)+ 50$: TST (SP)+ BEQ 60$ ADD ABTFLG,INTEXP BCC ABRTND BPL ABRTND DO ABRT,THEN,UMEXIT ABRTND: CLR INTEXP .IF EQ MMG$T 60$: RETURN .IFF 60$: CALLR HRET .ENDC .SBTTL ABRT - Abort An Outstanding Command ABRT: TST CRING+2 BMI ABRT MOV (PC)+,-(SP) CUROPT: .WORD 0 MSCP OP.ABO MOV (SP)+,P.OTRF(R4) MOV .DNTAB,-(SP) INC (SP) .ASSUME DN.FLG EQ 1 BISB #DN.CSE,@(SP)+ ADD #ABPOLL-POLL,@SP RETURN .DSABL LSB .SBTTL UMERR - Handle Interrupt Level Errors .ENABL LSB UMERR: CMPB #OP.END!OP.ONL,P.OPCD(R5) BEQ 20$ CMPB #ST.OFL,R1 BEQ 40$ CMPB #ST.POL,R1 BEQ 41$ CMPB #ST.SEX,R1 BEQ 30$ CMPB #ST.CMD,R1 BEQ 30$ .ASSUME ST.HST EQ ST.DAT+1 .ASSUME ST.CNT EQ ST.HST+1 .ASSUME ST.DRV EQ ST.CNT+1 .ASSUME ST.FMT EQ ST.DRV+1 CMPB R1,#ST.DAT BLO DSPERR CMPB R1,#ST.FMT BHI DSPERR CMP P.STS(R5),# BNE 30$ .IF NE UM$PORTS-1 MOV .PCTAB,R5 CLR PC.STEP(R5) .IFF CLR ISTEP .ENDC CLRB DN.FLG(R4) 30$: CALLR UMHERR 40$: DEC RETRY BLE 20$ INC RETRY CLRB DN.FLG(R4) CALLR INIT 41$: BITB #EF.SEX,P.FLGS(R5) BEQ 42$ MOV #POSLST,R4 BR BABORT 42$: CLR R1 CALLR CKCMD 20$: MOV #UNAVIL,R4 BABORT: BR ABORT .DSABL LSB .SBTTL DSPERR - Dispatch To Appropriate Error Routine For Last Command DSPERR: CALL GOT$IT .BR GOTTAB GOTTAB: .BYTE GOTRD - . .BYTE GOTWR - . .BYTE GOTOFF - . .BYTE GOTREW - . .BYTE GOTWR - . .BYTE GOTBAC - . .BYTE GOTFR1 - . .BYTE GOTTM - . .ENABL LSB GOT$IT: CLR R4 ADD (PC)+,@SP MCODE: .WORD 0 MOV @SP,-(SP) MOVB @(SP)+,-(SP) CLRB 1(SP) ADD (SP)+,@SP CALLR @(SP)+ .SBTTL GOTxx - Handle Errors Based on Last Command Issued GOTTM: GOTWR: CMPB #ST.WPR,R1 BNE 70$ MOV #WRTLOC,R4 BR ABORT GOTBAC: GOTFR1: BIT #ST.MSK,R1 BNE GOTFOR MOVB #ST.TM,R1 GOTFOR: CMPB #ST.BOT,R1 BNE 60$ BIS #BOTFND,R4 BISB #DN.SET,@.DNTAB .ASSUME DN.DEN EQ 0 BR GOTERR GOTRD: CMPB #ST.RDT,R1 BNE 50$ MOV #RECERR,R4 BR ABORT 50$: BIT #ST.MSK,R1 BNE 60$ BIS #100,R4 MOV RBCNT,R2 SUB P.BCNT(R5),R2 BEQ 70$ ASR R2 MOV #SMLREC,R4 MOV #HDERR$,-(SP) BR EBLKST 60$: CMPB #ST.TM,R1 BNE 70$ .ASSUME EOFFND EQ 1 INC R4 70$: BITB #EF.EOT,P.FLGS(R5) BEQ GOTERR TST NFSREAD BNE GOTERR CMPB (R4)+,(R4)+ .ASSUME EOTFND EQ 2 GOTOFF: GOTREW: GOTERR: TST R4 BNE OBJCNT DEC RETRY BLE UMHERR CALLR RERWRT OBJCNT: MOV #EOF$,-(SP) CMPB #OP.END!OP.REP,P.OPCD(R5) BNE 80$ MOV RBCNT,R2 SUB P.RCSK(R5),R2 .BR EBLKST EBLKST: .IF NE MMG$T .HP1EX P1LOW MOV R2,@#ERRBL2 $REL .-2 ERRBL2 UMR .HP1EN .IFF .IF NE MU$FSM MOV @MUCQ,R5 .IFF MOV @UMCQE,R5 .ENDC BEQ 80$ MOV R2,2(R5) .ENDC 80$: BIC #100,R4 BR EXCEP .DSABL LSB .SBTTL UMHERR - Error Completion Routines .ENABL LSB UMHERR: CLR R4 ABORT: MOV #HDERR$,-(SP) EXCEP: .IF NE MU$FSM .IF NE MMG$T MOV @H$CQE,R5 .HP1EX P1LOW MOV #MUCQ,-(SP) $REL .-2 MUCQ UMR MOV @(SP)+,-(SP) MOV R5,@(SP)+ .HP1EN .ENDC MOV (SP)+,R5 RET2LO FSMERR .IFF .IF EQ MMG$T MOV UMCQE,R5 .IFF MOV H$CQE,R5 .ENDC BIS (SP)+,@Q$CSW(R5) TST @R5 BEQ MUDONE RET2LO DOSYNCH .BR UMPSECT DOSYNCH: .IF NE MMG$T COM SINK MOV UMCQE,R5 MOV @R5,ERBSAV MOV R4,TEMP MOVB Q$JNUM(R5),R5 BIC #^C,R5 ASR R5 ASR R5 ASR R5 MOV R5,JOBNM .IFF MOV R4,@(R5)+ .ENDC BR $DONE UMXPSECT .ENDC .DSABL LSB .SBTTL MUDONE - Normal Completion Routines MUDONE: .IF NE MU$FSM CLR R4 RET2LO FSMDON .ENDC .ENABL LSB UMEXIT: RET2LO $DONE .BR UMPSECT $DONE:: .IF NE MMG$T .ADDR #UMCQE,R4 MOV @#SYSPTR,R5 TST SINK BNE 10$ CALLR @QCOMP(R5) 10$: CLR SINK CALL @QCOMP(R5) .ADDR #SYNBLK,R4 .SYNCH BR BADSYN MOV ERBSAV,R1 BIS #30000,@#177776 MOV R0,-(SP) MTPI (R1)+ MOV ERRBL2,-(SP) MTPI (R1)+ BADSYN: RETURN .IFF .DRFIN UM .ENDC .DSABL LSB .IF NE MMG$T .SBTTL XBUMP - Bump Buffer Address by 512 in XM XBUMP:: MOV UMCQE,-(SP) ADD #Q$PAR,@SP ADD #10,@(SP)+ ADD #512.,OLDBA ADC EXTADR RETURN .ENDC .SBTTL Magtape Data Area OLDBA:: .WORD 0 .IF NE MMG$T EXTADR::.WORD 0 UMXPSECT .ENDC NFSREAD::.WORD 0 .IF NE MMG$T UMPSECT SYNBLK::.WORD 0 JOBNM:: .WORD 0 .WORD 0 .WORD 0 TEMP:: .WORD 0 .WORD -1 .WORD 0 SINK:: .WORD 0 ERBSAV::.WORD 0 ERRBL2: .WORD 0 .ENDC .IF EQ MU$FSM .DREND UM,PSECT=UMLCODE .PSECT UMDVR .IFF MUCQ: .WORD 0 DRIVEN == MU$UN DVINFO:: .REPT DRIVEN .WORD -1 .WORD -1 .WORD -1 .BYTE 0 .BYTE 0 .WORD 0,0,0 .ENDR MTDONE == MUDONE MTCQE == UMCQE MT == UM MTLQE == UMLQE MTSTRT == UMSTRT MTCQ == MUCQ MUSTRT == UMSTRT .ENDC .IF NE MMG$T UMXPSECT UMXEND:: .PSECT UMXDAT UMXDND:: .PSECT UMDATA DATAND:: UMXDSZ ==: UMXDND - UMXDBA DATASZ ==: DATAND - DATABA UMXSZ ==: UMXEND - UMXBA UMXSIZ ==: UMXDSZ+DATASZ+UMXSZ MEMUMX ==: /100 .PSECT UMRLST UMREND:: UMRLSZ ==: UMREND - UMR.LST UMLSZ ==: UMRLSZ .PSECT UMNDLS UMPAD:: .BLKB <1000-SOVRSZ-UMLSZ> UMPSECT .ENDC .PSECT UMDVR SIZE = . SIZED = /2 .PSECT UMLORD LOWDATA ==: . - LOWBAS .IF NE MMG$T .ASSUME LOWDATA EQ UMXDSZ .ENDC .END .MCALL .MODULE .MODULE XC,VERSION=04,COMMENT= ; COPYRIGHT (c) 1986 BY ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. XL$PC = 1 XL$DVE = 0 XL$SBC = 0 XL$PDT = 0 .INCLUDE "SRC:XL.MAC"