Research V1 release

[unix-history] / u8.s

/ u8 -- unix

rtap: / read from the dec tape
	asr	r1 / divide the i-number by 2
	sub	$4.,r1 / (i-number/2)-4  r1
	mov	r1,cdev / cdev now has device number
	jsr	r0,bread; 578. / read in block thats in *u.fofp

wtap:
	asr	r1 / divide i-number by 2
	sub	$4.,r1 / r1 = i-number minus 4
	mov	r1,cdev / this is used as the device number
	jsr	r0,bwrite; 578. / write block (u.fofp) on dec tape
				/ Maximum

rrk0:
	mov	$1,cdev / set current device to i., disk
	jsr	r0,bread; 4872. / read block from disk (maximum block
				/ number allowed on device is 4872.)
				/ - (u.fofp) contains block number

wrk0:
	mov	$1,cdev / set current device to 1; disk
	jsr	r0,bwrite; 4872. / write block (u.fofp) on disk

rrf0:
	clr	cdev / set current device to 0., fixed head disk
	jsr	r0,bread; 1024. / read block (u.fofp) from fixed head
				/ disk (max. block number allowed on
				/ device is 1024.)

wrf0:
	clr	cdev / set current device to 0., fixed head disk
	jsr	r0,bwrite; 1024. / write block '(u.fofp)' on fixed head
				 / disk

bread: / read a block from a block structured device
	jsr	r0,tstdeve / error on special file I/O (only works on
			   / tape)
	mov	*u.fofp,r1 / move block number to r1
	mov	$2.-cold,-(sp) / "2-cold" to stack
1:
	cmp	r1,(r0)	/ is this block # greater than or equal to
			/ maximum block # allowed on device
	bhis	1f / yes, 1f (error)
	mov	r1,-(sp) / no, put block # on stack
	jsr	r0,preread / read in the block into an I/O buffer
	mov	(sp)+,r1 / return block # to r1
	inc	r1 / bump block # to next consecutive block
	dec	(sp) / "2-1-cold" on stack
	bgt	1b / 2-1-cold = 0?  No, go back and read in next block
1:
	tst	(sp)+ / yes, pop stack to clear off cold calculation
	mov	*u.fofp,r1 / restore r1 to initial value of the
			   / block #
       cmp     r1,(r0)+ / block # greater than or equal to maximum
       	                / block number allowed
       bhis    error10 / yes, error
       inc     *u.fofp / no, *u.fofp has next block number
       jsr     r0,preread / read in the block whose number is in r1
       bis     $40000,(r5) / set bit 14 of the 1st word of the I/O
       	                   / buffer
1:
       bit     $22000,(r5) / are 10th and 13th bits set (read bits)
       beq     1f / no
       cmp     cdev,$1 / disk or drum?
       ble     2f / yes
       tstb    uquant / is the time quantum = 0?
       bne     2f / no, 2f
       mov     r5,-(sp) / yes, save r5 (buffer address)
       jsr     r0,sleep; 31. / put process to sleep in channel 31 (tape)
       mov     (sp)+,r5 / restore r5
       br      1b / go back
2: / drum or disk
       jsr     r0,idle; s.wait+2 / wait
       br      1b
1: / 10th and 13th bits not set
       bic     $40000,(r5) / clear bit 14
       jsr     r0,tstdeve / test device for error (tape)
       add     $8,r5 / r5 points to data in I/O buffer
       jsr     r0,dioreg / do bookkeeping on u.count etc.
1: / r5 points to beginning of data in I/O buffer, r2 points to beginning
   / of users data
       movb    (r5)+,(r2)+ / move data from the I/O buffer
       dec     r3 / to the user's area in core starting at u.base
       bne     1b
       tst     u.count / done
       beq     1f / yes, return
       tst     -(r0) / no, point r0 to the argument again
       br      bread / read some more
1:
       mov     (sp)+,r0 / jump to routine that called readi
       jmp     ret

bwrite: / write on block structured device
       jsr     r0,tstdeve / test the device for an error
       mov     *u.fofp,r1 / put the block number in r1
       cmp     r1,(r0)+ / does block number exceed maximum allowable #
       bhis    error10 / yes, error
       inc     *u.fofp / no, increment block number
       jsr     r0,wslot / get an I/O buffer to write into
       jsr     r0,dioreg / do the necessary bookkeeping
