Trailing-Edge
-
PDP-10 Archives
-
BB-P363B-SM_1985
-
mcb/drivers/kdpkmc.lst
There are no other files named kdpkmc.lst in the archive.
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 1
30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (1)
; 0001 module KDPKMC ( ! KMC11/DUP11 driver KMC routines
; 0002 ident = 'X04040',
; 0003 language (bliss16)
; 0004 ) =
; 0005 begin
; 0006
; 0007 !
; 0008 ! COPYRIGHT (c) 1980, 1981, 1982
; 0009 ! DIGITAL EQUIPMENT CORPORATION
; 0010 ! Maynard, Massachusetts
; 0011 !
; 0012 ! This software is furnished under a license and may be used
; 0013 ! and copied only in accordance with the terms of such license
; 0014 ! and with the inclusion of the above copyright notice. This
; 0015 ! software or any other copies thereof may not be provided or
; 0016 ! otherwise made available to any other person. No title to
; 0017 ! and ownership of the software is hereby transferred.
; 0018 !
; 0019 ! The information in this software is subject to change
; 0020 ! without notice and should not be construed as a commitment
; 0021 ! by DIGITAL EQUIPMENT CORPORATION.
; 0022 !
; 0023 ! DIGITAL assumes no responsibility for the use or reliability
; 0024 ! of its software on equipment which is not supplied by
; 0025 ! DIGITAL.
; 0026 !
; 0027
; 0028 !++
; 0029 !
; 0030 ! FACILITY: MCB KDP Driver
; 0031 !
; 0032 ! ABSTRACT:
; 0033 !
; 0034 ! This is the DDM process which services the KMC11 microprocessor
; 0035 ! which controls DUP11 synchronous line devices.
; 0036 !
; 0037 ! ENVIRONMENT: MCB V3.0
; 0038 !
; 0039 ! AUTHOR: Alan D. Peckham CREATION DATE: 9-Mar-81
; 0040 !
; 0041 ! MODIFIED BY:
; 0042 !
; 0043 ! S. I. GOLDFARB, 25-MAR-1977
; 0044 ! R. H. ROSENBAUM, 30-AUG-1977
; 0045 ! L. J. TWAITS, 10-SEP-1977
; 0046 ! D. B. TUTTLE, 10-OCT-1977
; 0047 !
; 0048 ! Alan D. Peckham, 16-APR-80: Version 4
; 0049 ! 01 - Split off from KDP module.
; 0050 ! 02 - Change K_INPUT_DATA to be 4 words.
; 0051 ! 03 - Add KMCPRM routine to supply NM parameters
; 0052 ! 04 - Avoid doing SIGNAL_STOPs on device errors.
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 2
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (1)
; 0053 ! Add support for device error counters.
; 0054 !--
; 0055 !
; 0056 ! INCLUDE FILES:
; 0057 !
; 0058
; 0059 library 'MCBLIB';
; 0060
; 0061 library 'XPORT';
; 0062
; 0063 library 'NMXLIB';
; 0064
; 0065 library 'KDPDAT';
; 0066
; 0067 !
; 0068 ! TABLE OF CONTENTS:
; 0069 !
; 0070
; 0071 linkage
; 0072 KDP_CSR_MC_LNG = jsr (register = 1, register = 2, register = 3),
; 0073 KDP_CSR = jsr (register = 1);
; 0074
; 0075 forward routine
; 0076 DEVICE_BROKEN : LINKAGE_DB novalue,
; 0077 INPUT_TRANSFER : LINKAGE_DB novalue,
; 0078 KMC_INTERRUPT : MCB_INTERRUPT novalue,
; 0079 KMCDB : CALL$ novalue,
; 0080 KMCPRM : CALL$ novalue,
; 0081 KMCQUE : CALL$ novalue,
; 0082 KMCSTP : CALL$ novalue,
; 0083 KMCSTR : CALL$,
; 0084 KMCTIM : MCB_DB_MOD novalue,
; 0085 LOAD_MICROCODE : KDP_CSR_MC_LNG,
; 0086 OUTPUT_TRANSFER : LINKAGE_DB novalue,
; 0087 SERVICE_KMC : MCB_DB novalue,
; 0088 START_MICROCODE : KDP_CSR,
; 0089 TIMLTM : MCB_DB novalue,
; 0090 TIMPIN : MCB_DB novalue,
; 0091 TIMPWF : MCB_DB novalue;
; 0092
; 0093 !
; 0094 ! MACROS:
; 0095 !
; 0096 ! None
; 0097 !
; 0098 ! EQUATED SYMBOLS:
; 0099 !
; 0100
; 0101 literal
; 0102 FALSE = 1 EQL 0,
; 0103 NO_OPERATION = 0,
; 0104 TRUE = 1 EQL 1;
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 3
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (1)
; 0105
; 0106 literal
; 0107 REQUEST_TIMEOUT = 2;
; 0108
; 0109 global literal
; 0110 %name ('K.LEN') = K_LEN*%upval;
; 0111
; 0112 !
; 0113 ! OWN STORAGE:
; 0114 !
; 0115
; 0116 external routine
; 0117 $DSPCR : novalue;
; 0118
; 0119 bind
; P 0120 KMC_DISPATCH = TABLE$ ($DSPCR, FC_CCP,
; 0121 (FC_TIM, KMCTIM));
; 0122 !
; 0123 ! EXTERNAL REFERENCES:
; 0124 !
; 0125
; 0126 external routine
; 0127 COBAD : CALL$ novalue,
; 0128 COCTL : CALL$ novalue,
; 0129 CORBA : CALL$ novalue,
; 0130 COTBA : CALL$ novalue,
; 0131 REGISTER_NXM : KDP_CSR_NUM;
; 0132
; 0133 external
; 0134 MCB$GAW_PROCESS_DATA_BASE : vector [2],
; 0135 MCB$GW_PROCESS_HANDLE,
; 0136 MCB$GA_PROCESS_DISPATCH;
; 0137
; 0138 bind
; 0139 DB = MCB$GAW_PROCESS_DATA_BASE [1] : ref block field (K_FIELDS),
; 0140 DB_BIAS = MCB$GAW_PROCESS_DATA_BASE [0];
; 0141
; 0142 macro
; M 0143 GET_KMC_DATA_BASE (NAME) =
; M 0144 %if %declared (NAME)
; M 0145 %then map NAME : ref KMC_DATA_BASE
; M 0146 %else bind NAME = .MCB$GAW_PROCESS_DATA_BASE [1] : KMC_DATA_BASE
; 0147 %fi %;
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 4
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (2)
; 0148 routine DEVICE_BROKEN (DB) : LINKAGE_DB novalue =
; 0149
; 0150 !++
; 0151 ! FUNCTIONAL DESCRIPTION:
; 0152 !
; 0153 !
; 0154 ! FORMAL PARAMETERS:
; 0155 ! None
; 0156 !
; 0157 ! IMPLICIT INPUTS:
; 0158 ! None
; 0159 !
; 0160 ! IMPLICIT OUTPUTS:
; 0161 ! None
; 0162 !
; 0163 ! ROUTINE VALUE:
; 0164 ! COMPLETION CODES:
; 0165 ! None
; 0166 !
; 0167 ! SIDE EFFECTS:
; 0168 ! None
; 0169 !--
; 0170
; 0171 begin
; 0172 GET_KMC_DATA_BASE (DB);
; 0173 begin
; 0174
; 0175 bind
; 0176 CSR = DB [K_REGISTER] : ref block field (KDP_FIELDS);
; 0177
; 0178 DB [K_TIM] = 0;
; 0179 CSR [SEL0] = BIT_MASK [MCL]; ! Master Clear the KMC
; 0180 end;
; 0181 DB [KF_MICROCODE_RUNNING] = FALSE;
; 0182 DB [KF_MICROCODE_LOADED] = FALSE; %(force a reload)%
; 0183 begin ! Notify all the DUP processes
; 0184
; 0185 local
; 0186 CNT,
; 0187 PTR;
; 0188
; 0189 PTR = ch$ptr (DB [K_UNITS],, 8);
; 0190 CNT = ch$rchar_a (PTR);
; 0191
; 0192 do
; 0193 begin
; 0194
; 0195 bind
; 0196 REG = DB [K_OUTPUT_DATA] : block field (KDP_FIELDS);
; 0197
; 0198 local
; 0199 PIX;
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 5
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (2)
; 0200
; 0201 PIX = ch$rchar_a (PTR);
; 0202
; 0203 if .PIX<0, 8, 0> neq 0
; 0204 then
; 0205 CALL$P (COBAD, .PIX, REG [SEL0]);
; 0206
; 0207 end
; 0208 while (CNT = .CNT - 1) neq 0;
; 0209
; 0210 end;
; 0211 begin
; 0212
; 0213 bind
; 0214 BUF = .DB [K_INPUT_DATA] : block field (KDP_FIELDS);
; 0215
; 0216 while TRUE do
; 0217 begin
; 0218
; 0219 local
; 0220 CCB : ref block field (C_FIELDS);
; 0221
; 0222 if not $MCB_DEQUEUE_CCB (DB [K_INPUT_QUEUE], CCB) then exitloop;
; 0223
; 0224 begin
; 0225
; 0226 bind routine
; 0227 SERVICE_INPUT = .CCB [C_STS];
; 0228
; 0229 CALL$P (SERVICE_INPUT, .CCB [C_LIX], .CCB, BUF [SEL4]);
; 0230 end;
; 0231 end;
; 0232
; 0233 end;
; 0234 end; !of routine DEVICE_BROKEN
.TITLE KDPKMC
.IDENT /X04040/
000000 .PSECT $PLIT$, RO , D
000000 000000G P.AAA: .WORD $DSPCR
000002 000000G .WORD $DSPCR
000004 000000G .WORD $DSPCR
000006 000000G .WORD $DSPCR
000010 000000G .WORD $DSPCR
000012 000000V .WORD KMCTIM
000014 000000G .WORD $DSPCR
000016 000000G .WORD $DSPCR
000020 000000G .WORD $DSPCR
000022 000000G .WORD $DSPCR
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 6
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (2)
.GLOBL $DSPCR, COBAD, COCTL, CORBA, COTBA
.GLOBL KMCNXM, .CRDAT, .CRPIX, .CRDSP
.GLOBL $CALLP, $CMQRM
000034 K.LEN== 34
000000' KMC.DISPATCH= P.AAA
.SBTTL DEVICE.BROKEN
000000 .PSECT $CODE$, RO
000000 004167 000000G DEVICE.BROKEN:
JSR R1,$SAVE4 ; 0148
000004 105015 CLRB (R5) ; DB 0178
000006 012775 040000 000002 MOV #40000,@2(R5) ; *,*(DB) 0179
000014 042715 001400 BIC #1400,(R5) ; *,DB 0182
000020 012703 000027 MOV #27,R3 ; *,PTR 0189
000024 060503 ADD R5,R3 ; DB,PTR
000026 005004 CLR R4 ; CNT 0190
000030 152304 BISB (R3)+,R4 ; PTR,CNT
000032 012701 000020 MOV #20,R1 ; 0196
000036 060501 ADD R5,R1 ; DB,*
000040 005000 1$: CLR R0 ; PIX 0201
000042 152300 BISB (R3)+,R0 ; PTR,PIX
000044 001412 BEQ 2$ ; 0203
000046 010146 MOV R1,-(SP) ; 0205
000050 012746 000001 MOV #1,-(SP)
000054 012746 000000G MOV #COBAD,-(SP)
000060 010046 MOV R0,-(SP) ; PIX,*
000062 004767 000000G JSR PC,$CALLP
000066 062706 000010 ADD #10,SP
000072 077416 2$: SOB R4,1$ ; CNT,* 0208
000074 016501 000016 MOV 16(R5),R1 ; *(DB),* 0211
000100 012703 000012 MOV #12,R3 ; 0222
000104 060503 ADD R5,R3 ; DB,*
000106 004767 000000G 3$: JSR PC,$CMQRM
000112 103421 BCS 4$
000114 010400 MOV R4,R0 ; $MCB$R4,CCB
000116 010146 MOV R1,-(SP) ; 0229
000120 062716 000004 ADD #4,(SP)
000124 010046 MOV R0,-(SP) ; CCB,*
000126 012746 000002 MOV #2,-(SP)
000132 016046 000014 MOV 14(R0),-(SP) ; *(CCB),*
000136 005046 CLR -(SP)
000140 116016 000010 MOVB 10(R0),(SP) ; *(CCB),*
000144 004767 000000G JSR PC,$CALLP
000150 062706 000012 ADD #12,SP ; 0217
000154 000754 BR 3$ ; 0216
000156 000207 4$: RTS PC ; 0148
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 7
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (2)
; Routine Size: 56 words, Routine Base: $CODE$ + 0000
; Maximum stack depth per invocation: 11 words
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 8
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (3)
; 0235 routine INPUT_TRANSFER (DB) : LINKAGE_DB novalue =
; 0236
; 0237 !++
; 0238 ! FUNCTIONAL DESCRIPTION:
; 0239 !
; 0240 !
; 0241 ! FORMAL PARAMETERS:
; 0242 ! None
; 0243 !
; 0244 ! IMPLICIT INPUTS:
; 0245 ! None
; 0246 !
; 0247 ! IMPLICIT OUTPUTS:
; 0248 ! None
; 0249 !
; 0250 ! ROUTINE VALUE:
; 0251 ! COMPLETION CODES:
; 0252 ! None
; 0253 !
; 0254 ! SIDE EFFECTS:
; 0255 ! None
; 0256 !--
; 0257
; 0258 begin
; 0259 GET_KMC_DATA_BASE (DB);
; 0260
; 0261 bind
; 0262 CSR = DB [K_REGISTER] : ref block field (KDP_FIELDS);
; 0263
; 0264 local
; 0265 CCB : ref block field (C_FIELDS);
; 0266
; 0267 DB [K_TIM] = 0;
; 0268
; 0269 if not CMQRM$ (DB [K_INPUT_QUEUE], CCB)
; 0270 then
; 0271 CSR [$SUB_FIELD (SEL0, RQI)] = 0;
; 0272
; 0273 begin
; 0274
; 0275 bind
; 0276 BUF = .DB [K_INPUT_DATA] : block field (KDP_FIELDS);
; 0277
; 0278 CSR [SEL6] = .BUF [SEL6];
; 0279 CSR [SEL4] = .BUF [SEL4];
; 0280 CSR [SEL2] = .BUF [SEL2];
; 0281 end;
; 0282
; 0283 if not .CSR [$SUB_FIELD (SEL0, RQI)] then return;
; 0284
; 0285 begin
; 0286
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 9
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (3)
; 0287 bind
; 0288 BUF = .DB [K_INPUT_DATA] : block field (KDP_FIELDS);
; 0289
; 0290 bind routine
; 0291 SERVICE_INPUT = .CCB [C_STS];
; 0292
; 0293 DB [K_TIM] = REQUEST_TIMEOUT;
; 0294 BUF [BSEL3] = .CCB [C_LIX];
; 0295 BUF [BSEL2] = CALL$P (SERVICE_INPUT, .CCB [C_PIX], .CCB, BUF [SEL4]);
; 0296 end;
; 0297 end; !of routine INPUT_TRANSFER
.SBTTL INPUT.TRANSFER
000000 004167 000000G INPUT.TRANSFER:
JSR R1,$SAVE4 ; 0235
000004 105015 CLRB (R5) ; DB 0267
000006 012703 000012 MOV #12,R3 ; 0269
000012 060503 ADD R5,R3 ; DB,*
000014 004767 000000G JSR PC,$CMQRM
000020 103402 BCS 1$
000022 010403 MOV R4,R3 ; $MCB$R4,CCB
000024 000403 BR 2$
000026 142775 000200 000002 1$: BICB #200,@2(R5) ; *,*(DB) 0271
000034 016504 000016 2$: MOV 16(R5),R4 ; *(DB),* 0276
000040 016500 000002 MOV 2(R5),R0 ; *(DB),* 0278
000044 016460 000006 000006 MOV 6(R4),6(R0)
000052 016460 000004 000004 MOV 4(R4),4(R0) ; 0279
000060 016460 000002 000002 MOV 2(R4),2(R0) ; 0280
000066 105710 TSTB (R0) ; 0283
000070 100026 BPL 3$
000072 112715 000002 MOVB #2,(R5) ; *,DB 0293
000076 116364 000010 000003 MOVB 10(R3),3(R4) ; *(CCB),* 0294
000104 010446 MOV R4,-(SP) ; 0295
000106 062716 000004 ADD #4,(SP)
000112 010346 MOV R3,-(SP) ; CCB,*
000114 012746 000002 MOV #2,-(SP)
000120 016346 000014 MOV 14(R3),-(SP) ; *(CCB),*
000124 005046 CLR -(SP)
000126 116316 000011 MOVB 11(R3),(SP) ; *(CCB),*
000132 004767 000000G JSR PC,$CALLP
000136 110064 000002 MOVB R0,2(R4)
000142 062706 000012 ADD #12,SP ; 0258
000146 000207 3$: RTS PC ; 0235
; Routine Size: 52 words, Routine Base: $CODE$ + 0160
; Maximum stack depth per invocation: 11 words
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 10
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (4)
; 0298 routine KMC_INTERRUPT (DB) : MCB_INTERRUPT novalue =
; 0299
; 0300 !++
; 0301 ! FUNCTIONAL DESCRIPTION:
; 0302 !
; 0303 !
; 0304 ! FORMAL PARAMETERS:
; 0305 ! DB = address of KMC data base.
; 0306 !
; 0307 ! IMPLICIT INPUTS:
; 0308 ! None
; 0309 !
; 0310 ! IMPLICIT OUTPUTS:
; 0311 ! None
; 0312 !
; 0313 ! ROUTINE VALUE:
; 0314 ! COMPLETION CODES:
; 0315 ! None
; 0316 !
; 0317 ! SIDE EFFECTS:
; 0318 ! None
; 0319 !--
; 0320
; 0321 begin
; 0322 GET_KMC_DATA_BASE (DB);
; 0323 begin
; 0324
; 0325 bind
; 0326 CSR = DB [K_REGISTER] : ref block field (KDP_FIELDS);
; 0327
; 0328 CSR [$SUB_FIELD (BSEL0, IEI)] = 0;
; 0329 CSR [$SUB_FIELD (BSEL0, IEO)] = 0;
; 0330 end;
; 0331 SYNCH$ (.DB [K_SYNCH_BLOCK], SERVICE_KMC);
; 0332 end; !of routine KMC_INTERRUPT
.GLOBL $SYNCH
.SBTTL KMC.INTERRUPT
000000 142775 000001 000002 KMC.INTERRUPT:
BICB #1,@2(R5) ; *,*(DB) 0328
000006 142775 000020 000002 BICB #20,@2(R5) ; *,*(DB) 0329
000014 016504 000010 MOV 10(R5),R4 ; *(DB),* 0331
000020 012764 000000V 000004 MOV #SERVICE.KMC,4(R4)
000026 004767 000000G JSR PC,$SYNCH
000032 000207 RTS PC ; 0298
; Routine Size: 14 words, Routine Base: $CODE$ + 0330
; Maximum stack depth per invocation: 1 word
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 11
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (5)
; 0333 global routine KMCDB (BIAS, ADDRESS) : CALL$ novalue =
; 0334
; 0335 !++
; 0336 ! FUNCTIONAL DESCRIPTION:
; 0337 !
; 0338 !
; 0339 ! FORMAL PARAMETERS:
; 0340 ! BIAS = data base bias.
; 0341 ! ADDRESS = data base address.
; 0342 !
; 0343 ! IMPLICIT INPUTS:
; 0344 ! None
; 0345 !
; 0346 ! IMPLICIT OUTPUTS:
; 0347 ! None
; 0348 !
; 0349 ! ROUTINE VALUE:
; 0350 ! COMPLETION CODES:
; 0351 ! None
; 0352 !
; 0353 ! SIDE EFFECTS:
; 0354 ! None
; 0355 !--
; 0356
; 0357 begin
; 0358 DB_BIAS = .BIAS;
; 0359 DB = .ADDRESS;
; 0360 MCB$GA_PROCESS_DISPATCH = KMC_DISPATCH;
; 0361 end; !of routine KMCDB
.SBTTL KMCDB
000000 016567 000002 000000G KMCDB:: MOV 2(R5),.CRDAT ; BIAS(.AP.),* 0358
000006 016567 000004 000002G MOV 4(R5),.CRDAT+2 ; ADDRESS(.AP.),* 0359
000014 012767 000000' 000000G MOV #KMC.DISPATCH,.CRDSP ; 0360
000022 000207 RTS PC ; 0333
; Routine Size: 10 words, Routine Base: $CODE$ + 0364
; Maximum stack depth per invocation: 0 words
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 12
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (6)
; 0362 global routine KMCPRM (CCB) : CALL$ novalue =
; 0363
; 0364 !++
; 0365 ! FUNCTIONAL DESCRIPTION:
; 0366 !
; 0367 !
; 0368 ! FORMAL PARAMETERS:
; 0369 ! CCB = CCB to insert parameters into
; 0370 !
; 0371 ! IMPLICIT INPUTS:
; 0372 ! None
; 0373 !
; 0374 ! IMPLICIT OUTPUTS:
; 0375 ! None
; 0376 !
; 0377 ! ROUTINE VALUE:
; 0378 ! COMPLETION CODES:
; 0379 ! None
; 0380 !
; 0381 ! SIDE EFFECTS:
; 0382 ! None
; 0383 !--
; 0384
; 0385 begin
; 0386
; 0387 map
; 0388 CCB : ref block field (C_FIELDS);
; 0389
; 0390 stacklocal
; 0391 SAVE_MAP;
; 0392
; 0393 SMAP$ (SAVE_MAP);
; 0394 MAP$ (.DB_BIAS);
; 0395 begin
; 0396 GET_KMC_DATA_BASE (DB);
; 0397 CCB [C_PRM1] = .DB [K_REGISTER];
; 0398 CCB [C_PRM3] = .DB [K_VECTOR];
; 0399 CCB [C_PRM4] = .DB [K_PRIORITY];
; 0400 end;
; 0401 MAP$ (.SAVE_MAP);
; 0402 end; !of routine KMCPRM
.GLOBL KISAR6
.SBTTL KMCPRM
000000 016746 000000G KMCPRM::MOV KISAR6,-(SP) ; *,SAVE.MAP 0393
000004 016767 000000G 000000G MOV .CRDAT,KISAR6 ; 0394
000012 016500 000002 MOV 2(R5),R0 ; CCB(.AP.),* 0397
000016 016701 000002G MOV .CRDAT+2,R1
000022 016160 000002 000024 MOV 2(R1),24(R0)
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 13
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (6)
000030 016160 000004 000030 MOV 4(R1),30(R0) ; 0398
000036 116102 000006 MOVB 6(R1),R2 ; 0399
000042 010260 000032 MOV R2,32(R0)
000046 012667 000000G MOV (SP)+,KISAR6 ; SAVE.MAP,* 0401
000052 000207 RTS PC ; 0362
; Routine Size: 22 words, Routine Base: $CODE$ + 0410
; Maximum stack depth per invocation: 1 word
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 14
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (7)
; 0403 global routine KMCQUE (CCB) : CALL$ novalue =
; 0404
; 0405 !++
; 0406 ! FUNCTIONAL DESCRIPTION:
; 0407 !
; 0408 !
; 0409 ! FORMAL PARAMETERS:
; 0410 ! CCB = address of request CCB.
; 0411 !
; 0412 ! IMPLICIT INPUTS:
; 0413 ! None
; 0414 !
; 0415 ! IMPLICIT OUTPUTS:
; 0416 ! None
; 0417 !
; 0418 ! ROUTINE VALUE:
; 0419 ! COMPLETION CODES:
; 0420 ! None
; 0421 !
; 0422 ! SIDE EFFECTS:
; 0423 ! None
; 0424 !--
; 0425
; 0426 begin
; 0427
; 0428 map
; 0429 CCB : ref block field (C_FIELDS);
; 0430
; 0431 stacklocal
; 0432 SAVE_MAP;
; 0433
; 0434 SMAP$ (SAVE_MAP);
; 0435 MAP$ (.DB_BIAS);
; 0436 begin
; 0437
; 0438 bind
; 0439 BUF = .DB [K_INPUT_DATA] : block field (KDP_FIELDS),
; 0440 CSR = DB [K_REGISTER] : ref block field (KDP_FIELDS);
; 0441
; 0442 GET_KMC_DATA_BASE (DB);
; 0443
; 0444 if not .DB [KF_MICROCODE_RUNNING]
; 0445 then
; 0446 begin
; 0447
; 0448 bind routine
; 0449 SERVICE_INPUT = .CCB [C_STS];
; 0450
; 0451 BUF [BSEL2] = CALL$P (SERVICE_INPUT, .CCB [C_PIX], .CCB, BUF [SEL4]);
; 0452 end
; 0453 else
; 0454
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 15
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (7)
; 0455 if .CSR [$SUB_FIELD (SEL0, RQI)]
; 0456 then
; 0457 CMQIN$ (DB [K_INPUT_QUEUE], .CCB)
; 0458 else
; 0459 begin
; 0460
; 0461 bind routine
; 0462 SERVICE_INPUT = .CCB [C_STS];
; 0463
; 0464 CSR [$SUB_FIELD (SEL0, RQI)] = 1;
; 0465 DB [K_TIM] = REQUEST_TIMEOUT;
; 0466 BUF [BSEL3] = .CCB [C_LIX];
; 0467 BUF [BSEL2] = CALL$P (SERVICE_INPUT, .CCB [C_PIX], .CCB, BUF [SEL4]);
; 0468 end;
; 0469
; 0470 end;
; 0471 MAP$ (.SAVE_MAP);
; 0472 end; !of routine KMCQUE
.GLOBL $CMQIN
.SBTTL KMCQUE
000000 016746 000000G KMCQUE::MOV KISAR6,-(SP) ; *,SAVE.MAP 0434
000004 016767 000000G 000000G MOV .CRDAT,KISAR6 ; 0435
000012 016700 000002G MOV .CRDAT+2,R0 ; 0439
000016 016001 000016 MOV 16(R0),R1 ; 0436
000022 016504 000002 MOV 2(R5),R4 ; CCB(.AP.),* 0449
000026 032710 001000 BIT #1000,(R0) ; 0444
000032 001421 BEQ 2$ ; 0451
000034 105770 000002 TSTB @2(R0) ; 0455
000040 100006 BPL 1$
000042 012703 000012 MOV #12,R3 ; 0457
000046 060003 ADD R0,R3
000050 004767 000000G JSR PC,$CMQIN
000054 000431 BR 3$ ; 0455
000056 152770 000200 000002 1$: BISB #200,@2(R0) ; 0464
000064 112710 000002 MOVB #2,(R0) ; 0465
000070 116461 000010 000003 MOVB 10(R4),3(R1) ; 0466
000076 010146 2$: MOV R1,-(SP) ; 0467
000100 062716 000004 ADD #4,(SP)
000104 010446 MOV R4,-(SP)
000106 012746 000002 MOV #2,-(SP)
000112 016446 000014 MOV 14(R4),-(SP)
000116 005046 CLR -(SP)
000120 116416 000011 MOVB 11(R4),(SP)
000124 004767 000000G JSR PC,$CALLP
000130 110061 000002 MOVB R0,2(R1)
000134 062706 000012 ADD #12,SP ; 0459
000140 012667 000000G 3$: MOV (SP)+,KISAR6 ; SAVE.MAP,* 0471
000144 000207 RTS PC ; 0403
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 16
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (7)
; Routine Size: 51 words, Routine Base: $CODE$ + 0464
; Maximum stack depth per invocation: 7 words
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 17
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (8)
; 0473 global routine KMCSTP (UNIT) : CALL$ novalue =
; 0474
; 0475 !++
; 0476 ! FUNCTIONAL DESCRIPTION:
; 0477 !
; 0478 !
; 0479 ! FORMAL PARAMETERS:
; 0480 ! UNIT = DUP unit number on KMC
; 0481 !
; 0482 ! IMPLICIT INPUTS:
; 0483 ! None
; 0484 !
; 0485 ! IMPLICIT OUTPUTS:
; 0486 ! None
; 0487 !
; 0488 ! ROUTINE VALUE:
; 0489 ! COMPLETION CODES:
; 0490 ! None
; 0491 !
; 0492 ! SIDE EFFECTS:
; 0493 ! None
; 0494 !--
; 0495
; 0496 begin
; 0497
; 0498 macro
; M 0499 $return =
; M 0500 begin
; M 0501 MAP$ (.SAVE_MAP);
; M 0502 return
; 0503 end %;
; 0504
; 0505 stacklocal
; 0506 SAVE_MAP;
; 0507
; 0508 SMAP$ (SAVE_MAP);
; 0509 MAP$ (.DB_BIAS);
; 0510 begin
; 0511 GET_KMC_DATA_BASE (DB);
; 0512
; 0513 local
; 0514 PTR;
; 0515
; 0516 PTR = ch$ptr (DB [K_UNITS],, 8);
; 0517
; 0518 if ch$rchar_a (PTR) lequ .UNIT<0, 8, 0> then $return;
; 0519
; 0520 PTR = ch$plus (.PTR, .UNIT);
; 0521
; 0522 if ch$rchar (.PTR) eql 0 then $return;
; 0523
; 0524 DB [K_ACTIVE] = .DB [K_ACTIVE] - 1;
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 18
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (8)
; 0525
; 0526 if .DB [K_ACTIVE] eql 0
; 0527 then
; 0528 if .DB [KF_MICROCODE_RUNNING]
; 0529 then
; 0530 begin
; 0531
; 0532 bind
; 0533 REG = DB [K_REGISTER] : ref block field (KDP_FIELDS);
; 0534
; 0535 DB [K_TIM] = 0;
; 0536 REG [SEL0] = BIT_MASK [MCL];
; 0537 DB [KF_MICROCODE_RUNNING] = FALSE;
; 0538 end;
; 0539
; 0540 ch$wchar (0, .PTR);
; 0541 end;
; 0542 MAP$ (.SAVE_MAP);
; 0543 end; !of routine KMCSTP
.SBTTL KMCSTP
000000 016746 000000G KMCSTP::MOV KISAR6,-(SP) ; *,SAVE.MAP 0508
000004 016767 000000G 000000G MOV .CRDAT,KISAR6 ; 0509
000012 016701 000002G MOV .CRDAT+2,R1 ; 0516
000016 012700 000027 MOV #27,R0 ; *,PTR
000022 060100 ADD R1,R0 ; *,PTR
000024 122065 000002 CMPB (R0)+,2(R5) ; PTR,UNIT(.AP.) 0518
000030 101421 BLOS 2$
000032 066500 000002 ADD 2(R5),R0 ; UNIT(.AP.),PTR 0520
000036 105710 TSTB (R0) ; PTR 0522
000040 001415 BEQ 2$
000042 105361 000026 DECB 26(R1) ; 0524
000046 001011 BNE 1$ ; 0526
000050 032711 001000 BIT #1000,(R1) ; 0528
000054 001406 BEQ 1$
000056 105011 CLRB (R1) ; 0535
000060 012771 040000 000002 MOV #40000,@2(R1) ; 0536
000066 042711 001000 BIC #1000,(R1) ; 0537
000072 105010 1$: CLRB (R0) ; PTR 0540
000074 012667 000000G 2$: MOV (SP)+,KISAR6 ; SAVE.MAP,* 0542
000100 000207 RTS PC ; 0473
; Routine Size: 33 words, Routine Base: $CODE$ + 0632
; Maximum stack depth per invocation: 1 word
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 19
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (9)
; 0544 global routine KMCSTR (UNIT, PIX) : CALL$ =
; 0545
; 0546 !++
; 0547 ! FUNCTIONAL DESCRIPTION:
; 0548 !
; 0549 !
; 0550 ! FORMAL PARAMETERS:
; 0551 ! UNIT = DUP unit number on KMC
; 0552 ! PIX = PIX if DUP process.
; 0553 !
; 0554 ! IMPLICIT INPUTS:
; 0555 ! None
; 0556 !
; 0557 ! IMPLICIT OUTPUTS:
; 0558 ! None
; 0559 !
; 0560 ! ROUTINE VALUE:
; 0561 ! COMPLETION CODES:
; 0562 ! None
; 0563 !
; 0564 ! SIDE EFFECTS:
; 0565 ! None
; 0566 !--
; 0567
; 0568 begin
; 0569
; 0570 macro
; M 0571 $return (STS) =
; M 0572 begin
; M 0573 MAP$ (.SAVE_MAP);
; M 0574 return STS
; 0575 end %;
; 0576
; 0577 stacklocal
; 0578 SAVE_MAP;
; 0579
; 0580 SMAP$ (SAVE_MAP);
; 0581 MAP$ (.DB_BIAS);
; 0582 begin
; 0583
; 0584 local
; 0585 PTR;
; 0586
; 0587 GET_KMC_DATA_BASE (DB);
; 0588 PTR = ch$ptr (DB [K_UNITS],, 8);
; 0589
; 0590 if ch$rchar_a (PTR) lequ .UNIT<0, 8, 0> then $return (FALSE);
; 0591
; 0592 PTR = ch$plus (.PTR, .UNIT);
; 0593
; 0594 if ch$rchar (.PTR) neq 0 then $return (FALSE);
; 0595
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 20
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (9)
; 0596 if .DB [K_ACTIVE] eql 0
; 0597 then
; 0598 begin
; 0599
; 0600 if not .DB [KF_MICROCODE_LOADED]
; 0601 then
; 0602 begin
; 0603
; 0604 external
; 0605 $KDPMC : ref vector;
; 0606
; 0607 external literal
; 0608 $KDPML;
; 0609
; 0610 if .DB [K_REGISTER] lssu %o'160000' then $return (FALSE);
; 0611
; 0612 if REGISTER_NXM (.DB [K_REGISTER], 4) then $return (FALSE);
; 0613
; 0614 if not $MCB_SET_VECTOR (.DB [K_VECTOR], KMC_INTERRUPT, .DB [K_PRIORITY])
; 0615 then
; 0616 $return (FALSE);
; 0617
; 0618 if not $MCB_SET_VECTOR (.DB [K_VECTOR] + 4, KMC_INTERRUPT, .DB [K_PRIORITY])
; 0619 then
; 0620 begin
; 0621 $MCB_CLEAR_VECTOR (.DB [K_VECTOR]);
; 0622 $return (FALSE);
; 0623 end;
; 0624
; 0625 if not LOAD_MICROCODE (.DB [K_REGISTER], $KDPMC, $KDPML^5)
; 0626 then
; 0627 $return (FALSE);
; 0628
; 0629 DB [KF_MICROCODE_LOADED] = TRUE;
; 0630 end;
; 0631
; 0632 if not .DB [KF_MICROCODE_RUNNING]
; 0633 then
; 0634 begin
; 0635
; 0636 if not START_MICROCODE (.DB [K_REGISTER]) then $return (FALSE);
; 0637
; 0638 DB [KF_MICROCODE_RUNNING] = TRUE;
; 0639 end;
; 0640
; 0641 end;
; 0642
; 0643 DB [K_ACTIVE] = .DB [K_ACTIVE] + 1;
; 0644 ch$wchar (.PIX, .PTR);
; 0645 end;
; 0646 MAP$ (.SAVE_MAP);
; 0647 TRUE
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 21
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (9)
; 0648 end; !of routine KMCSTR
.GLOBL $KDPMC, $KDPML, V.ECST, $CALLI
.GLOBL V.ECCL
.SBTTL KMCSTR
000000 016746 000000G KMCSTR::MOV KISAR6,-(SP) ; *,SAVE.MAP 0580
000004 016767 000000G 000000G MOV .CRDAT,KISAR6 ; 0581
000012 016702 000002G MOV .CRDAT+2,R2 ; 0588
000016 012704 000027 MOV #27,R4 ; *,PTR
000022 060204 ADD R2,R4 ; *,PTR
000024 122465 000002 CMPB (R4)+,2(R5) ; PTR,UNIT(.AP.) 0590
000030 101555 BLOS 3$
000032 066504 000002 ADD 2(R5),R4 ; UNIT(.AP.),PTR 0592
000036 105714 TSTB (R4) ; PTR 0594
000040 001151 BNE 3$
000042 105762 000026 TSTB 26(R2) ; 0596
000046 001155 BNE 6$
000050 032712 000400 BIT #400,(R2) ; 0600
000054 001127 BNE 2$
000056 026227 000002 160000 CMP 2(R2),#160000 ; 0610
000064 103537 BLO 3$
000066 016200 000002 MOV 2(R2),R0 ; 0612
000072 012701 000004 MOV #4,R1
000076 004767 000000G JSR PC,KMCNXM
000102 006000 ROR R0
000104 103527 BLO 3$
000106 016700 000002G MOV .CRDAT+2,R0 ; 0614
000112 116001 000006 MOVB 6(R0),R1
000116 010146 MOV R1,-(SP)
000120 012746 000330' MOV #KMC.INTERRUPT,-(SP)
000124 016046 000004 MOV 4(R0),-(SP)
000130 012746 000003 MOV #3,-(SP)
000134 012746 000000G MOV #V.ECST,-(SP)
000140 004767 000000G JSR PC,$CALLI
000144 062706 000012 ADD #12,SP
000150 032700 000001 BIT #1,R0
000154 001503 BEQ 3$ ; 0616
000156 016700 000002G MOV .CRDAT+2,R0 ; 0618
000162 116001 000006 MOVB 6(R0),R1
000166 010146 MOV R1,-(SP)
000170 012746 000330' MOV #KMC.INTERRUPT,-(SP)
000174 016046 000004 MOV 4(R0),-(SP)
000200 062716 000004 ADD #4,(SP)
000204 012746 000003 MOV #3,-(SP)
000210 012746 000000G MOV #V.ECST,-(SP)
000214 004767 000000G JSR PC,$CALLI
000220 062706 000012 ADD #12,SP
000224 032700 000001 BIT #1,R0
000230 001020 BNE 1$
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 22
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (9)
000232 016700 000002G MOV .CRDAT+2,R0 ; 0621
000236 016046 000004 MOV 4(R0),-(SP)
000242 012746 000001 MOV #1,-(SP)
000246 012746 000000G MOV #V.ECCL,-(SP)
000252 004767 000000G JSR PC,$CALLI
000256 016667 000006 000000G MOV 6(SP),KISAR6 ; SAVE.MAP,* 0622
000264 062706 000006 ADD #6,SP ; 0618
000270 000437 BR 4$ ; 0620
000272 016700 000002G 1$: MOV .CRDAT+2,R0 ; 0625
000276 012703 000000G MOV #$KDPML,R3
000302 072327 000005 ASH #5,R3
000306 016001 000002 MOV 2(R0),R1
000312 012702 000000G MOV #$KDPMC,R2
000316 004767 000000V JSR PC,LOAD.MICROCODE
000322 006000 ROR R0
000324 103017 BHIS 3$ ; 0627
000326 052777 000400 000002G BIS #400,@.CRDAT+2 ; 0629
000334 032777 001000 000002G 2$: BIT #1000,@.CRDAT+2 ; 0632
000342 001017 BNE 6$
000344 016700 000002G MOV .CRDAT+2,R0 ; 0636
000350 016001 000002 MOV 2(R0),R1
000354 004767 000000V JSR PC,START.MICROCODE
000360 006000 ROR R0
000362 103404 BLO 5$
000364 011667 000000G 3$: MOV (SP),KISAR6 ; SAVE.MAP,*
000370 005000 4$: CLR R0
000372 000415 BR 7$
000374 052777 001000 000002G 5$: BIS #1000,@.CRDAT+2 ; 0638
000402 016700 000002G 6$: MOV .CRDAT+2,R0 ; 0643
000406 105260 000026 INCB 26(R0)
000412 116514 000004 MOVB 4(R5),(R4) ; PIX(.AP.),PTR 0644
000416 011667 000000G MOV (SP),KISAR6 ; SAVE.MAP,* 0646
000422 012700 000001 MOV #1,R0 ; 0544
000426 005726 7$: TST (SP)+
000430 000207 RTS PC
; Routine Size: 141 words, Routine Base: $CODE$ + 0734
; Maximum stack depth per invocation: 7 words
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 23
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (10)
; 0649 routine KMCTIM (DB, MODIFIER) : MCB_DB_MOD novalue =
; 0650
; 0651 !++
; 0652 ! FUNCTIONAL DESCRIPTION:
; 0653 !
; 0654 !
; 0655 ! FORMAL PARAMETERS:
; 0656 ! MODIFIER = timer function modifier.
; 0657 !
; 0658 ! IMPLICIT INPUTS:
; 0659 ! None
; 0660 !
; 0661 ! IMPLICIT OUTPUTS:
; 0662 ! None
; 0663 !
; 0664 ! ROUTINE VALUE:
; 0665 ! COMPLETION CODES:
; 0666 ! None
; 0667 !
; 0668 ! SIDE EFFECTS:
; 0669 ! None
; 0670 !--
; 0671
; 0672 begin
; P 0673 DISPATCH$ (
; P 0674 .MODIFIER,
; P 0675 TABLE$ ($DSPCR, FD_TIM, ! Timer dispatch table:
; P 0676 (FM_LTM, TIMLTM), ! Long timer
; P 0677 (FM_PWF, TIMPWF), ! Power failure
; P 0678 (FM_PIN, TIMPIN)), ! Process initialization
; P 0679 (.DB),
; 0680 MCB_DB);
; 0681 end; !of routine KMCTIM
000024 .PSECT $PLIT$, RO , D
000024 000000G P.AAB: .WORD $DSPCR
000026 000000V .WORD TIMLTM
000030 000000V .WORD TIMPWF
000032 000000V .WORD TIMPIN
000034 000000G .WORD $DSPCR
000036 000000G .WORD $DSPCR
.SBTTL KMCTIM
001366 .PSECT $CODE$, RO
000000 004773 000024' KMCTIM: JSR PC,@P.AAB(R3) ; *,*(MODIFIER) 0680
000004 000207 RTS PC ; 0649
; Routine Size: 3 words, Routine Base: $CODE$ + 1366
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 24
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (10)
; Maximum stack depth per invocation: 1 word
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 25
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (11)
; 0682 routine LOAD_MICROCODE (CSR, MC, LNG) : KDP_CSR_MC_LNG =
; 0683
; 0684 !++
; 0685 ! FUNCTIONAL DESCRIPTION:
; 0686 !
; 0687 !
; 0688 ! FORMAL PARAMETERS:
; 0689 ! CSR = address of KMC SEL0 register
; 0690 !
; 0691 ! IMPLICIT INPUTS:
; 0692 ! None
; 0693 !
; 0694 ! IMPLICIT OUTPUTS:
; 0695 ! None
; 0696 !
; 0697 ! ROUTINE VALUE:
; 0698 ! COMPLETION CODES:
; 0699 ! None
; 0700 !
; 0701 ! SIDE EFFECTS:
; 0702 ! None
; 0703 !--
; 0704
; 0705 begin
; 0706
; 0707 map
; 0708 CSR : ref block field (KDP_FIELDS),
; 0709 MC : ref vector;
; 0710
; 0711 local
; 0712 ADR;
; 0713
; 0714 incra ADDR from CSR [SEL0] to CSR [SEL6] by %upval do .ADDR = 0;
; 0715
; 0716 ADR = 0;
; 0717
; 0718 do
; 0719 begin
; 0720
; 0721 map
; 0722 CSR : ref block field (KDP_FIELDS) volatile;
; 0723
; 0724 CSR [SEL0] = 4^8;
; 0725 CSR [SEL4] = .ADR;
; 0726 CSR [SEL6] = .MC [0];
; 0727 CSR [$SUB_FIELD (BSEL1, 0, 5, 1, 0)] = 1;
; 0728 CSR [SEL0] = 0;
; 0729 CSR [SEL4] = 0;
; 0730 CSR [SEL6] = 0;
; 0731 CSR [SEL0] = 4^8;
; 0732 CSR [SEL4] = .ADR;
; 0733
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 26
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (11)
; 0734 if .MC [0] neq .CSR [SEL6]
; 0735 then
; 0736 begin
; 0737 COUNTER_INCREMENT (DB, K_MICROCODE_WONT_LOAD);
; 0738 COUNTER_INCREMENT (DB, K_DEVICE_ERRORS);
; 0739 return FALSE;
; 0740 end;
; 0741
; 0742 MC = MC [1];
; 0743 ADR = .ADR + 1;
; 0744 end
; 0745 until (LNG = .LNG - 1) eql 0;
; 0746
; 0747 incra ADDR from CSR [SEL0] to CSR [SEL6] by %upval do .ADDR = 0;
; 0748
; 0749 TRUE
; 0750 end; !of routine LOAD_MICROCODE
.GLOBL $IC8
.SBTTL LOAD.MICROCODE
000000 004167 000000G LOAD.MICROCODE:
JSR R1,$SAVE5 ; 0682
000004 010104 MOV R1,R4 ; *,CSR
000006 010405 MOV R4,R5 ; CSR,* 0714
000010 062705 000006 ADD #6,R5
000014 000401 BR 2$
000016 005021 1$: CLR (R1)+ ; ADDR
000020 020105 2$: CMP R1,R5 ; ADDR,*
000022 101775 BLOS 1$
000024 005001 CLR R1 ; ADR 0716
000026 012714 002000 3$: MOV #2000,(R4) ; *,CSR 0724
000032 010164 000004 MOV R1,4(R4) ; ADR,*(CSR) 0725
000036 011264 000006 MOV (R2),6(R4) ; MC,*(CSR) 0726
000042 052714 020000 BIS #20000,(R4) ; *,CSR 0727
000046 005014 CLR (R4) ; CSR 0728
000050 005064 000004 CLR 4(R4) ; *(CSR) 0729
000054 005064 000006 CLR 6(R4) ; *(CSR) 0730
000060 012714 002000 MOV #2000,(R4) ; *,CSR 0731
000064 010164 000004 MOV R1,4(R4) ; ADR,*(CSR) 0732
000070 021264 000006 CMP (R2),6(R4) ; MC,*(CSR) 0734
000074 001413 BEQ 4$
000076 016700 000002G MOV .CRDAT+2,R0 ; 0737
000102 052760 002000 000022 BIS #2000,22(R0)
000110 062700 000022 ADD #22,R0 ; 0738
000114 004767 000000G JSR PC,$IC8
000120 005000 CLR R0 ; 0736
000122 000207 RTS PC
000124 062702 000002 4$: ADD #2,R2 ; *,MC 0742
000130 005201 INC R1 ; ADR 0743
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 27
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (11)
000132 077343 SOB R3,3$ ; LNG,* 0745
000134 010401 MOV R4,R1 ; CSR,ADDR 0747
000136 000401 BR 6$
000140 005021 5$: CLR (R1)+ ; ADDR
000142 020105 6$: CMP R1,R5 ; ADDR,*
000144 101775 BLOS 5$
000146 012700 000001 MOV #1,R0 ; 0682
000152 000207 RTS PC
; Routine Size: 54 words, Routine Base: $CODE$ + 1374
; Maximum stack depth per invocation: 7 words
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 28
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (12)
; 0751 routine OUTPUT_TRANSFER (DB) : LINKAGE_DB novalue =
; 0752
; 0753 !++
; 0754 ! FUNCTIONAL DESCRIPTION:
; 0755 !
; 0756 !
; 0757 ! FORMAL PARAMETERS:
; 0758 ! None
; 0759 !
; 0760 ! IMPLICIT INPUTS:
; 0761 ! None
; 0762 !
; 0763 ! IMPLICIT OUTPUTS:
; 0764 ! None
; 0765 !
; 0766 ! ROUTINE VALUE:
; 0767 ! COMPLETION CODES:
; 0768 ! None
; 0769 !
; 0770 ! SIDE EFFECTS:
; 0771 ! None
; 0772 !--
; 0773
; 0774 begin
; 0775 GET_KMC_DATA_BASE (DB);
; 0776
; 0777 bind
; 0778 REG = .DB [K_OUTPUT_DATA] : block field (KDP_FIELDS);
; 0779
; 0780 begin
; 0781
; 0782 map
; 0783 REG : vector [4];
; 0784
; 0785 bind
; 0786 CSR = .DB [K_REGISTER] : vector [4];
; 0787
; 0788 REG [0] = .CSR [0];
; 0789 REG [1] = .CSR [1];
; 0790 REG [2] = .CSR [2];
; 0791 REG [3] = .CSR [3];
; 0792 block [CSR, BSEL2] = 0;
; 0793 end;
; 0794 begin
; 0795
; 0796 local
; 0797 DUP_NUM;
; 0798
; 0799 if (DUP_NUM = .REG [BSEL3]) lss 0
; 0800 then
; 0801 begin
; 0802 COUNTER_INCREMENT (DB, K_COMPLETION_QUEUE_OVERRUN);
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 29
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (12)
; 0803 COUNTER_INCREMENT (DB, K_PERFORMANCE_ERRORS);
; 0804 DEVICE_BROKEN (DB [K_TIM]);
; 0805 return;
; 0806 end;
; 0807
; 0808 if .DUP_NUM <0, 8, 0> gtru .DB [K_UNITS]
; 0809 then
; 0810 begin
; 0811 COUNTER_INCREMENT (DB, K_INVALID_UNIT);
; 0812 COUNTER_INCREMENT (DB, K_DEVICE_ERRORS);
; 0813 DEVICE_BROKEN (DB [K_TIM]);
; 0814 return;
; 0815 end;
; 0816
; 0817 DUP_NUM = ch$rchar (ch$ptr (DB [K_DUP_PIX], .DUP_NUM, 8));
; 0818
; 0819 if .DUP_NUM<0, 8, 0> eqlu 0
; 0820 then
; 0821 begin
; 0822 COUNTER_INCREMENT (DB, K_INVALID_UNIT);
; 0823 COUNTER_INCREMENT (DB, K_DEVICE_ERRORS);
; 0824 DEVICE_BROKEN (DB [K_TIM]);
; 0825 return;
; 0826 end;
; 0827
; 0828 begin
; 0829
; 0830 bind routine
; 0831 SERVICE_OUTPUT =
; 0832 (case .REG [$SUB_FIELD (SEL2, COM)] from 0 to 7 of
; 0833 set
; 0834 [TBA] : COTBA;
; 0835 [RBA] : CORBA;
; 0836 [CTL, CTL + 4] : COCTL;
; 0837 [inrange] :
; 0838 begin
; 0839 COUNTER_INCREMENT (DB, K_INVALID_OUTPUT_CODE);
; 0840 COUNTER_INCREMENT (DB, K_DEVICE_ERRORS);
; 0841 DEVICE_BROKEN (DB [K_TIM]);
; 0842 return;
; 0843 end;
; 0844 tes) : CALL$ novalue;
; 0845
; 0846 CALL$P (SERVICE_OUTPUT, .DUP_NUM, REG [SEL0]);
; 0847 end;
; 0848 end;
; 0849 end; !of routine OUTPUT_TRANSFER
.SBTTL OUTPUT.TRANSFER
000000 004167 000000G OUTPUT.TRANSFER:
JSR R1,$SAVE5 ; 0751
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 30
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (12)
000004 010502 MOV R5,R2 ; *,DB
000006 016203 000020 MOV 20(R2),R3 ; *(DB),* 0774
000012 016200 000002 MOV 2(R2),R0 ; *(DB),* 0780
000016 011013 MOV (R0),(R3) ; 0788
000020 012704 000002 MOV #2,R4 ; 0789
000024 060304 ADD R3,R4
000026 016014 000002 MOV 2(R0),(R4)
000032 016063 000004 000004 MOV 4(R0),4(R3) ; 0790
000040 016063 000006 000006 MOV 6(R0),6(R3) ; 0791
000046 105060 000002 CLRB 2(R0) ; 0792
000052 116401 000001 MOVB 1(R4),R1 ; *,DUP.NUM 0799
000056 002006 BGE 1$
000060 052762 000400 000024 BIS #400,24(R2) ; *,*(DB) 0802
000066 012700 000024 MOV #24,R0 ; 0803
000072 000441 BR 9$
000074 120162 000027 1$: CMPB R1,27(R2) ; DUP.NUM,*(DB) 0808
000100 101006 BHI 2$ ; 0811
000102 010105 MOV R1,R5 ; DUP.NUM,* 0817
000104 060205 ADD R2,R5 ; DB,*
000106 005001 CLR R1 ; DUP.NUM
000110 156501 000030 BISB 30(R5),R1 ; *,DUP.NUM
000114 001004 BNE 3$ ; 0819
000116 052762 000400 000022 2$: BIS #400,22(R2) ; *,*(DB) 0822
000124 000422 BR 8$ ; 0823
000126 111400 3$: MOVB (R4),R0 ; 0832
000130 042700 177770 BIC #177770,R0
000134 006300 ASL R0
000136 066007 000040' ADD P.AAC(R0),PC ; Case dispatch
000142 012700 000000G 4$: MOV #COTBA,R0
000146 000422 BR 10$
000150 012700 000000G 5$: MOV #CORBA,R0
000154 000417 BR 10$
000156 012700 000000G 6$: MOV #COCTL,R0
000162 000414 BR 10$
000164 052762 001000 000022 7$: BIS #1000,22(R2) ; *,*(DB) 0839
000172 012700 000022 8$: MOV #22,R0 ; 0840
000176 060200 9$: ADD R2,R0 ; DB,*
000200 004767 000000G JSR PC,$IC8
000204 010205 MOV R2,R5 ; DB,* 0841
000206 004767 176016 JSR PC,DEVICE.BROKEN
000212 000207 RTS PC ; 0838
000214 010346 10$: MOV R3,-(SP) ; 0846
000216 012746 000001 MOV #1,-(SP)
000222 010046 MOV R0,-(SP)
000224 010146 MOV R1,-(SP) ; DUP.NUM,*
000226 004767 000000G JSR PC,$CALLP
000232 062706 000010 ADD #10,SP ; 0774
000236 000207 RTS PC ; 0751
; Routine Size: 80 words, Routine Base: $CODE$ + 1550
; Maximum stack depth per invocation: 11 words
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 31
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (12)
000040 .PSECT $PLIT$, RO , D
P.AAC: ; CASE Table for OUTPUT.TRANSFER+0136 0832
000040 000000 .WORD 0 ; [4$]
000042 000014 .WORD 14 ; [6$]
000044 000022 .WORD 22 ; [7$]
000046 000022 .WORD 22 ; [7$]
000050 000006 .WORD 6 ; [5$]
000052 000014 .WORD 14 ; [6$]
000054 000022 .WORD 22 ; [7$]
000056 000022 .WORD 22 ; [7$]
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 32
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (13)
; 0850 routine SERVICE_KMC (DB) : MCB_DB novalue =
; 0851
; 0852 !++
; 0853 ! FUNCTIONAL DESCRIPTION:
; 0854 !
; 0855 !
; 0856 ! FORMAL PARAMETERS:
; 0857 ! None
; 0858 !
; 0859 ! IMPLICIT INPUTS:
; 0860 ! None
; 0861 !
; 0862 ! IMPLICIT OUTPUTS:
; 0863 ! None
; 0864 !
; 0865 ! ROUTINE VALUE:
; 0866 ! COMPLETION CODES:
; 0867 ! None
; 0868 !
; 0869 ! SIDE EFFECTS:
; 0870 ! None
; 0871 !--
; 0872
; 0873 begin
; 0874
; 0875 label
; 0876 TEST_BLOCK;
; 0877
; 0878 GET_KMC_DATA_BASE (DB);
; 0879
; 0880 do TEST_BLOCK:
; 0881 begin
; 0882
; 0883 bind
; 0884 CSR = .DB [K_REGISTER] : block field (KDP_FIELDS);
; 0885
; 0886 begin
; 0887
; 0888 map
; 0889 CSR : block field (KDP_FIELDS) volatile;
; 0890
; 0891 if .CSR [$SUB_FIELD (SEL2, RDYI)]
; 0892 then
; 0893 leave TEST_BLOCK with INPUT_TRANSFER (DB [K_TIM]);
; 0894
; 0895 if .CSR [$SUB_FIELD (SEL2, RDYO)]
; 0896 then
; 0897 leave TEST_BLOCK with OUTPUT_TRANSFER (DB [K_TIM]);
; 0898
; 0899 end;
; 0900 CSR [$SUB_FIELD (BSEL0, IEI)] = 1;
; 0901 CSR [$SUB_FIELD (BSEL0, IEO)] = 1;
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 33
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (13)
; 0902 return;
; 0903 end
; 0904 while TRUE;
; 0905
; 0906 end; !of routine SERVICE_KMC
.SBTTL SERVICE.KMC
002010 .PSECT $CODE$, RO
000000 016501 000002 SERVICE.KMC:
000000 1$: MOV 2(R5),R1 ; *(DB),* 0880
000004 132761 000020 000002 BITB #20,2(R1) ; 0891
000012 001403 BEQ 2$
000014 004767 176130 JSR PC,INPUT.TRANSFER ; 0893
000020 000767 BR 1$
000022 105761 000002 2$: TSTB 2(R1) ; 0895
000026 100003 BPL 3$
000030 004767 177504 JSR PC,OUTPUT.TRANSFER ; 0897
000034 000761 BR 1$
000036 152711 000021 3$: BISB #21,(R1) ; 0901
000042 000207 RTS PC ; 0850
; Routine Size: 18 words, Routine Base: $CODE$ + 2010
; Maximum stack depth per invocation: 1 word
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 34
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (14)
; 0907 routine START_MICROCODE (CSR) : KDP_CSR =
; 0908
; 0909 !++
; 0910 ! FUNCTIONAL DESCRIPTION:
; 0911 !
; 0912 !
; 0913 ! FORMAL PARAMETERS:
; 0914 ! CSR = address of KMC SEL0 register
; 0915 !
; 0916 ! IMPLICIT INPUTS:
; 0917 ! None
; 0918 !
; 0919 ! IMPLICIT OUTPUTS:
; 0920 ! None
; 0921 !
; 0922 ! ROUTINE VALUE:
; 0923 ! COMPLETION CODES:
; 0924 ! None
; 0925 !
; 0926 ! SIDE EFFECTS:
; 0927 ! None
; 0928 !--
; 0929
; 0930 begin
; 0931
; 0932 map
; 0933 CSR : ref block field (KDP_FIELDS);
; 0934
; 0935 CSR [$SUB_FIELD (SEL0, MCL)] = 1;
; 0936 CSR [BSEL2] = -1;
; 0937 CSR [SEL0] = BIT_MASK [RUN];
; 0938
; 0939 if
; 0940 begin
; 0941
; 0942 local
; 0943 COUNT;
; 0944
; 0945 COUNT = 0;
; 0946
; 0947 do
; 0948 begin
; 0949
; 0950 map
; 0951 CSR : ref block field (KDP_FIELDS) volatile;
; 0952
; 0953 if .CSR [BSEL2] eql 0 then exitloop 0;
; 0954
; 0955 end
; 0956 until (COUNT = .COUNT - 1) eql 0
; 0957
; 0958 end
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 35
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (14)
; 0959 then
; 0960 begin
; 0961 COUNTER_INCREMENT (DB, K_MICROCODE_WONT_START);
; 0962 COUNTER_INCREMENT (DB, K_DEVICE_ERRORS);
; 0963 return FALSE;
; 0964 end;
; 0965
; 0966 CSR [$SUB_FIELD (BSEL0, IEI)] = 1;
; 0967 CSR [$SUB_FIELD (BSEL0, IEO)] = 1;
; 0968 TRUE
; 0969 end; !of routine START_MICROCODE
.SBTTL START.MICROCODE
000000 112761 000377 000002 START.MICROCODE:
MOVB #377,2(R1) ; *,*(CSR) 0936
000006 012711 100000 MOV #-100000,(R1) ; *,CSR 0937
000012 005000 CLR R0 ; COUNT 0945
000014 105761 000002 1$: TSTB 2(R1) ; *(CSR) 0953
000020 001414 BEQ 2$
000022 077004 SOB R0,1$ ; COUNT,* 0956
000024 016700 000002G MOV .CRDAT+2,R0 ; 0961
000030 052760 004000 000022 BIS #4000,22(R0)
000036 062700 000022 ADD #22,R0 ; 0962
000042 004767 000000G JSR PC,$IC8
000046 005000 CLR R0 ; 0960
000050 000207 RTS PC
000052 152711 000021 2$: BISB #21,(R1) ; *,CSR 0967
000056 012700 000001 MOV #1,R0 ; 0907
000062 000207 RTS PC
; Routine Size: 26 words, Routine Base: $CODE$ + 2054
; Maximum stack depth per invocation: 1 word
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 36
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (15)
; 0970 routine TIMLTM (DB) : MCB_DB novalue =
; 0971
; 0972 !++
; 0973 ! FUNCTIONAL DESCRIPTION:
; 0974 !
; 0975 !
; 0976 ! FORMAL PARAMETERS:
; 0977 ! None
; 0978 !
; 0979 ! IMPLICIT INPUTS:
; 0980 ! None
; 0981 !
; 0982 ! IMPLICIT OUTPUTS:
; 0983 ! None
; 0984 !
; 0985 ! ROUTINE VALUE:
; 0986 ! COMPLETION CODES:
; 0987 ! None
; 0988 !
; 0989 ! SIDE EFFECTS:
; 0990 ! None
; 0991 !--
; 0992
; 0993 begin
; 0994 GET_KMC_DATA_BASE (DB);
; 0995
; 0996 local
; 0997 REG0 : block [1] field (KDP_FIELDS);
; 0998
; 0999 REG0 = .block [.DB [K_REGISTER], SEL0];
; 1000
; 1001 if .REG0 [IEO] eql 0 then return;
; 1002
; 1003 if (.REG0 [RDYI] neq 0) or (.REG0 [RDYO] neq 0)
; 1004 then
; 1005 COUNTER_INCREMENT (DB, K_LOST_INTERRUPT)
; 1006 else
; 1007 COUNTER_INCREMENT (DB, K_LATE_RDYI);
; 1008
; 1009 COUNTER_INCREMENT (DB, K_PERFORMANCE_ERRORS);
; 1010 DEVICE_BROKEN (DB [K_TIM]);
; 1011 end; !of routine TIMLTM
.SBTTL TIMLTM
000000 017501 000002 TIMLTM: MOV @2(R5),R1 ; *(DB),REG0 0999
000004 032701 000020 BIT #20,R1 ; *,REG0 1001
000010 001422 BEQ 4$
000012 012700 000024 MOV #24,R0 ; 1005
000016 060500 ADD R5,R0 ; DB,*
000020 032701 000020 BIT #20,R1 ; *,REG0 1003
000024 001003 BNE 1$
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 37
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (15)
000026 032701 000200 BIT #200,R1 ; *,REG0
000032 001403 BEQ 2$
000034 052710 001000 1$: BIS #1000,(R0) ; 1005
000040 000402 BR 3$ ; 1003
000042 052710 002000 2$: BIS #2000,(R0) ; 1007
000046 004767 000000G 3$: JSR PC,$IC8 ; 1009
000052 004767 175562 JSR PC,DEVICE.BROKEN ; 1010
000056 000207 4$: RTS PC ; 0970
; Routine Size: 24 words, Routine Base: $CODE$ + 2140
; Maximum stack depth per invocation: 1 word
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 38
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (16)
; 1012 routine TIMPIN (DB) : MCB_DB novalue =
; 1013
; 1014 !++
; 1015 ! FUNCTIONAL DESCRIPTION:
; 1016 !
; 1017 !
; 1018 ! FORMAL PARAMETERS:
; 1019 ! None
; 1020 !
; 1021 ! IMPLICIT INPUTS:
; 1022 ! None
; 1023 !
; 1024 ! IMPLICIT OUTPUTS:
; 1025 ! None
; 1026 !
; 1027 ! ROUTINE VALUE:
; 1028 ! COMPLETION CODES:
; 1029 ! None
; 1030 !
; 1031 ! SIDE EFFECTS:
; 1032 ! None
; 1033 !--
; 1034
; 1035 begin
; 1036 NO_OPERATION
; 1037 end; !of routine TIMPIN
.SBTTL TIMPIN
000000 000207 TIMPIN: RTS PC ; 1012
; Routine Size: 1 word, Routine Base: $CODE$ + 2220
; Maximum stack depth per invocation: 0 words
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 39
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (17)
; 1038 routine TIMPWF (DB) : MCB_DB novalue =
; 1039
; 1040 !++
; 1041 ! FUNCTIONAL DESCRIPTION:
; 1042 !
; 1043 !
; 1044 ! FORMAL PARAMETERS:
; 1045 !
; 1046 ! IMPLICIT INPUTS:
; 1047 ! None
; 1048 !
; 1049 ! IMPLICIT OUTPUTS:
; 1050 ! None
; 1051 !
; 1052 ! ROUTINE VALUE:
; 1053 ! COMPLETION CODES:
; 1054 ! None
; 1055 !
; 1056 ! SIDE EFFECTS:
; 1057 ! None
; 1058 !--
; 1059
; 1060 begin
; 1061 GET_KMC_DATA_BASE (DB);
; 1062 DEVICE_BROKEN (DB [K_TIM]);
; 1063 DB [KF_MICROCODE_LOADED] = FALSE;
; 1064 end; !of routine TIMPWF
.SBTTL TIMPWF
000000 004767 175552 TIMPWF: JSR PC,DEVICE.BROKEN ; 1062
000004 042715 000400 BIC #400,(R5) ; *,DB 1063
000010 000207 RTS PC ; 1038
; Routine Size: 5 words, Routine Base: $CODE$ + 2222
; Maximum stack depth per invocation: 1 word
; 1065 end
; 1066 eludom
; OTS external references
.GLOBL $SAVE5, $SAVE4
; PSECT SUMMARY
;
; Psect Name Words Attributes
; $PLIT$ 24 RO , D , LCL, REL, CON
; $CODE$ 590 RO , I , LCL, REL, CON
KDPKMC 25-Jan-1983 09:54:46 TOPS-20 Bliss-16 3(552) Page 40
X04040 30-Dec-1982 03:17:46 NETPKG:<DRIVERS>KDPKMC.B16.8 (17)
; LIBRARY STATISTICS
;
; -------- Symbols -------- Blocks
; File Total Loaded Percent Read
;
; NETPKG:<V3P0>MCBLIB.L16.7 372 61 16 0
; NETPKG:<BLIS16>XPORT.L16.1 568 2 0 0
; NETPKG:<MCB>NMXLIB.L16.13 200 2 1 0
; NETPKG:<DRIVERS>KDPDAT.L16.3 227 60 26 0
; 1067
; Size: 590 code + 24 data words
; Run Time: 00:13.8
; Elapsed Time: 00:50.4
; Memory Used: 38 pages
; Compilation Complete
ADDR 714# 747#
ADDRESS 333 359
ADR 712 716# 725 732 743#
BIAS 333 358
BIT_MASK 179 536 937
BLISS16 3
BSEL0 328 329 900 901 966 967
BSEL1 727
BSEL2 295 451 467 792 936 953
BSEL3 294 466 799
BUF 214# 229 276# 278 279 280 288# 294# 295# 439# 451# 466#
467#
CALL$P 205 229 295 451 467 846
CALL$ 79 80 81 82 83 127 128 129 130 333# 362# 403#
473# 544# 844
CCB 220 222 227 229 265 269 291 294 295 362 388 397#
398# 399# 403 429 449 451 457 462 466 467
CH$WCHAR 540 644
CMQIN$ 457
CMQRM$ 269
CNT 186 190# 208#
COBAD 127* 205
COCTL 128 836
COM 832
CORBA 129 835
COTBA 130 834
COUNTER_INCREMENT 737 738 802 803 811 812 822 823 839 840 961 962
1005 1007 1009
COUNT 943 945# 956#
CSR 176# 179# 262# 271# 278# 279# 280# 283 326# 328# 329# 440#
455 464# 682 708 714 722 724# 725# 726# 727# 728# 729#
730# 731# 732# 734 747 786# 788 789 790 791# 792 884#
889 891 895 900# 901# 907 933 935# 936# 937# 951 953
966# 967#
CTL 836
C_FIELDS 220 265 388 429
C_LIX 229 294 466
C_PIX 295 451 467
C_PRM1 397
C_PRM3 398
C_PRM4 399
C_STS 227 291 449 462
DB 139# 148 172 176 178# 181# 182# 189 196 214 222 235
259 262 267# 269 276 288 293# 298 322 326 331 359#
396 397 398 399 439 440 442 444 457 465# 511 516
524# 526 528 533 535# 537# 587 588 596 600 610 612
614 618 621 625 629# 632 636 638# 643# 649 679 737
738 751 775 778 786 802 803 804 808 811 812 813
817 822 823 824 839 840 841 850 878 884 893 897
961 962 970 994 999 1005 1007 1009 1010 1012 1038 1061
1062 1063#
DB_BIAS 140# 358# 394 435 509 581
DEVICE_BROKEN 76 148* 804 813 824 841 1010 1062
DISPATCH$ 673
DUP_NUM 797 799# 808 817# 819 846
EQLU 819
FALSE 102# 181 182 537 590 594 610 612 616 622 627 636
739 963 1063
FC_CCP 120
FC_TIM 121
FD_TIM 675
FM_LTM 676
FM_PIN 678
FM_PWF 677
GET_KMC_DATA_BASE 143# 172 259 322 396 442 511 587 775 878 994 1061
IEI 328 900 966
IEO 329 901 967 1001
INPUT_TRANSFER 77 235* 893
KDPKMC 1#
KDP_CSR 73# 88 907#
KDP_CSR_MC_LNG 72# 85 682#
KDP_CSR_NUM 131
KDP_FIELDS 176 196 214 262 276 288 326 439 440 533 708 722
778 884 889 933 951 997
KF_MICROCODE_LOADED 182 600 629 1063
KF_MICROCODE_RUNNING 181 444 528 537 632 638
KMCDB 79 333*
KMCPRM 80 362*
KMCQUE 81 403*
KMCSTP 82 473*
KMCSTR 83 544*
KMCTIM 84 121 649*
KMC_DATA_BASE 145 146
KMC_DISPATCH 120# 360
KMC_INTERRUPT 78 298* 614 618
K_ACTIVE 524 526 596 643
K_COMPLETION_QUEUE_OVERRUN 802
K_DEVICE_ERRORS 738 812 823 840 962
K_DUP_PIX 817
K_FIELDS 139
K_INPUT_DATA 214 276 288 439
K_INPUT_QUEUE 222 269 457
K_INVALID_OUTPUT_CODE 839
K_INVALID_UNIT 811 822
K_LATE_RDYI 1007
K_LEN 110
K_LOST_INTERRUPT 1005
K_MICROCODE_WONT_LOAD 737
K_MICROCODE_WONT_START 961
K_OUTPUT_DATA 196 778
K_PERFORMANCE_ERRORS 803 1009
K_PRIORITY 399 614 618
K_REGISTER 176 262 326 397 440 533 610 612 625 636 786 884
999
K_SYNCH_BLOCK 331
K_TIM 178 267 293 465 535 804 813 824 841 893 897 1010
1062
K_UNITS 189 516 588 808
K_VECTOR 398 614 618 621
LANGUAGE 3
LINKAGE_DB 76 77 86 148# 235# 751#
LNG 682 745#
LOAD_MICROCODE 85 625 682*
MAP$ 394 401 435 471 501 509 542 573 581 646
MC 682 709 726 734 742#
MCB$GAW_PROCESS_DATA_BASE 134 139 140 146
MCB$GA_PROCESS_DISPATCH 136 360#
MCB$GW_PROCESS_HANDLE 135
MCB_DB 87 89 90 91 680 850# 970# 1012# 1038#
MCB_DB_MOD 84 649#
MCB_INTERRUPT 78 298#
MCL 179 536 935
MODIFIER 649 674
NAME 143 144 145 146#
NO_OPERATION 103# 1036
OUTPUT_TRANSFER 86 751* 897
PIX 199 201# 203 205 544 644
PTR 187 189# 190 201 514 516# 518 520# 522 540 585 588#
590 592# 594 644
RBA 835
RDYI 891 1003
RDYO 895 1003
REG 196# 205 533# 536# 778# 783 788# 789# 790# 791# 799 832
846
REG0 997 999# 1001 1003
REGISTER_NXM 131 612
REQUEST_TIMEOUT 107# 293 465
RQI 271 283 455 464
RUN 937
SAVE_MAP 391 393 401 432 434 471 501 506 508 542 573 578
580 646
SEL0 179 205 271 283 455 464 536 714 724 728 731 747
846 935 937 999
SEL2 280 832 891 895
SEL4 229 279 295 451 467 725 729 732
SEL6 278 714 726 730 734 747
SERVICE_INPUT 227* 229 291* 295 449* 451 462* 467
SERVICE_KMC 87 331 850*
SERVICE_OUTPUT 831* 846
SMAP$ 393 434 508 580
START_MICROCODE 88 636 907*
STS 571 574
SYNCH$ 331
TABLE$ 120 675
TBA 834
TEST_BLOCK 876 880 893 897
TIMLTM 89 676 970*
TIMPIN 90 678 1012*
TIMPWF 91 677 1038*
TRUE 104# 216 629 638 647 749 904 968
UNIT 473 518 520 544 590 592
$DSPCR 117* 120 675
$KDPMC 605 625
$KDPML 608 625
$MCB_CLEAR_VECTOR 621
$MCB_DEQUEUE_CCB 222
$MCB_SET_VECTOR 614 618
$RETURN 499# 518 522 571# 590 594 610 612 616 622 627 636
$SUB_FIELD 271 283 328 329 455 464 727 832 891 895 900 901
935 966 967