ASMB,R,Q,C
      NAM TIM,7 09580-16022 REV.1926 790312 
*-------------------------------------------------------------------
* 
*      RELOC.       09580-16022 
*      SOURCE       09580-18022 
* 
*      C. LEATH     03/15/77    REV. A
*                   790307      REV 1926
* 
*      HP 92425A TEST SYSTEM SOFTWARE IS THE PROPRIETARY
*      MATERIAL OF THE HEWLETT-PACKARD COMPANY.  USE AND
*      DISCLOSURE THEREOF ARE RESTRICTED BY WRITTEN AGREEMENT.
* 
*      (C) COPYRIGHT HEWLETT-PACKARD COMPANY 1977.
*      ALL RIGHTS RESERVED.  NO PART OF THIS PROGRAM
*      MAY BE PHOTOCOPIED, REPRODUCED OR TRANSLATED 
*      TO ANOTHER PROGRAM LANGUAGE WITHOUT THE PRIOR
*      WRITTEN CONSENT OF THE HEWLETT-PACKARD COMPANY.
* 
*-------------------------------------------------------------------
      EXT EXEC,RTCLN,ISN,.ENTR
      EXT ERROR 
      ENT TIM 
A     EQU 0 
B     EQU 1 
      SKP 
* 
* 
*     COMMENTS
**************************************************
* 
*     THIS IS THE TABLE INTERFACE MODULE FOR THE 9580 SYSTEM
*  RESPONSIBLE FOR RETRIEVING DATA FROM SYSTEM AVAILABLE
*  MEMORY (SAM) AND RETURNING THE DATA OF INTEREST TO 
*  THE REQUESTING DEVICE SUBROUTINE.  THE PARAMETERS
*  IN THE CALLING SEQUENCE DETERMINE WHAT DATA IS TO
*  BE RETURNED AND HOW MUCH.  THE DEVICE SUBROUTINE 
*  IS RESPONSIBLE FOR KNOWING WHAT DATA IS IN THE TABLE 
*  AND WHAT FORMAT IT IS IN.
*     THE PARAMETERS IN THE CALLING SEQUENCE ARE DEFINED AS 
*  AS FOLLOWS:
*     IDTN = DEVICE TYPE NUMBER, UNIQUE FOR EACH DEVICE 
*     IUN = UNIT NUMBER 
*     IRW = 1(READ),2(WRITE),3(# UNITS) 
*     IBUF= DEVICE SUBROUTINE BUFFER IN WHICH DATA IS TO
*       BE RETURNED.
*     IBL = IBUF LENGTH 
*     N = ERROR INDICATOR,
*          WHERE: 
*          1 = DEVICE TYPE NOT EXISTENT IN TABLE
*          2 = LENGTH OF REQUEST BUFFER IBL DOES NOT
*              JIBE WITH THE LENGTH OF THE RECORD SET.
*          3 = UNIT # DOES NOT EXIST IN THE TABLE.
*          4 = NO CLASS # 
*          5 = ILLEGAL IRW REQUEST #
* 
*     ERRORS ARE RECOVERABLE BY CHANGING THE ASCII TABLE
*     OR BY CHANGING THE TEST PROGRAM.
* 
*     SUBROUTINE TIM IS INCLUDED WITH EACH BASIC OVERLAY
*  IN ORDER TO ENABLE EACH DEVICE SUBROUTINE THAT 
*  NEEDS VARIABLE DATA TO ACCESS TABLE DATA.
* 
*     PRIOR TO USING THIS PROGRAM IT IS ASSUMED THAT THE
*  ALLOC PROGRAM HAS BEEN RUN.  ALLOC IS THE PROGRAM THAT TAKES 
*  THE ASCII FILE CONTAINING THE CONFIGURATION INFORMATION
*  AND PLACES IT IN SAM (SYSTEM AVAILABLE MEMORY). OF COURSE
*  THE DATA IN SAM IS BINARY.  THE FORMAT OF THE TABLE IN 
*  IS AS SHOWN IN THE FOLLOWING FIGURE.  EACH TABLE IN SAM
*  IS LINKED BY THE FIRST IN THE TABLE WHICH IS THE CLASS 
*  NUMBER FOR THE SUCCEEDING TABLE.  THE LAST TABLE IN SAM
*  HAS THE FIRST WORD POINTING TO THE FIRST TABLE OF THE GROUP, 
*  SO THAT WE HAVE IN A SENSE A CIRCULARLY LINKED LIST. 
*  THE SECOND WORD OF THE TABLE CONTAINS THE ACTUAL LENGTH
*  OF THE TABLE, WITH THE MAXIMUM SIZE ANY ONE TABLE CAN BE 
*  IS 130 WORDS.
* 
*            -----------------------------------------
*   WORD 1   *     CLASS # FOR NEXT TABLE IF ANY     *
*            *    (MAY POINT TO ITSELF)              *
*            -----------------------------------------
*    WORD 2  *  LENGTH (MAXIMUM 130 WORDS)           *
*            *----------------------------------------
*    WORD 3  *  DEVICE TYPE NUMBER                   *
*            *----------------------------------------
*    WORD 4  *   # UNITS                             *
*            *---------------------------------------*
*    WORD 5  *  # OF ENTRIES                         *
*            *---------------------------------------*
*    WORD 6  *    DATA AND INFO SIMILAR TO WORDS 3-5 *
*            *---------------------------------------*
* 
*   NOTE: WORDS 3-5 ARE HEADER INFORMATION FOR EACH DEVICE
* 
* 
*     COMMENTS RELATED TO THE PROGRAM, KEYED TO THE NUMBERS.
* 
****#1
* 
* 
*     SOME ERROR CHECKING IS DONE TO VERIFY IRW IS CORRECT. 
*  THE STATION NUMBER IS RETRIEVED VIA ISN AND THE CLASS
*  NUMBER FOR THE FIRST BUFFER IN SAM IS ALSO RETRIEVED 
*  VIA "RTCLN". 
* 
****#2
*     RETRIEVE THE BUFFER WITH A CLASS GET REQUEST, USING 
*   SUBROUTINE "GTBUF".  LDT IS THE POINTER INTO IBC AND
*   IT IS INITIALIZED TO 3 TO POINT TO THE THIRD WORD SINCE 
*   WORDS 1 AND 2 CONTAIN RESPECTIVELY THE CLASS NUMBER 
*   FOR THE NEXT BUFFER IF ANY AND THE LENGTH OF THE BUFFER.
* 
****#3
* 
*    AT THIS POINT WE BEGIN SEARCHING THRU THE BUFFER IBC TO
* FIND THE DEVICE TYPE NUMBER (IDTN). THE FOLLOWING ALGORITHM 
* IS USED TO INDEX TO EACH IDTN IN THE TABLE: 
* 
*    LDT(N) = [IBC(LDT(N-1) + 2) + 1] *[IBC(LDT(N-1)] + [LDT(N-1)+3]
*                     A                     B               C 
* 
*     WHERE: LDT IS THE INDEX THAT IS UPDATED EACH TIME THRU LOOP(TM3). 
*     A =   THE NUMBER OF ENTRIES PLUS ONE FOR EACH UNIT NUMBER WORD. 
*     B =   THE NUMBER OF UNITS 
*     C =   THREE WORDS OF OVERHEAD FOR EACH DEVICE TYPE. 
* 
*      IF AFTER COMPUTING EACH LDT IT IS DISCOVERED THAT THE VALUE
*  EXCEEDS THE TABLE LENGTH THE NEXT TABLE IS RETRIEVED FROM
*  SAM. 
* 
****#4
* 
*     THIS PORTION SEARCHES FOR THE UNIT NUMBER "IUN".
*  THE POINTER LDT AT THIS TIME POINTS TO THE 
*  FIRST UNIT NUMBER OF A PARTICULAR DEVICE TYPE (IDTN) 
*  AND THE COUNTER "IUCNT" IS INITIALIZED WITH
*  THE NUMBER OF UNITS ASSIGNED TO THE DEVICE TYPE. 
*     IF THE UNIT NUMBER (IUN) IS NOT FOUND 
*  A RETURN IS MADE TO THE CALLING ROUTINE WITH THE 
*  THE ERROR FLAG (N) = -2. 
*      THE ALGORITHM USED TO COMPUTE THE INDEX (LDT) FOR EACH 
*  UNIT NUMBER IS:
* 
*      LDT(N) = LDT(N-1) +IUPTR + 1 
*                  A        B     C 
* 
*     WHERE: A = THE PREVIOUS INDEX TO A UNIT NUMBER. 
*            B = THE NUMBER OF ENTRIES PER UNIT.
*            C = ONE WORD FOR UNIT #
* 
* 
****#5
* 
*     HERE THE READ/WRITE INDICATOR (IRW) IS EXAMINED TO
*  DETERMINE WHICH DIRECTION DATA IS TO FLOW, AND IF
*  A WRITE (IRW = 2) WE GO TO TM16. IF A
*  READ THE DATA OF INTEREST IS TRANSFERRED TO THE
*  DEVICE SUBROUTINE BUFFER (IBUF).  IN CASE THE DATA 
*  OVERFLOWS INTO ANOTHER BUFFER A CLASS GET REQUEST (GTBUF)
*  IS MADE TO RETRIEVE THE OTHER BUFFER.
* 
****#6
* 
*     THIS IS THE WRITE SECTION, WITH THE ONLY DIFFERNCE FROM 
*  THE READ REQUEST BEING THAT "ICL" IN THE GET REQUEST 
*  HAS BIT 14 =0 TO INDICATE TO THE SYSTEM THAT WE WANT 
*  TO RELEASE THE BUFFER BU RETAIN THE CLASS NUMBER.
*  OVERFLOWS ARE HANDLED PRETTY MUCH THE SAME WAY AS IN THE 
*  READ REQUEST.
* 
* 
*     SAME #6 EXCEPT THIS IS FOR A WRITE REQUEST. 
      SKP 
      SPC 3 
IDTN  NOP 
IUN   NOP 
IRW   NOP 
IBUF  NOP 
IBL   NOP 
N     NOP 
TIM   NOP 
      JSB .ENTR     RETRIEVE PARAMETER ADDRESSES
      DEF IDTN
      CLA 
      STA N,I 
      STA IFND
      STA J 
************************** # 1 PARAMETER CHECK AND INITIALIZATION 
*                           OF STATION #(ISTN) AND CLASS # (ICLAS). 
* SEE IF IRW IS < 0 OR > 3
* 
      LDA IRW,I 
      SZA,RSS 
      JMP ERR5
      SSA 
      JMP ERR5
      CMA,INA 
      ADA .2
      SSA 
      JMP ERR5
      JSB ISN       GET STATION # 
      DEF *+2 
      DEF IDMY
      STA ISTN
      JSB RTCLN     GET CLASS # FOR STATION 
      DEF *+3 
      DEF ISTN
      DEF ICLAS 
      STA IFCLS     SAVE FIRST CLASS #
      SZA,RSS       IS CLASS # = 0
      JMP ERR4      YES ERROR 
TM1   LDA .3        INITIALIZE LDT(POINTER FOR SEARCHING) 
      STA LDT 
      LDA IDTN,I    DEVICE TYPE NUMBER
      STA ISV       SEARCH VARIABLE 
* 
************************* # 2 GET TABLES AND SEARCH FOR IDTN. 
* 
TM2   LDB ICLAS 
      LDA IC1       MASK (BITS 13 1AND 14 SET)
      JSB GTBUF     GET CLASS BUFFER
      JSB FOUND     SEE IF IBC(LDT) = ISV 
      JMP TM5       EUREKA!!
* 
**************************** # 3
* 
TM3   LDA LDT       CHECK IF NUMBER OF
      CPA .130      INITS IS CURRENT BUFFER 
      JMP *+2       IF NOT, READ NEXT BUFFER
      JMP TM3A
* 
      LDB IBC       SET CLASS# OF NEXT BUFFER 
      STB ICLAS 
* 
      LDA IC1       GET NEXT BUFFER 
      JSB GTBUF 
* 
      LDA .2        SET CURRENT LOCATION OF 
      STA LDT        DEVICE TYPE TO PSEUDO LOCATION.
* 
      LDA .2         SET TO (FIRST DATA LOC.) - 1 
* 
* 
TM3A  ADA IBCPT     GET NUMBER OF UNITS 
      INA 
      LDB A,I 
      STB TEMP
* 
      LDB LDT       CHECK IF NUMBER OF
      INB 
      CPB .130      ENTRIES IS IN CURRENT BUFFER
      JMP *+2       IF NOT, READ NEXT BUFFER
      JMP TM3B
* 
      LDB IBC       SET CLASS # OF NEXT BUFFER
      STB ICLAS 
* 
      LDA IC1       GET NEXT BUFFER 
      JSB GTBUF 
* 
      CLB,INB      SET CURRENT LOCATION OF
      STB LDT       DEVICE TYPE TO PSEUDO LOCATION
* 
      LDB .2        SET TO (FIRST DATA LOC.) - 1
* 
TM3B  ADB IBCPT     FETCH NUMBER OF ENTRIES 
      INB 
      LDA B,I 
* 
      INA           ADJUST NUMBER OF ENTRIES
      CLB 
      MPY TEMP
      STA TEMP
      ADA LDT 
      ADA .3        LDT = TEMP +(LDT+3) 
      STA LDT 
      CMA,INA       SEE IF  LDT > LENGTH OF TABLE(IBC(2)) 
      ADA IBC2
      SSA,RSS 
      JMP TM4 
      LDA LDT       LDT = LDT - 128 
      ADA M128
      STA LDT 
      LDA IBC 
      CPA IFCLS     HAVE WE EXAMINED ALL CLASS BUFFERS? 
      JMP ERR1      YES THEN IDTN DOES NOT EXIST IN CONFIG TABLE
      LDB IBC 
      STB ICLAS 
      JMP TM2       TRY AGAIN (READ IN ANOTHER BUFFER)
TM4   JSB FOUND 
      JMP TM5        FOUND IT THIS TIME 
      JMP TM3        GO LOOP DE LOOP
* 
* 
      SKP 
      SPC 3 
* 
************************** # 4
*     DEVICE TYPE NUMBER HAS BEEN FOUND SO THEREFORE WE MUST
*  NOW FIND THE UNIT # AND ENTRIES
* 
TM5   LDA LDT       MAKE SURE LDT+1 .NE. 130
      INA 
      CPA .130
      JMP *+2 
      JMP TM6 
      LDA IB130 
      STA IUCNT      NUMBER OF UNITS
      LDB IBC 
      STB ICLAS     KEEP ICLAS CURRENT
      LDA IC1 
      JSB GTBUF 
      LDA .4        SET POINTER TO FIRST UNIT NUMBER
      STA LDT 
      LDB IBCPT 
      ADB .3        PICK UP # OF ENTRIES
      LDA B,I 
      STA IUPTR 
      CPA IBL,I     SEE IF IBL(BUFFER LENGTH) = #ENTRIES(SUBRECORDS)
      JMP TM10
      JMP ERR2
TM6   LDA LDT       SEE IF LDT = 130(END OF BUFFER).
      CPA .130
      JMP *+2 
      JMP TM7 
      LDB IBC       SINCE LDT= 130, THE INFORMATION WE NEED IS IN 
      STB ICLAS 
      LDA IC1       THE NEXT CLASS BUFFER 
      JSB GTBUF 
      LDA .2        SET LDT TO POINT TO IBC LENGTH WORD (IBC(2))
      STA LDT 
TM7   LDB IBCPT 
      ADB LDT       COMPUTE IBC(LDT+2) AND IBC(LDT+1), #ENTRIES AND 
      INB           # UNITS RESPECTIVELY
      LDA B,I 
      STA IUCNT 
      INB 
      LDA B,I 
      STA IUPTR 
      CPA IBL,I     SEE IF IBL = #ENTRIES 
      JMP *+2 
      JMP ERR2
      LDA LDT       LDT = LDT + 3, POINT IT TO FIRST UNIT # 
      ADA .3
      STA LDT 
* 
* 
TM10  LDA IRW,I     SEE IF THIS IS A UNIT COUNT REQUEST ONLY
      CPA .3
      JMP TM20
* 
      LDA IUN,I     SET UP UNIT# TO BE TESTED FOR.
      STA ISV 
* 
      LDA IUCNT     PRESET COUNTER FOR #UNITS + 1.
      CMA 
      STA IFND
* 
TM11  ISZ IFND      TEST IF #UNITS HAS BEEN EXCEEDED. 
      JMP *+2 
      JMP ERR3
* 
TM12  LDA LDT       CHECK IF UNIT # IS IN CURRENT BUFFER. 
      CMA,INA 
      ADA IBC2
      SSA,RSS 
      JMP TM13      YES. UNIT# IS IN CURRENT BUFFER.
* 
      LDA LDT       ADJUST UNIT# POINTER FOR POSISTION IN 
      ADA M128      NEXT BUFFER.
      STA LDT 
* 
      LDA IC1       READ NEXT BUFFER. 
      LDB IBC       (NOTE. ENTRIES FOR A UNIT MAY SPAN MORE 
      STB ICLAS            THAN ONE BUFFER.)
      JSB GTBUF 
      JMP TM12
* 
TM13  JSB FOUND     CHECK IF UNIT# IS RIGHT ONE.
      JMP TM14      YES.
* 
      LDA LDT       INDEX TO NEXT UNIT# POSITION. 
      ADA IUPTR 
      INA 
      STA LDT 
* 
      JMP TM11
* 
      SKP 
      SPC 3 
************************ # 5
*     AT THIS POINT THE UNIT # AND DEVICE TYPE HAVE BEEN FOUND
* AND WE ARE READY TO TRANSFER DATA TO OR FROM THE CLASS
* TABLES IN SAM.
* 
TM14  ISZ LDT       POINT LDT TO FIRST SUBRECORD ENTRY IN TABLE 
      LDA IBL,I     INITIALIZE COUNTER
      CMA,INA 
      STA TRCNT 
      LDA IRW,I     READ OR WRITE REQUEST?
      CPA .2
      JMP TM16      WRITE REQUEST 
* 
*     READ REQUEST
* 
      LDA IBUF      INITIALIZE ADDRESS POINTERS 
      STA TO
TM15  LDA IBCPT 
      ADA LDT 
      STA FROM
      JSB TRFER     BEGIN TO TRANSFER 
      JMP TIM,I     ALL DONE
      LDB IBC       GET THE REST
      LDA IC1 
      JSB GTBUF 
      CLA 
      STA J         RE-INIT POINTERS
      LDA .3
      STA LDT 
      JMP TM15
      SPC 3 
********************** #6 
*     WRITE REQUEST 
* 
TM16  LDB ICLAS 
      LDA IC2       (BIT 13 ONLY SET) RELEASE BUFFER,KEEP CLASS # 
      JSB GTBUF 
      LDA IBUF
      STA FROM
TM17  LDA IBCPT 
      ADA LDT 
      STA TO
      JSB TRFER 
      JMP TM18
* 
* CLASS READ/WRITE
* 
      LDA IBC 
      STA TEMP      SAVE CURRENT CLASS #
      JSB WRTBF 
      LDB TEMP      GET THE NEXT BUFFER 
      STB ICLAS 
      LDA IC2 
      JSB GTBUF 
      CLA           RE-INIT POINTERS
      STA J 
      LDA .3
      STA LDT 
      JMP TM17
TM18  JSB WRTBF 
      JMP TIM,I     GET HAT 
TM20  LDA IUCNT 
      STA IBUF,I
      JMP TIM,I 
* 
      SKP 
      SPC 3 
* 
*     SPECIAL SUBROUTINES THAT MAKE THE JOB OF ALL THE PREVIOUS 
*  BIT CRUNCHING IN THIS ROUTINE EASIER.
* 
**************************************************************
* 
******CLASS GET REQUEST UPON ENTRY A=MASK B=CLASS # 
* 
GTBUF NOP 
      IOR B          A /\ B 
      STA ICL 
      JSB EXEC
      DEF RTG 
      DEF .21 
      DEF ICL 
      DEF IBC 
      DEF .130
RTG   JMP GTBUF,I 
* 
.21   DEC 21
.130  DEC 130 
ICL   NOP 
* 
      SPC 2 
* 
*CLASS READ/WRITE REQUEST 
* 
WRTBF NOP 
      JSB EXEC
      DEF RTW 
      DEF .20 
      DEF .0
      DEF IBC 
      DEF IBC+1     LENGTH
      DEF IDMY
      DEF JDMY
      DEF ICLAS 
RTW   JMP WRTBF,I 
* 
.20   DEC 20
.0    OCT 0 
IDMY  NOP 
JDMY  NOP 
ICLAS NOP 
* 
      SPC 2 
* 
*     MATCH CHECKING ROUTINE WHICH SEES WHETHER IBC(LDT) = ISV
*      WHERE ISV IS EITHER THE IDTN OR THE IUN. 
* 
*      IF A MATCH RETURN IS P+1 
*      IF NO MATCH RETURN IS P+2
* 
FOUND NOP 
      LDB IBCPT 
      ADB LDT 
      LDA B,I 
      CPA ISV 
      JMP FOUND,I 
      ISZ FOUND 
      JMP FOUND,I 
* 
      SPC 2 
* 
*     DATA TRANSFER ROUTINE, TAKES DATA FROM ONE LOCATION(FROM) 
*  AND TRANSFERS IT TO ANOTHER (TO).
*  P+1 RETURN INDICATES ALL DATA TRANSFERRED
*  P+2 RETURN   " MORE TO GO
*      !!ATTENTION!! ZERO WORDS CANNOT MOVED.(IE TRCNT.NE.0)
* 
TRFER NOP 
* 
TRLOP LDA J         CHECK IF WORD ABOUT TO BE MOVED 
      ADA LDT       IS IN CURRENT BUFFER. 
      CMA,INA 
      ADA IBC2
      SSA,RSS 
      JMP *+3 
* 
      ISZ TRFER     RETURN TO GET NEXT BUFFER.
      JMP TRFER,I 
* 
      LDA FROM,I    MOVE DATA WORD. 
      STA TO,I
* 
      ISZ J         SET POINTER TO NEXT WORD. 
      ISZ FROM
      ISZ TO
* 
      ISZ TRCNT     CHECK IF ALL WORDS HAVE BEEN MOVED. 
      JMP TRLOP 
* 
      JMP TRFER,I   MAKE "FINISHED (P+1)" RETURN. 
* 
FROM  NOP 
TO    NOP 
J     NOP 
TRCNT NOP 
      SKP 
      SPC 3 
* 
*     ERROR MESSAGES
* 
ERR5  ISZ N,I 
ERR4  ISZ N,I 
ERR3  ISZ N,I 
ERR2  ISZ N,I 
ERR1  ISZ N,I 
      JSB ERROR 
      DEF *+3 
      DEF N,I 
      DEF IERMS 
      JMP TIM,I 
* 
IERMS DEC 5 
      ASC 3,TIM 
* 
      SPC 3 
* 
* STORAGE, CONSTANTS ETC
* 
IBC   BSS 130 
IFND  NOP 
.3    DEC 3 
IBC2  EQU IBC+1 
IBCPT DEF IBC-1 
IB130 EQU IBC+129 
.4    DEC 4 
.2    DEC 2 
IUCNT NOP 
IUPTR NOP 
IC1   OCT 60000 
IC2   OCT 20000 
ISV   NOP 
TEMP  NOP 
IFCLS NOP 
ISTN  NOP 
M128  DEC -128
LDT   NOP 
      END