1: / r2 points to the users data; r5 points to the I/O buffers data area
       movb    (r2)+,(r5)+ / ; r3, has the byte count
       dec     r3 / area to the I/O buffer
       bne     1b
       jsr     r0,dskwr / write it out on the device
       tst     u.count / done
       beq     1f / yes, 1f
       tst     -(r0) / no, point r0 to the argument of the call
       br      bwrite / go back and write next block
1:
       mov     (sp)+,r0 / return to routine that called writei
       jmp     ret
tstdeve: / check whether permanent error has occured on special file
         / I/O
       mov     cdev,r1 / only works on tape; r1 has device #
       tstb    deverr(r1) / test error bit of device
       bne     1f / error
       rts     r0 / device okay
1:
       clrb    deverr(r1) / clear error

error10:
       jmp     error / see 'error' routine

dioreg:
       mov     u.count,r3 / move char count to r3
       cmp     r3,$512. / more than 512. char?
       blos    1f / no, branch
       mov     $512.,r3 / yes, just take 512.
1:
       mov     u.base,r2 / put users base in r2
       add     r3,u.nread / add the number to be read to u.nread
       sub     r3,u.count / update count
       add     r3,u.base / update base
       rts     r0 / return

preread:
       jsr     r0,bufaloc / get a free I/O buffer (r1 has block number)
       br      1f / branch if block already in a I/O buffer
       bis     $2000,(r5) / set read bit (bit 100 in I/O buffer)
       jsr     r0,poke / perform the read
1:
       clr     *$ps / ps = 0
       rts     r0

dskrd:
       jsr     r0,bufaloc / shuffle off to bufaloc; get a free I/O buffer
               br 1f
       bis     $2000,(r5) / set bit 10 of word 1 of I/O queue entry
                          / for buffer
       jsr     r0,poke / just assigned in bufaloc, bit 10=1 says read
1:
       clr     *$ps
       bit     $22000,(r5) / if either bits 10, or 13 are 1; jump to idle
       beq     1f
       jsr     r0,idle; s.wait+2
       br      1b
1:
       add     $8,r5 / r5 points to first word of data in block just read
                     / in
       rts     r0

wslot:
       jsr     r0,bufaloc / get a free I/O buffer; pointer to first
               br 1f / word in buffer in r5
1:
       bit     $22000,(r5) / check bits 10, 13 (read, waiting to read)
       	                   / of I/O queue entry
       beq     1f / branch if 10, 13 zero (i.e., not reading, or waiting
       	          / to read)
       jsr     r0,idle; s.wait+2 / if buffer is reading or writing to read,
       	                         / idle
       br      1b / till finished
1:
       bis     $101000,(r5) / set bits 9, 15 in 1st word of I/O queue
                            / (write, inhibit bits)
       clr     *$ps / clear processor status
       add     $8,r5 / r5 points to first word in data area for this
       	             / block
       rts     r0

dskwr:
       bic     $100000,*bufp / clear bit 15 of I/O queue entry at
                             / bottom of queue

ppoke:
       mov     $340,*$ps
       jsr     r0,poke
       clr     *$ps
       rts     r0
poke:
       mov     r1,-(sp)
       mov     r2,-(sp)
       mov     r3,-(sp)
       mov     $bufp+nbuf+nbuf+6,r2 / r2 points to highest priority I/O
                                    / queue pointer
1:
       mov     -(r2),r1 / r1 points to an I/O queue entry
       bit     $3000,(r1) / test bits 9 and 10 of word 1 of I/O queue
                          / entry
       beq     2f / branch to 2f if both are clear
       bit     $130000,(r1) / test bits 12, 13, and 15
       bne     2f / branch if any are set
       movb    (r1),r3 / get device id
       tstb    deverr(r3) / test for errors on this device
       beq     3f / branch if no errors
       mov     $-1,2(r1) / destroy associativity
       clrb    1(r1) / do not do I/O
       br      2f
3:
       cmpb    r3,$1 / device id = 1; device is disk
       blt     prf / device id = 0; device is drum
       bgt     ptc / device id greater than or equal to 1; device is
       	           / dec tape
       bit     $2,active / test disk busy bit
       bne     2f / branch if bit is set
       bis     $2,active / set disk busy bit
       mov     r1,rkap / rkap points to current I/O queue entry for disk
       mov     2(r1),mq / put physical block number in mq
       mov     $12.,div / divide physical block number by 12.
       mov     $rkda+2,r3 /
       mov     ac,-(sp) / put remainder from divide on stack; gives
                        / sector number
       mov     $4,lsh / shift quotient 4 bits, to align with cyl and surf
                      / bits in rkda
       bis     mq,(sp) / or mq with sector; gives total disk address
       br      3f
