6DC 
          IDENT  6DC,MSFW 
          PERIPH
          BASE   MIXED
          SST 
          TITLE  6DC - CONCURRENT PP OVERLAY LOADER.
*COMMENT  6DC - CONCURRENT PP OVERLAY LOADER. 
          COMMENT  COPYRIGHT CONTROL DATA SYSTEMS INC.  1992. 
 6DC      SPACE  4,10 
***       6DC - CONCURRENT PP OVERLAY LOADER. 
* 
*         J. M. MAREK.       85/11/01.
          SPACE  4,20 
***       *6DC* LOADS 16-BIT OVERLAYS INTO CONCURRENT PPS (CPP).  IT IS 
*         EXPECTED THAT THE ONLY CPP SUBROUTINE TO CALL *6DC* WILL BE 
*         THE PERIPHERAL LIBRARY LOADER (PLL) IN PP RESIDENT.  *6DC* IS 
*         LOADED INTO THE DRIVER OVERLAY AREA WHEN A CPP PROGRAM ISSUES 
*         A *SETMS* REQUEST.  *6DC* PROVIDES THE STANDARD DRIVER ENTRY
*         POINTS, *RDS*, *WDS*, AND *EMS*.
* 
*         WHEN IT IS CALLED AT *RDS*, IT EXAMINES THE PARAMETERS IN 
*         *T5* - *T7*.  IF THE PARAMETERS SPECIFY LOADING A CM RESIDENT 
*         16-BIT PP PROGRAM, *6DC* COMPLETES THE LOAD, PERFORMING THE 
*         NECESSARY PACKING, AND RETURNS TO THE CALLER.  IF A MASS
*         RESIDENT PROGRAM IS REQUESTED, *RDS* ISSUES AN ERROR LOG
*         MESSAGE AND RETURNS AN ERROR STATUS (-1) TO THE CALLER.  IF 
*         *T5* - *T7* DO NOT SPECIFY A 16-BIT LOAD, *6DC* HANGS THE 
*         CPP.
* 
*         WHEN *6DC* IS CALLED AT *WDS*, IT ALSO HANGS THE *CPP*. 
* 
*         WHEN IT IS CALLED AT *EMS*, IT SIMPLY RETURNS TO THE CALLER.
* 
*         NOTE.  DURING EXECUTION *6DC* DESTROYS ITS PRESET CODE. 
*         DRIVER PRESET SHOULD NEVER BE SPECIFIED WITHOUT DRIVER LOAD.
          SPACE  4,10 
***       ENTRY CONDITIONS. 
* 
*         CM RESIDENT 16-BIT OVERLAY. 
*         (T5 - T7) = 2/ ,4/ 10,18/  *RPL* ADDRESS,12/ LENGTH 
* 
*         MS RESIDENT OVERLAY.  (NOT SUPPORTED) 
*         (T5 - T7) = 2/ ,4/ 14,6/ ESTO,12/  TRACK,12/  SECTOR
* 
*         MS READ.  (NOT SUPPORTED) 
*         (T5 - T7) = 3/0, 9/  ESTO,12/  TRACK,12/  SECTOR
 COMMON   SPACE  4,10 
*         COMMON DECKS. 
  
  
*CALL     COMPMAC 
*CALL     COMPIOU 
*CALL     COMSMSC 
*CALL     COMSMSP 
          EJECT 
**        ENTRY POINT TRANSFERS.
  
  
          ORG    MSFW 
  
          CON    PRS         PRESET ADDRESS 
  
  
 RDS      CON    0           ENTRY
          UJN    RDS.        ENTER DRIVER 
  
  
 WDS      CON    0           ENTRY
          UJN    WDS.        ENTER DRIVER 
 EMS      SPACE  4,10 
**        EMS - END MASS STORAGE OPERATION. 
* 
*         EXIT   (A) = 0. 
  
  
 .EMS     SUBR               ENTRY/EXIT 
          LDN    0
          STM    CHRV 
          UJN    .EMSX       RETURN 
 WDS      SPACE  4,10 
**        WDS - WRITE SECTOR. 
* 
*         *WDS* HANGS THE PP WHEN IT IS CALLED. 
* 
*         ENTRY  (A) = BUFFER ADDRESS FOR SECTOR. 
  
  
 WDS.     MONITOR  HNGM      HANG THE PP
 WDS1     UJN    WDS.        CONTINUE HANGING 
 RDS      SPACE  4,10 
