Google
 

Trailing-Edge - PDP-10 Archives - BB-H311B-RM - rsx20f-swskit/documentation/klinit.mem
There are no other files named klinit.mem in the archive.


  +---------------+
  | d i g i t a l |    I n t e r o f f i c e   M e m o r a n d u m
  +---------------+





  Subj: New KLINIT Command FIX


     As part of the KL RAMP project KLI was modified to give an expanded
     error  report  when  CRAM  or  DRAM  errors  were encountered.  The
     expanded report is generated  two  ways,  first  when  an  operator
     explicitly  asks  for it in the KLI dialogue and an error exists in
     microcode (error meaning an invalid value in some RAM location) and
     secondly   when   an   error   occurs  while  running  and  KLI  is
     automatically requested to reload the KL.





     1.0  CRAM/DRAM ERROR REPORTING

     1.1  Operator Command

     A new command has been added to the KLI dialogue.  The  KLI  prompt
     is:

         KLI -- RELOAD MICROCODE [YES,VERIFY,FIX,NO]?

     The  YES  responce  will  cause  the  microcode  to  be  completely
     reloaded,  the  NO  command  will  cause  KLI  to go on to the next
     question.  The VERIFY command will cause KLI to read the  microcode
     file  from disk and the contents of the RAM from the KL and compare
     them.  If a difference is found the expanded error report is typed.
     The FIX command is new, it is similar to the VERIFY command in that
     it compares the actual RAM values to the correct values  and  types
     the  report when a difference is found, the difference is that once
     the report has been typed an attempt is made to  load  the  correct
     value into the loacation.  If this loading fails a message is typed
     and if the loading fails on five different locations the command is
     aborted and control is returned back to the operator.



     1.2  Internal RAM Value Representations

     Internal to KLI the RAM values are stored  in  such  a  way  as  to
     facilitate  loading  and  comparing  the values.  The CRAM and DRAM
     values have the following representations:


     CRAM File/Core Format:


         Bit                                          Bit
          16                                            0
         +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
         !64!  !66!  !68!  !70!  !72!  !74!  !76!  !78!  ! Word 1
         +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
         !48!49!50!51!52!53!54!55!56!57!58!59!60!  !62!  ! Word 2
         +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
         !32!33!34!35!36!37!38!39!40!41!42!43!44!45!46!47! Word 3
         +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
         !16!17!18!19!20!21!22!23!24!25!26!27!28!29!30!31! Word 4
         +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
         ! 0! 1! 2! 3! 4! 5! 6! 7! 8! 9!10!11!12!13!14!15! Word 5
         +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
         !  !  !  !  !  !  !  !  !  !  !80!81!82!83!84!85! Word 6
         +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

         Note:
                 Values in boxes represent CRAM bit positions
                 Blank boxes are zeros


     DRAM File/Core Format:

         Bit                                          Bit
          16                                            0
         +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
         !  !  !A1!A2!A3!B1!B2!B3!  !  !PE!PC!J7!J8!J9!J0! Word 1
         +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
         !  !  !A1!A2!A3!B1!B2!B3!  !  !PO!PC!J7!J8!J9!J0! Word 2
         +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
         !  !  !  !  !  !  !  !  !  !  !  !  !J1!J2!J3!J4! Word 3
         +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

         Note:
                 J0 is shortened form for J10
                 Word 1= D RAM even address value
                 Word 2= D RAM odd address value
                 Word 3= D RAM common J field value
                 PC is only available after a function read


     This is the format of how they are stored in core and in  the  disk
     file.  When the RAM values are read from the KL with function reads
     the data returned is placed in these formats.  On loading the  data
     is taken from this format and converted to function writes data.



     1.3  Error Report Format

     The error reports have the following formats:

     KLI -- ? C-RAM DIFFERS AT 43
     KLI -- BAD  002556 012600 002000 002640 100002 10
     KLI -- GOOD 002575 012700 002000 002640 100002 10


     KLI -- XOR  000023 000100 000000 000000 000000 00

     KLI -- ? D-RAM DIFFERS AT 106
     KLI -- BAD  A:2 B:0 P:0 J:1002 A:2 B:0 P:0 J:1002
     KLI -- GOOD A:4 B:0 P:0 J:1412 A:2 B:0 P:1 J:1412
     KLI -- XOR  A:6 B:0 P:0 J:0410 A:0 B:0 P:1 J:0410

     In common with CRAM and DRAM reporting is the fact that  there  are
     four  similar  functioning lines.  The first line indicates whether
     it is a CRAM or a DRAM error and the address  of  the  error.   The
     second  line labled with BAD is the actual contents of the RAM read
     from the KL.  The third line labled GOOD is the contents of the RAM
     location  as  read  from  the  microcode disk file.  The final line
     labled XOR is the XOR value of the BAD and GOOD lines.

     The CRAM output consists of six groups of numbers.  The first  five
     groups represent 16 bit quantities and represent from left to right
     CRAM bits 0-15, 16-31, 32-47, 48-63, and 64-79.  The final group is
     a  6 bit quantity representing CRAM bits 80-85 or known as the SPEC
     field.  This type out is the same as one would get with KLDCP  when
     typing out in octal format.  Also if you compare this output to the
     internal representation one sees that it is words 5 to 1 and word 6
     typed out as octal values.

     The DRAM output consists of two sets of labled fields.   The  first
     set  is the even DRAM location value and the second is the odd DRAM
     location value.  The A and B fields are 3 bit quantities and the  P
     field  is a 1 bit quantity.  The J field is a 10 bit quantity where
     bits 5-6 are zero,  bits  1-4  are  common  to  the  even  and  odd
     locations,  and bits 7-10 depend on the location.  When compared to
     the internal representation one can see how the fields are stored.