prf: / drum
       bit     $1,active / test drum busy bit
       bne     2f / branch if bit is set
       bis     $1,active / set drum busy bit
       mov     r1,rfap / rfap points to current I/O queue entry for drum
       mov     $dae+2,r3
       clr     -(sp)
       movb    2(r1),1(sp) / move low byte of physical block number into
                           / high byte of stack
       clr     -(sp) / word
       movb    3(r1),(sp) / move high byte of physical block number into
                          / low byte of stack
       mov     (sp)+,-(r3) / load dae with high byte of physical block
                           / number
3:
       mov     (sp)+,-(r3) / load rkda register; load dar register
       mov     6(r1),-(r3) / load bus address register
       mov     4(r1),-(r3) / load word count register
       mov     $103,-(sp) / 103 indicates write operation when loaded
                          / in csr
       bit     $2000,(r1) / if bit 10 of word 1 of I/O queue entry is
                          / a one
       beq     3f / then read operation is indicated
       mov     $105,(sp) / 105 indicates read operation
3:
       mov     (sp)+,-(r3) / load csr with interrupt enabled, command, go
       br      seta
ptc: / tape I/O
       bit     $4,active
       bne     2f
       mov     tccm,r3
       swab    r3
       bic     $!7,r3
       add     $2,r3
       cmpb    r3,(r1)
       beq     3f
       movb    $1,tccm / stop transport if not same unit
3:
       bis     $4,active
       mov     r1,tcap
       mov     $20.,tcerrc
       mov     $tape1,tcstate
       movb    (r1),r3 / device
       sub     $2,r3 / now unit
       swab    r3
       bis     $103,r3 / now rbn,for,unit,ie
       mov     r3,tccm
 seta: / I/O queue bookkeeping; set read/write waiting bits.
       mov     (r1),r3 / move word 1 of I/O queue entry into r3
       bic     $!3000,r3 / clear all bits except 9 and 10
       bic     $3000,(r1) / clear only bits 9 and 10
       rol     r3
       rol     r3
       rol     r3
       bis     r3,(r1) / or old value of bits 9 and 10 with bits 12
       	               / and 13
2:
       cmp     r2,$bufp / test to see if entire I/O queue has been
                        / scanned
       bhi    1b
       mov    (sp)+,r3
       mov    (sp)+,r2
       mov    (sp)+,r1
       rts    r0

bufaloc:
       mov    r2,-(sp) / save r2 on stack
       mov    $340,*$ps / set processor priority to 7
1:
       clr    -(sp) / vacant buffer
       mov    $bufp,r2 / bufp contains pointers to I/O queue entrys
                       / in buffer area
2:
       mov    (r2)+,r5 / move pointer to word 1 of an I/O queue entry
                       / into r5
       bit    $173000,(r5) / lock+keep+active+outstanding
       bne    3f / branch when any of bits 9,10,12,13,14,15 are set
       	         / (i.e., buffer busy)
       mov    r2,(sp) / save pointer to last non-busy buffer found
       	              / points to word 2 of I/O queue entry)
3:
       cmpb   (r5),cdev / is device in I/O queue entry same as current
                        / device
       bne    3f
       cmp    2(r5),r1 / is block number in I/O queue entry, same as
       	               / current block number
       bne    3f
       tst    (sp)+ / bump stack pointer
       br     1f / use this buffer
3:
       cmp    r2,$bufp+nbuf+nbuf
       blo    2b / go to 2b if r2 less than bufp+nbuf+nbuf (all
                 / buffers not checked)
       mov    (sp)+,r2 / once all bufs are examined move pointer to
       	               / last free block
       bne    2f / if (sp) is non zero, i.e., if a free buffer is
       	         / found branch to 2f
       jsr    r0,idle; s.wait+2 / idle if no free buffers
       br     1b
2:
       tst    (r0)+ / skip if warmed over buffer
1:
       mov    -(r2),r5 / put pointer to word 1 of I/O queue entry in r5
       movb   cdev,(r5) / put current device number in I/O queue entry
       mov    r1,2(r5) / move block number into word 2 of I/O queue
/ entry
1:
       cmp     r2,$bufp / bump all entrys in bufp and put latest assigned
       blos    1f / buffer on the top (this makes if the lowest priority)
       mov     -(r2),2(r2) / job for a particular device
       br      1b
1:
       mov     r5,(r2)
       mov     (sp)+,r2 / restore r2
       rts     r0