**        RDS - READ SECTOR.
* 
*         ENTRY  (A) = BUFFER ADDRESS FOR SECTOR. 
* 
*         EXIT   (A) = 0 IF TRANSFER COMPLETE.
*                    = ERROR CODE IF ERROR OCCURRED.
  
  
 RDS6     EQU    WDS1 
  
 RDS7     LDM    PLLA        GET OVERLAY NAME 
          STM    RDSB 
          LDM    PLLB 
          STM    RDSB+1 
          LDC    RDSA+ERLN   ISSUE ERROR LOG MESSAGE
          RJM    DFM
          LDML   RDS         GET RETURN ADDRESS 
          STDL   CM 
          LCN    1           SET ERROR FLAG 
          LJM    0,CM        RETURN 
  
 RDS.     LDD    T5          CHECK 16-BIT LOAD BIT
          SHN    21-11
 RDS1     PJN    RDS6        IF NOT 16-BIT LOAD 
          SHN    21-10-21+11
          MJN    RDS7        IF MS RESIDENT OVERLAY 
          SHN    21-5-21+10  GET RPL HEADER 
          SCN    77 
          LMD    T6 
          CRD    CM 
          ADN    1           SET FWA OF OVERLAY 
          STD    T6 
          SHN    -14
          STD    T5 
          LDD    CM+1        GET LOAD ADDRESS 
          LPN    17 
          SHN    14 
          LMD    CM+2 
          ZJN    RDS2        IF ZERO LEVEL OVERLAY
          STDL   LA 
 RDS2     STML   2,LA 
          LDDL   LA 
          ADN    5           SET FWA OF OVERLAY CODE
          STDL   CM+2 
          SOD    T7          COMPUTE THE NUMBER OF BYTES
          SHN    4           BYTES = WORDS(15)/4 AND TRUNCATED
          SBD    T7 
          SHN    -2 
          ADDL   CM+2        COMPUTE THE LAST BYTE ADDRESS
          STDL   T7 
          SHN    -15
          NJN    RDS1        IF OVERLAY WRAPS MEMORY
          LDD    CM          BUILD NORMAL OVERLAY HEADER
          STI    LA 
          LDD    CM+1 
          SCN    77 
          STM    1,LA 
          LDN    1
          STM    3,LA 
          LDD    CM+4 
          STM    4,LA 
          LDN    4
          STD    T4 
  
*         START THE MAIN LOOP WITH THESE INITIAL CONDITIONS - 
* 
*         (T4) = 4. 
*         (T5 - T6) = FWA OF THE OVERLAY IN CM. 
*         (T7) = LAST BYTE ADDRESS+1 OF THE OVERLAY IN PP MEMORY. 
*         (CM+2) = FWA OF THE OVERLAY CODE. 
*         (LA) = LOAD ADDRESS OF THE OVERLAY. 
  
*         GET 15 16-BIT BYTES.
  
 RDS3     LDD    T5          READ THE NEXT 4 WORDS
          SHN    14 
          LMD    T6 
          CRM    BUF,T4 
          STD    T6 
          SHN    -14
          STD    T5 
          LDC    BUF
          STD    CM 
  
*         LOAD 12 BITS FROM THE FIRST BYTE AND 4 FROM THE NEXT. 
  
 RDS4     LDI    CM 
          SHN    4
          STIL   CM+2 
          AOD    CM 
          LDI    CM 
          SHN    -8D
          RAIL   CM+2 
          AODL   CM+2 
          SBDL   T7 
          PJN    RDS5        IF LAST BYTE 
  
*         LOAD 8 BITS FROM THE CURRENT BYTE AND 8 FROM THE NEXT.
  
          LDI    CM 
          SHN    8D 
          SCN    77 
          STIL   CM+2 
          AOD    CM 
          LDI    CM 
          SHN    -4 
          RAIL   CM+2 
          AODL   CM+2 
          SBDL   T7 
          PJN    RDS5        IF LAST BYTE 
  
*         LOAD 4 BITS FROM THE CURRENT BYTE AND 12 BITS FROM THE NEXT.
  
          LDI    CM 
          LPN    17 
          SHN    12D
          STIL   CM+2 
          AOD    CM 
          LDI    CM 
          RAIL   CM+2 
          AODL   CM+2 
          SBDL   T7 
          PJN    RDS5        IF LAST BYTE 
  
*         CHECK FOR MORE DATA.
  
          AOD    CM 
          SBK    BUF+4*5
          MJP    RDS4        IF 4 WORDS HAVE NOT BEEN PROCESSED 
          UJP    RDS3        GET 4 MORE WORDS 
  
 RDS5     LDML   RDS         GET RETURN ADDRESS 
          STDL   CM 
          LDN    0
          LJM    0,CM        RETURN 
  
  
 RDSA     DATA   H* 6DC -*
 RDSB     DATA   C* XXX IS MASS RESIDENT.*
  
 BUF      BSS    0
*         BSS    4*5
 PRS      SPACE  4,10 
**        PRS - PRESET. 
* 
*         CALLS  SLI. 
  
  
 PRS      LDC    PRSA        GET TABLE OF LONG INSTRUCTIONS 
          STD    CM+4 
          LDD    T3          PRESERVE *T3*
          STD    CM+3 
 PRS1     LDI    CM+4        GET NEXT INSTRUCTION ADDRESS 
          ZJN    PRS2        IF END OF LIST 
          STD    T3 
          BLI    T3          BUILD LONG INSTRUCTION 
          AOD    CM+4 
          UJN    PRS1        PROCESS NEXT INSTRUCTION 
  
 PRS2     LDD    CM+3        RESTORE *T3* 
          STD    T3 
          LDC    SMSX        ENSURE PRESET IS NOT RE-EXECUTED 
          STM    MSFW 
          LJM    SMSX        RETURN 
  
  
 PRSA     BSS    0
          LIST16
  
 .1       MAX    *,BUF+4*5
 .1       SET    .1+4-MSFW   CHECK FOR OVERFLOW 
 .1       SET    .1/5 
 .1       SET    MSFW+.1*5
 .2       SET    PPFW-5-*-5  BYTES AVAILABLE BEFORE OVERFLOW
          ERRNG  PPFW-5-.1   DRIVER OVERFLOWS INTO *PPFW*-5 
          END 