tape: / dec tape interrupt
       jsr     r0,setisp / save registers and clockp on stack
       mov     tcstate,r3 / put state of dec tape in r3
       jsr     r0,trapt; tccm; tcap; 4 / busy bit
       mov     r3,pc / device control status register
       / if no errors, go to device state (an address)

taper: / dec tape error
       dec     tcerrc / decrement the number of errors
       bne     1f / if more than 1 branch
       movb    1(r2),r3 / r2+1 points to command register upper byte
       bic     $!7,r3 / clear all but bits 8-10 (Unit Selection)
       incb    deverr+2(r3) / set error bit for this tape unit
       br      tape3
1: / more than 1 error
       bit     $4000,(r2) / direction of tape
       beq     1f / if forward go to 1f
       bic     $4000,(r2) / reverse, set to forward
       mov     $tape1,tcstate / put tape 1 in the state
       br      0f
1: / put tape in reverse
       bis     $4000,(r2) / set tape to reverse direction
       mov     $tape2,tcstate / put tape 2 as the state
0:
       bis     $4,active / check active bit of tape
       movb    $103,(r2) / set read function and interrupt enable
       br      4f / go to retisp
tape1: / read bn forward
       mov     $tcdt,r0 / move address of data register to r0
       cmp     (r0),2(r1) / compare block addresses
       blt     0b / if lt, keep moving
       bgt     taper / if gt, reverse
       mov     6(r1),-(r0) / put bus address in tcba
       mov     4(r1),-(r0) / put word count in tcwc
       mov     $115,-(sp) / put end interrupt enable
       bit     $20000,(r1) / is "waiting to read bit" of I/O queue set?
       beq     1f / no,  1f
       mov     $105,(sp) / yes, put and interrupt enable
1:
       movb    (sp)+,(r2) / move function into command register (tccm)
       bis     $4,active / set active bit
       mov     $tape3,tcstate / get ready for I/O transfer
       br      4f / go to retisp (rti)

tape2: / read bn bakasswards
       mov     tcdt,r0 / r0 has contents of data register
       add     $3,r0 / overshoot
       cmp     r0,2(r1)
       bgt     0b / if gt keep reading
       br      taper / else reverse

tape3: / I/O transfer
       bic     $30000,(r1) / clear bits 12 and 13 of I/O queue entry
       jsr     r0,poke / do the I/O
       bit     $4,active / still busy see if pick up r-ahead, w-behind
       bne     1f / yes
       movb    $1,(r2) / no, indicate too bad
1:
       jsr     r0,wakeup; runq; 31. / wait up
       br      4f / retisp

drum: / interrupt handler
       jsr     r0,setisp / save r1,r2,r3, and clockp on the stack
       jsr     r0,trapt; dcs; rfap; 1 / check for stray interrupt or
                                      / error
               br 3f / no, error
       br      2f / error

disk:
       jsr     r0,setisp / save r1,r2,r3, and clockp on the stack
       jmp     *$0f
0:
       jsr     r0,trapt; rkcs; rkap; 2
       	       br 3f / no, errors
       mov     $115,(r2) / drive reset, errbit was set
       mov     $1f,0b-2 / next time jmp *$0f is executed jmp will be
                        / to 1f
       br      4f
1:
       bit     $20000,rkcs
       beq     4f / wait for seek complete
       mov     $0b,0b-2
       mov     rkap,r1
2:
       bit     $3000,(r1) / are bits 9 or 10 set in the 1st word of
                          / the disk buffer
       bne     3f / no, branch ignore error if outstanding
       inc     r1
       asr     (r1)
       asr     (r1)
       asr     (r1) / reissue request
       dec     r1
3:
       bic     $30000,(r1) / clear bits 12 and 13 in 1st word of buffer
       mov     ac,-(sp)
       mov     mq,-(sp) / put these on the stack
       mov     sc,-(sp)
       jsr     r0,poke
       mov     (sp)+,sc
       mov     (sp)+,mq / pop them off stack
       mov     (sp)+,ac
4:
       jmp     retisp / u4-3

trapt:                                   / r2 points to the
       mov     (r0)+,r2 / device control register
       mov     *(r0)+,r1 / transaction pointer points to buffer
       tst     (sp)+
       tstb    (r2) / is ready bit of dcs set?
       bge     4b / device still active so branch
       bit     (r0),active / was device busy?
       beq     4b / no, stray interrupt
       bic     (r0)+,active / yes, set active to zero
       tst     (r2) / test the err(bit is) of dcs
       bge     2f / if no error jump to 2f
       tst     (r0)+ / skip on error
 2:
       jmp     (r0)