OpenCores
URL https://opencores.org/ocsvn/System09/System09/trunk

Subversion Repositories System09

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /System09/trunk/src/Flex9
    from Rev 59 to Rev 66
    ↔ Reverse comparison
  •

Rev 59 → Rev 66

/f9-fms.asm
0,0 → 1,1293
*
** FILE MANAGEMENT SYSTEM
*
ZD400 JMP >ZD436
FMSCLS JMP >ZD459
FMS JMP >FMS1
CPYMSG FCC / DISK OPERATING SYSTEM/
FCC / COPYRIGHT (C) 1980 BY/
FCC / TECHNICAL SYSTEMS CONSULTANTS/
ORG CPYMSG
FCBPTR RMB 2
CURFCB RMB 4
ZD40F RMB 2
ZD411 RMB 1
ZD412 RMB 1
ZD413 RMB 1
ZD414 RMB 1
ZD415 RMB 2
ZD417 RMB 1
ZD418 RMB 2
ZD41A RMB 1
ZD41B RMB 2
ZD41D RMB 24
VERFLG FCB $FF
*
**
*
ZD436 JSR >COLDDR
LDX #FCBPTR
LDB #$0A
BSR ZD451
LDX #Z0005
STX >ZD413
STX >ZD415
CLR >ZD41A
ZD44C LDX #ZD41B
LDB #$1A
ZD451 CLR ,X+
DECB
BNE ZD451
JMP >PRSPL5
 
ZD459 JSR >PRSPL4
ZD45C LDX >FCBPTR
BEQ ZD44C
LEAX -$1C,X
STX >CURFCB
PSHS Y
JSR >CLOSE
PULS Y
BCC ZD45C
LDX >CURFCB
CLR $02,X
JSR >PRSPL5
LDB #$FF
RTS
 
*
** FMS CALL, PROCESSING
*
FMS1 TST >ZCCFC
BEQ ZD483
JSR >PRSPL4
ZD483 PSHS Y,B
STX >CURFCB
CLR $01,X
LDB ,X
BNE DOFUNC
*
** READ/WRITE CHAR/BYTE
*
LDB $02,X
BEQ ZD4AC
CMPB #$02
BEQ ZD4A7
JSR >ZD5B4
ZD499 LDX >CURFCB
BCS ZD4C4
TST >ZCCFC
BNE ZD4C6
CLRB
PULS Y,B
RTS
 
ZD4A7 JSR >ZD6CF
BRA ZD499
ZD4AC LDB #$12
BRA ZD4C4
 
DOFUNC CMPB #$16
BLS DOFUN1
LDB #$01
BRA ZD4C4
DOFUN1 DECB
ASLB
LDX #FMSTBL
JSR [B,X]
LDX >CURFCB
BCC ZD4C6
ZD4C4 STB $01,X
ZD4C6 JSR >PRSPL5
TST $01,X
PULS Y,B
RTS
*
** FMS COMMAND VECTOR TABLE
*
FMSTBL FDB OPENRD FC 1
FDB OPENWR FC 2
FDB OPENUD FC 3
FDB CLOSE FC 4
FDB REWIND FC 5
FDB OPNDIR FC 6
FDB GETREC FC 7
FDB PUTREC FC 8
FDB RDSECT FC 9
FDB WRSECT FC 10
FDB RESV1 FC 11
FDB DELETE FC 12
FDB RENAME FC 13
FDB RESV2 FC 14
FDB NXTSEC FC 15
FDB OPNREC FC 16
FDB GETBYT FC 17
FDB PUTBYT FC 18
FDB RESV3 FC 19
FDB NXTDRV FC 20
FDB POSREC FC 21
FDB BAKREC FC 22
*
**
*
ZD4FA BSR ZD51C
BNE ZD503
LDB #$02
ORCC #$01
RTS
 
ZD503 STD ,X
LDX ,X
CLR ,X
CLR $01,X
RTS
 
ZD50C BSR ZD51C
BEQ ZD515
LDB #$0D
ORCC #$01
RTS
 
ZD515 LDD [,X]
STD ,X
ANDCC #$FE
RTS
 
ZD51C LDD >CURFCB
ADDD #$001C
LDX #FCBPTR
ZD525 LDY ,X
BNE ZD52D
ANDCC #$FB
RTS
 
ZD52D CMPD ,X
BNE ZD533
RTS
ZD533 LDX ,X
BRA ZD525
 
ZD537 LDX >CURFCB
CLRA
CLRB
BSR ZD540
LDB #$2F
ZD540 STA $11,X
LEAX $01,X
DECB
BNE ZD540
RTS
 
ZD549 LDX >CURFCB
LDB #$0B
ZD54E LDA $04,X
STA $24,X
LEAX $01,X
DECB
BNE ZD54E
RTS
 
ZD559 LDX >CURFCB
LDB #$0B
ZD55E LDA $04,X
PSHS A
LDA $24,X
CMPA ,S+
BNE ZD56E
LEAX $01,X
DECB
BNE ZD55E
ZD56E RTS
*
** GET RANDOM BYTE FROM SECTOR
*
GETBYT LDX >CURFCB
LDB $02,X
LSRB
BCC ZD5F0
LDB $23,X
JMP >ZD600
 
ZD57D LDX >CURFCB
LDB $22,X
INC $22,X
ABX
STA $40,X
INCB
BNE ZD5AC
ORCC #$01
RTS
*
** PUT RANDOM BYTE IN SECTOR
*
PUTBYT LDX >CURFCB
LDB $02,X
ANDB #$03
CMPB #$03
BNE ZD5F0
ORB #$80
STB $02,X
LDB $0F,X
BITB #$80
BNE ZD5AF
LDB $23,X
ABX
STA $40,X
ZD5AC ANDCC #$FE
RTS
 
ZD5AF LDB #$0B
ORCC #$01
RTS
 
ZD5B4 LDA $3B,X
BMI ZD5F5
BEQ ZD5C2
DEC $3B,X
LDA #$20
BRA ZD5DF
 
ZD5C2 BSR ZD5F5
BCS ZD5E1
CMPA #$18
BHI ZD5DF
BEQ ZD5C2
CMPA #$09
BNE ZD5DC
BSR ZD5F5
BCS ZD5E1
LDX >CURFCB
STA $3B,X
BRA ZD5B4
 
ZD5DC TSTA
BEQ ZD5C2
ZD5DF ANDCC #$FE
ZD5E1 RTS
*
** REWIND FILE
*
REWIND JSR >ZDAB1
BCS ZD5F0
BITA #$01
BEQ ZD5F0
STA ,X
JMP >ZD9A0
 
ZD5F0 LDB #$12
ORCC #$01
RTS
 
ZD5F5 LDX >CURFCB
LDB $22,X
BEQ ZD607
INC $22,X
ZD600 ABX
LDA $40,X
ANDCC #$FE
RTS
 
ZD607 BSR ZD60C
BCC ZD5F5
RTS
 
ZD60C LDX >CURFCB
LDD $40,X
INC $21,X
BNE ZD61A
INC $20,X
ZD61A CMPD #$0000
BEQ ZD63C
ZD620 STD $1E,X
PSHS A
LDA #$04
STA $22,X
PULS A
BSR RDSECT
BCC ZD640
BITB #$80
BEQ ZD638
LDB #$10
BRA ZD63E
 
ZD638 LDB #$09
BRA ZD63E
 
ZD63C LDB #$08
ZD63E ORCC #$01
ZD640 RTS
*
** READ SINGLE SECTOR
*
RDSECT BSR ZD668
LDX >CURFCB
JSR >DRIVE
BCS ZD65D
ZD64B BSR ZD65E
JSR >READ
BNE ZD655
ANDCC #$FE
RTS
 
ZD655 PSHS B
BSR ZD670
PULS B
BCC ZD64B
ZD65D RTS
 
ZD65E LDX >CURFCB
LDD $1E,X
LEAX $40,X
RTS
 
ZD668 CLRA
STA >ZD411
STA >ZD412
RTS
 
ZD670 BITB #$10
BNE ZD685
BITB #$80
BNE ZD69C
LDB >ZD411
INCB
CMPB #$07
BEQ ZD685
STB >ZD411
BRA RESV2
 
ZD685 CLR >ZD411
LDB >ZD412
INCB
CMPB #$04
BEQ ZD69C
STB >ZD412
LDX >CURFCB
JSR >RESTOR
*
** RESERVED
*
RESV2 ANDCC #$FE
RTS
ZD69C ORCC #$01
RTS
*
** WRITE SINGLE SECTOR
*
WRSECT BSR ZD668
LDX >CURFCB
JSR >DRIVE
BCS ZD6C9
ZD6A9 LDX >CURFCB
BSR ZD65E
JSR >WRITE
BNE ZD6BD
LDA >VERFLG
BEQ ZD6EF
JSR >VERIFY
BEQ ZD6EF
ZD6BD BITB #$40
BNE ZD6CC
PSHS B
BSR ZD670
PULS B
BCC ZD6A9
ZD6C9 RTS
 
LDB #$20
ZD6CC ORCC #$01
RTS
 
ZD6CF LDX >CURFCB
LDB $3B,X
BMI ZD714
CMPA #$20
BNE ZD6EA
INCB
STB $3B,X
CMPB #$7F
BNE ZD6EF
BRA ZD6F2
 
ZD6E5 BSR ZD6F2
BCC ZD6CF
RTS
 
ZD6EA TSTB
BEQ ZD714
BRA ZD6E5
 
ZD6EF ANDCC #$FE
RTS
 
ZD6F2 PSHS A
CMPB #$01
BNE ZD6FC
LDA #$20
BRA ZD70C
 
ZD6FC LDA #$09
BSR ZD714
PULS A
BCS ZD713
PSHS A
LDX >CURFCB
LDA $3B,X
ZD70C CLR $3B,X
BSR ZD714
PULS A
ZD713 RTS
 
ZD714 LDX >CURFCB
LDB $02,X
CMPB #$02
LBNE ZD5F0
LDB $22,X
CMPB #$04
BNE ZD72E
PSHS A
BSR ZD74B
PULS A
BCS ZD73D
ZD72E JSR >ZD57D
BCC ZD73D
LDB #$04
LDX >CURFCB
STB $22,X
ANDCC #$FE
ZD73D RTS
 
ZD73E LDX >CURFCB
CLRA
CLRB
STD $20,X
STD $42,X
BRA ZD772
 
ZD74B LDB $12,X
BNE ZD772
LDB $17,X
BEQ ZD799
CLR $17,X
BSR ZD799
BCS ZD786
BSR ZD73E
BCS ZD786
BSR ZD73E
BCS ZD786
LDX >CURFCB
LDB #$02
STB $17,X
LDD $11,X
JMP >ZDC82
 
ZD772 BSR ZD782
LDX >CURFCB
STD $40,X
JSR >WRSECT
BCC ZD799
JMP >ZDBC1
 
ZD782 BSR ZD787
LDD ,X
ZD786 RTS
 
ZD787 LDX >CURFCB
LDB $03,X
LDA #$06
MUL
LDX #ZD41D
ABX
STX >ZD41B
TST ,X
RTS
 
ZD799 BSR ZD782
BNE ZD7A2
LDB #$07
ZD79F ORCC #$01
RTS
 
ZD7A2 LDX >CURFCB
STD $13,X
TST $12,X
BNE ZD7B0
STD $11,X
ZD7B0 INC $16,X
BNE ZD7B8
INC $15,X
ZD7B8 TST $17,X
BEQ ZD7C8
JSR >ZDC43
BCS ZD79F
LDX >CURFCB
LDD $13,X
ZD7C8 JSR >ZD620
BCS ZD79F
LDX >CURFCB
LDD $40,X
PSHS B,A
BSR ZD787
PULS B,A
STD ,X
BNE ZD7E7
CLR $02,X
CLR $03,X
CLR $04,X
CLR $05,X
BRA ZD7EF
 
ZD7E7 LDY $04,X
LEAY -$01,Y
STY $04,X
ZD7EF CLRA
LDX >CURFCB
INC $21,X
BNE ZD7FB
INC $20,X
ZD7FB CLRB
ZD7FC STA $40,X
LEAX $01,X
DECB
BNE ZD7FC
LDX >CURFCB
LDD $20,X
STD $42,X
ANDCC #$FE
RTS
*
** OPEN SYSTEM INFO. RECORD
*
OPNREC CLRB
PSHS B
LDB #$03
BRA ZD825
LDX >ZD415
STX >ZD413
OPNDIR LDB >ZD413
PSHS B
LDB >ZD414
ZD825 LDX >CURFCB
STB $41,X
PULS B
STB $40,X
CLR >ZD418
CLRB
STB $22,X
RTS
*
** GET INFO RECORD
*
GETREC LDX >CURFCB
LDB $22,X
BNE ZD85D
JSR >ZD60C
BCS ZD875
LDX >CURFCB
TST >ZD418
BNE ZD852
LDD <Z0044
STD >ZD418
ZD852 LDA #$10
STA $22,X
LDD $1E,X
STD $2F,X
ZD85D LDA $22,X
STA $31,X
LDB #$18
ZD865 PSHS X,B
JSR >ZD5F5
PULS X,B
STA $04,X
LEAX $01,X
DECB
BNE ZD865
ANDCC #$FE
ZD875 RTS
*
** PUT INFORMATION RECORD
*
PUTREC LDX >CURFCB
LDA $31,X
STA $22,X
LDB #$18
ZD881 PSHS X,B
LDA $04,X
JSR >ZD714
PULS X,B
LEAX $01,X
DECB
BNE ZD881
JMP >WRSECT
 
ZD892 LDX >CURFCB
LDA $03,X
STA $23,X
LDA >ZD417
TST >ZD41A
BNE ZD8D3
STA $03,X
LDX >ZD415
STX >ZD413
ZD8AA CMPX #Z0005
BEQ ZD8BB
BSR ZD8D3
BLS ZD8EA
LDX >ZD418
STX >ZD413
BRA ZD8AA
 
ZD8BB LDX >CURFCB
LDA $23,X
STA $03,X
BPL ZD8D3
ZD8C5 JSR >NXTDRV
BCS ZD900
BSR ZD8D3
BLS ZD8EA
JSR >ZDDAD
BRA ZD8C5
 
ZD8D3 LDX >CURFCB
CLR >ZD41A
JSR >ZD549
JSR >OPNDIR
ZD8DF JSR >GETREC
BCC ZD8EB
CMPB #$08
BEQ ZD900
ORCC #$01
ZD8EA RTS
 
ZD8EB LDX >CURFCB
LDA $04,X
BEQ ZD8FE
BPL ZD8F6
BSR ZD905
ZD8F6 JSR >ZD559
BNE ZD8DF
ANDCC #$FE
RTS
 
ZD8FE BSR ZD905
ZD900 ANDCC #$FB
ANDCC #$FE
RTS
 
ZD905 LDA $33,X
BNE ZD916
LDD $2F,X
STD $32,X
LDA $31,X
STA $34,X
ZD916 RTS
 
ZD917 JSR >ZD787
BNE ZD933
BSR ZD936
BCS ZD935
LDB #$06
LDY >CURFCB
LDX >ZD41B
ZD929 LDA $5D,Y
LEAY $01,Y
STA ,X+
DECB
BNE ZD929
ZD933 ANDCC #$FE
ZD935 RTS
 
ZD936 JSR >OPNREC
JSR >ZD60C
BCS ZD946
LDX >CURFCB
LDB #$10
STB $22,X
ZD946 RTS
 
ZD947 JSR >ZD787
BSR ZD936
BCS ZD946
LDB #$06
LDY >CURFCB
LDX >ZD41B
ZD957 LDA ,X+
STA $5D,Y
LEAY $01,Y
DECB
BNE ZD957
JSR >WRSECT
BCC ZD946
JMP >ZDBC1
*
**
*
RESV1 LDX >CURFCB
LDA #$02
STA $02,X
LDD $2F,X
STD $1E,X
JSR >RDSECT
BCS ZD983
JSR >PUTREC
BCC ZD985
JMP >ZDBC1
 
ZD983 LDB #$0A
ZD985 RTS
*
** OPEN FOR READ
*
OPENRD JSR >ZD4FA
BCS ZD9C8
JSR >ZD892
BCS ZD9C8
BNE ZD9CD
LDX >CURFCB
TST >ZD41A
BEQ ZD9A0
LDA $0F,X
BITA #$20
BNE ZD9C9
ZD9A0 JSR >ZDCC0
BCS ZD9CF
LDD $11,X
STD $40,X
JSR >ZDA76
LDB $17,X
BEQ ZD9C6
ZD9B3 PSHS B
JSR >ZD60C
PULS B
BCS ZD9C8
DECB
BNE ZD9B3
LDX >CURFCB
CLRB
STB $22,X
ZD9C6 ANDCC #$FE
ZD9C8 RTS
 
ZD9C9 LDB #$11
BRA ZD9CF
 
ZD9CD LDB #$04
ZD9CF PSHS B
JSR >ZD50C
PULS B
ORCC #$01
RTS
 
OPENWR LDX >CURFCB
TST $03,X
BPL ZD9E8
JSR >NXTDRV
BCC ZD9E8
LDB #$10
RTS
 
ZD9E8 JSR >ZD4FA
BCS ZD9CF
JSR >ZD537
JSR >ZD917
BCS ZD9CF
JSR >ZD892
BCS ZD9CF
BNE ZDA00
LDB #$03
BRA ZD9CF
 
ZDA00 JSR >ZDCC0
BCS ZD9CF
LDX >CURFCB
LDB #$0A
ZDA0A CLR $0F,X
LEAX $01,X
DECB
BNE ZDA0A
LDX >CURFCB
LDD $32,X
BEQ ZDA40
STD $2F,X
LDA $34,X
STA $31,X
LDD >DATERG
STD $19,X
LDA >YEAR
STA $1B,X
JSR >ZDDAD
JSR >RESV1
BCS ZD9CF
BSR ZDA76
LDA #$04
STA $22,X
ANDCC #$FE
RTS
 
ZDA40 LDX >CURFCB
CLR $17,X
INC $12,X
LDD $2F,X
JSR >ZD620
BCS ZDA5E
JSR >ZD772
BCS ZDA5E
JSR >WRSECT
BCC ZDA61
JSR >ZDBC1
ZDA5E JMP >ZD9CF
 
ZDA61 LDX >CURFCB
LDD $1E,X
STD $32,X
LDA #$10
STA $34,X
JSR >ZD947
BCS ZDA5E
BRA ZDA00
 
ZDA76 LDX >CURFCB
LDA ,X
STA $02,X
CLR ,X
CLR $3B,X
CLRA
STA $22,X
RTS
*
** READ/WRITE NEXT SECTOR
*
NXTSEC BSR ZDAB1
BCS ZDA99
CLR ,X
LSRA
LBCS ZD60C
LDB #$04
STB $22,X
ANDCC #$FE
ZDA99 RTS
 
ZDA9A LDX >CURFCB
LDA $02,X
CMPA #$83
BNE ZDAAE
LDA #$03
STA $02,X
ZDAA7 JSR >WRSECT
LBCS ZDBC1
ZDAAE ANDCC #$FE
RTS
 
ZDAB1 BSR ZDA9A
BCS ZDAC2
LDX >CURFCB
LDA $02,X
CMPA #$03
BLS ZDAAE
LDB #$12
ORCC #$01
ZDAC2 RTS
 
CLOSE BSR ZDAB1
BCS ZDAF8
CMPA #$02
BEQ ZDAD3
ZDACB LDX >CURFCB
CLR $02,X
JMP >ZD50C
 
ZDAD3 LDA $12,X
BNE ZDADD
JSR >ZDBA7
BRA ZDAF6
 
ZDADD BSR ZDAA7
BCS ZDAF8
LDX >CURFCB
TST $17,X
BEQ ZDAEE
JSR >ZDC98
BCS ZDAF8
ZDAEE JSR >RESV1
BCS ZDAF8
JSR >ZD947
ZDAF6 BCC ZDACB
ZDAF8 RTS
*
** OPEN FOR UPDATE
*
OPENUD JSR >OPENRD
BCS ZDB26
JSR >ZD60C
BCS ZDB26
LDA #$03
BRA ZDB1F
*
**
*
RESV3 JSR >OPENRD
BCS ZDB26
LDX >CURFCB
LDA $0F,X
BITA #$80
BNE ZDB27
LDD $13,X
JSR >ZD620
BCS ZDB26
LDA #$02
ZDB1F LDX >CURFCB
STA $02,X
ANDCC #$FE
ZDB26 RTS
 
ZDB27 LDB #$0B
ORCC #$01
RTS
*
** RENAME FILE
*
RENAME BSR ZDB63
JSR >ZD892
BCS ZDB5D
BEQ ZDB59
LDX >CURFCB
LDB #$0B
ZDB3A LDA $24,X
STA $04,X
LEAX $01,X
DECB
BNE ZDB3A
BSR ZDB93
BCS ZDB5D
LDX >CURFCB
LDA $0F,X
BITA #$80
BNE ZDB27
BITA #$60
BNE ZDB5E
BSR ZDB63
BRA ZDBAE
 
ZDB59 LDB #$03
ORCC #$01
ZDB5D RTS
ZDB5E LDB #$0C
ORCC #$01
RTS
 
ZDB63 LDX >CURFCB
LDA #$0B
STA >ZD411
ZDB6B LDA $04,X
LDB $35,X
STA $35,X
STB $04,X
LEAX $01,X
DEC >ZD411
BNE ZDB6B
LDX >CURFCB
LDA $0C,X
BNE ZDB8F
LDB #$03
ZDB85 LDA $3D,X
STA $0C,X
LEAX $01,X
DECB
BNE ZDB85
ZDB8F LDX >CURFCB
RTS
 
ZDB93 BSR ZDB63
ZDB95 JSR >ZD892
BCS ZDBA1
BNE ZDBA2
LDX >CURFCB
ANDCC #$FE
ZDBA1 RTS
 
ZDBA2 LDB #$04
ORCC #$01
RTS
 
ZDBA7 LDX >CURFCB
LDA #$FF
STA $04,X
ZDBAE JSR >RESV1
LDX >CURFCB
LDA #$00
STA $02,X
RTS
 
ZDBB9 STD $40,X
JSR >WRSECT
BCC ZDBD5
ZDBC1 BITB #$40
BNE ZDBCD
BITB #$80
BEQ ZDBD3
LDB #$10
BRA ZDBD3
ZDBCD LDB #$0B
BRA ZDBD3
 
LDB #$0A
ZDBD3 ORCC #$01
ZDBD5 RTS
*
** DELETE FILE
*
DELETE JSR >ZD917
BCS ZDC39
BSR ZDB95
BCS ZDC39
LDX >CURFCB
LDA $0F,X
BITA #$80
BNE ZDC3A
BITA #$60
BNE ZDC3E
JSR >ZD787
LDX >ZD41B
LDD $02,X
BNE ZDC05
LDX >CURFCB
LDD $11,X
BEQ ZDC31
LDX >ZD41B
STD ,X
BRA ZDC19
 
ZDC05 LDX >CURFCB
JSR >ZD620
BCS ZDC39
LDX >CURFCB
LDD $11,X
BEQ ZDC31
BSR ZDBB9
BCS ZDC39
ZDC19 LDX >CURFCB
LDD $13,X
LDX >ZD41B
STD $02,X
LDX >CURFCB
LDD $15,X
LDX >ZD41B
ADDD $04,X
STD $04,X
ZDC31 JSR >ZDBA7
BCS ZDC39
JSR >ZD947
ZDC39 RTS
 
ZDC3A LDB #$0B
BRA ZDC40
ZDC3E LDB #$0C
ZDC40 ORCC #$01
RTS
 
ZDC43 LDD $1E,X
INCB
CMPB $3C,X
BLS ZDC4F
LDB #$01
INCA
ZDC4F CMPD $13,X
BNE ZDC63
LDA $37,X
CMPA #$FF
BEQ ZDC63
INCA
STA $37,X
ANDCC #$FE
RTS
 
ZDC63 BSR ZDC98
BCS ZDC97
LDX >CURFCB
LDA $3A,X
ADDA #$03
BNE ZDC87
LDD $1E,X
CMPD $11,X
BEQ ZDC7F
LDB #$17
ORCC #$01
RTS
 
ZDC7F LDD $40,X
ZDC82 STD $38,X
LDA #$04
ZDC87 STA $3A,X
LDD $13,X
STD $35,X
LDA #$01
STA $37,X
ANDCC #$FE
ZDC97 RTS
 
ZDC98 LDD $38,X
JSR >ZD620
BCS ZDC97
LDX >CURFCB
TFR X,Y
LDB $3A,X
ABX
LDB #$03
ZDCAB LDA $35,Y
LEAY $01,Y
STA $40,X
LEAX $01,X
DECB
BNE ZDCAB
JSR >WRSECT
BCC ZDC97
JMP >ZDBC1
 
ZDCC0 JSR >OPNREC
JSR >ZD60C
BCS ZDD0E
LDX >CURFCB
CLRA
CLRB
STD $20,X
LDA $67,X
STA $3C,X
CLRB
ZDCD7 CLR $40,X
LEAX $01,X
DECB
BNE ZDCD7
LDX >CURFCB
ANDCC #$FE
RTS
*
** BACKUP ONE RECORD
*
BAKREC LDX >CURFCB
LDA $17,X
BEQ ZDD0A
LDD $20,X
SUBD #$0001
BPL ZDCF8
JMP >ZDD9A
*
** POSITION TO RECORD N
*
ZDCF8 STD $20,X
POSREC JSR >ZDAB1
BCS ZDD0E
RORA
BCC ZDD0A
CLR ,X
LDA $17,X
BNE ZDD0F
ZDD0A LDB #$12
ORCC #$01
ZDD0E RTS
 
ZDD0F CLR >ZD411
LDD $11,X
LDY $20,X
BEQ ZDD85
JSR >ZDD9F
BCS ZDD0E
CLRA
CLRB
ZDD22 TST $02,X
BEQ ZDD9A
ADDB $02,X
ADCA #$00
STX >ZD40F
LDX >CURFCB
CMPD $20,X
BCC ZDD62
LDX >ZD40F
LEAX $03,X
PSHS A
LDA >ZD411
INCA
STA >ZD411
CMPA #$54
BEQ ZDD50
CMPA #$A8
PULS A
BEQ ZDD9A
BRA ZDD22
 
ZDD50 PSHS B
LDX >CURFCB
LDD $40,X
BSR ZDD9F
BCS ZDD9A
PULS B
PULS A
BRA ZDD22
 
ZDD62 SUBD $20,X
LDX >ZD40F
LDA $02,X
PSHS B
SUBA ,S+
DECA
TFR A,B
LDA ,X
ADDB $01,X
LDX >CURFCB
BCS ZDD7F
ZDD7A CMPB $3C,X
BLS ZDD85
ZDD7F SUBB $3C,X
INCA
BRA ZDD7A
 
ZDD85 JSR >ZD620
BCS ZDD9E
LDX >CURFCB
LDD $42,X
CMPD $20,X
BEQ ZDDAA
LDB #$19
BRA ZDD9C
 
ZDD9A LDB #$18
ZDD9C ORCC #$01
ZDD9E RTS
 
ZDD9F JSR >ZD620
BCS ZDDAC
LDX >CURFCB
LDB #$44
ABX
ZDDAA ANDCC #$FE
ZDDAC RTS
 
ZDDAD LDX >CURFCB
LDB #$0B
ZDDB2 LDA $24,X
STA $04,X
LEAX $01,X
DECB
BNE ZDDB2
RTS
*
** FIND NEXT DRIVE
*
NXTDRV LDX >CURFCB
LDA $03,X
INCA
CMPA #$04
BCC ZDDD6
STA $03,X
BNE ZDDD0
JSR >DRVRDY
BRA ZDDD3
 
ZDDD0 JSR >QUICK
ZDDD3 BCS NXTDRV
RTS
 
ZDDD6 LDB #$10
ORCC #$01
RTS
END
 
/f9-monex.asm
0,0 → 1,1300
*
** FLEX 9 DISK DRIVERS
*
* FOR SYS09BUG ON THE DIGILENT SPARTAN 3 STARTER BOARD
* WITH I/O MAPPED AT $XE000
* AND ROM MAPPED AT $XF000
* THE DIGILENT SPARTAN 3 STARTER BOARD HAS 1MBYTE OF SRAM
* THE FIRST 64K IS USED BY FLEX,
* THE SECOND 128K IS USED AS A ROM DISK
* THE REMAINING RAM IS USED FOR A RAM DISK
*
*
CFLAG EQU $01 CARRY FLAG
VFLAG EQU $02 OVERFLOW FLAG
ZFLAG EQU $04 ZERO FLAG
NFLAG EQU $08 NEGATIVE FLAG
IFLAG EQU $10 IRQ MASK CC
HFLAG EQU $20 HALF CARRY
FFLAG EQU $40 FIRQ MASK CC
EFLAG EQU $80 ENTIRE FLAG
*
MAPPAG EQU $00 PAGE $0000 DAT ADDRESS
DATREG EQU IC11 DAT REGISTERS
*
* Serial Port
*
ACIAC1 EQU ACIAS
ACIAD1 EQU ACIAS+1
DELCON EQU 1250 Delay (Processor clock in MHz * 50)
*
* XMODEM Control characters
*
SOH EQU $01
EOT EQU $04
ACK EQU $06
NAK EQU $15
CAN EQU $18
*
* DRIVE GEOMETRY
*
EMAXSEC EQU 14 ROM DISK
EMAXTRK EQU 48 3 * 16 * 14 * 256 = 172,032 Bytes
ETOTSEC EQU EMAXTRK*EMAXSEC-EMAXSEC
*
RMAXSEC EQU 14 RAM DISK
RMAXTRK EQU 192 12 * 16 * 14 * 256 = 688,128 Bytes
RTOTSEC EQU RMAXTRK*RMAXSEC-RMAXSEC
*
* DRIVE TYPES
*
DTYPROM EQU 0 ROM DISK
DTYPRAM EQU 1 RAM DISK
DTYPFLS EQU 2 FLASH DISK
DTYPNET EQU 3 FLEXNET DISK
*
ORG $DE00
*
* DISK DRIVER JUMP TABLE LAST UPDATE: 22/12/2006
* Disk driver for RAM Disk.
*
* 14 SECTORS PER TRACK
* 16 * N TRACKS PER DISK
*
* ROM DISK OCCUPIES $10000 - $1E000 ... $30000 - $3E000
* RAM DISK OCCUPIES $40000 - $4E000 ... $F0000 - $FE000
* Track Buffer page mapped at $E000 - $EFFF
* MAPPAG = $00 = 0 x $1000 (4 K pages)
 
* ON SWTPC ROM AT $XF000 AND IO AT $XE000
* APPEARS THROUGHOUT THE MEMORY SO MUST BE SKIPPED OVER
* WHEN USING RAM AS A RAMDISK.
* THE MSN OF THE TRACK MAPS INTO THE MSN OF THE DAT
* THE LSN OF THE TRACK NUMBER INDEXES INTO THE 4K RAM PAGE
* THE SECTOR MAPS INTO THE LSN OF THE DAT WHICH IS INVERTED
*
*
*
* FLEX disk jump table.
*
READ JMP READSC
WRITE JMP WRITSC
VERIFY JMP BUSY
RESTOR JMP RESTR1
DRIVE JMP DRVSEL
DRVRDY JMP CHKRDY
QUICK JMP CHKQIK
COLDDR JMP DINIT
WARMDR JMP DWARM
SEEK JMP SEEKTS
*
* RAM SPACE
*
DRVNUM FCB 0
TRACK FCB 0
SECTOR FCB 0
CHKSUM FCB 0
CCSAVE FCB 0
BLKNUM FCB 0 Xmodem block number
BYTCNT FCB 0 Xmodem byte count
XSTATE FDB 0 Xmodem State Vector
DELCNT FCB $00,$00,$00 Xmodem Poll timer
*
* Disc driver type table.
* Indexed by drive number
*
DTYPTAB FCB DTYPROM Drive 0 (ROM Disk)
FCB DTYPRAM Drive 1 (RAM Disk)
FCB DTYPFLS Drive 2 (FLASH Disk)
FCB DTYPNET Drive 3 (NETPC Disk)
*
* RAM Disk offset
* Indexed by drive type
*
DOFFTAB FCB $10 ROM Disk $10000
FCB $40 RAM DISK $40000
FCB $FF Flash Disk
FCB $FF NETPC Disk
*
REAVEC RMB 2 Disc driver jump table.
WRIVEC RMB 2
VERVEC RMB 2
RSTVEC RMB 2
DRVVEC RMB 2
CHKVEC RMB 2
QUIVEC RMB 2
INIVEC RMB 2
WARVEC RMB 2
SEEVEC RMB 2
*
* SECTOR BUFFER
*
BUFFER RMB 256
SYNCREG RMB 4 Prom input register
*
****************************************
*
* START OF EXTENSION COMMANDS
*
****************************************
*
ORG MONEXT
FDB NEXTEXT Jump to next extended command
*
*
*****************************************
* Disk drivers *
* ------------ *
* The system dependant code for the *
* disc drivers fits here. Two tables *
* must be included. These are DTYPTAB a *
* four byte table that defines which of *
* the (up to four) following sets of *
* jump tables to use, and TABSRT the *
* jump tables themselves. For a full *
* description of the floppy drivers see *
* section 4 (pp9-14) of the general *
* Flex adaptation guide. *
*****************************************
*
* Mass storage drivers for embedded applications.
*
* Jump tables.
TABSRT FDB EREAD Drive type 0 (ROM disk).
FDB EWRITE
FDB ECHECK
FDB ECHECK
FDB ECHECK
FDB ECHECK
FDB ECHECK
FDB DDUMMY
FDB DDUMMY
FDB DDUMMY
*
FDB EREAD Drive type 1 (RAM disk).
FDB EWRITE
FDB ECHECK
FDB ECHECK
FDB ECHECK
FDB ECHECK
FDB ECHECK
FDB DDUMMY
FDB DDUMMY
FDB DDUMMY
*
FDB DDUMMY Drive type 2 (External Flash disk).
FDB DDUMMY
FDB DDUMMY
FDB DDUMMY
FDB DDUMMY
FDB DDUMMY
FDB DDUMMY
FDB DDUMMY
FDB DDUMMY
FDB DDUMMY
*
FDB NREAD Drive type 3 (NetPC drive via serial port).
FDB NWRITE
FDB NVERIFY
FDB NCHECK
FDB NCHECK
FDB NCHECK
FDB NCHECK
FDB DDUMMY
FDB DDUMMY
FDB DDUMMY
*
*
* Dummy routine (no errors).
DDUMMY CLRB
TSTB Set (z)=1
ANDCC #$FF-CFLAG Set (c)=0
RTS
* *
**************************
* Main Flex entry points *
*************************
*
* Read sector routine.
* Entry: (X) = address where sector is to be placed.
* (A) = Track number.
* (B) = Sector number.
* Exit: (B) = Error code (z)=1 if no error.
READSC JMP [REAVEC]
*
* Write track routine.
* Entry: (X) = Address of area of memory from which the data will be taken.
* (A) = Track number.
* (B) = Sector number.
* Exit: (B) = Error condition, (Z)=1 no an error.
WRITSC JMP [WRIVEC]
*
* Verify sector routine.
* Entry: no parameters.
* Exit: (B) = Error condition (Z)=1 if no error.
BUSY JMP [VERVEC]
*
* Restore drive to track 00.
* Entry: (X) = FCB address (3,X contains drive number).
* Exit: (B) = Error condition, (Z)=1 if no error.
RESTR1 BSR DRVSEL Select drive first.
BEQ RST1
RTS
RST1 JMP [RSTVEC]
*
* Select current drive.
* Entry: (X) = FCB address (3,X contains drive number).
* Exit: (B) = Error condition, (Z)=0 and (c)=1 if error.
* (B) = $0F if non existant drive.
DRVSEL PSHS X,Y
LDB 3,X Get driver type.
STB DRVNUM
LDX #DTYPTAB
LDA B,X
CMPA #$FF Is the drive nonexistant?
BNE DRIVE1
PULS X,Y
LDB #$0F
TSTB
ORCC #$01
RTS
*
DRIVE1 LDB #20 Get correct table start address.
MUL
LDX #TABSRT
LEAX D,X
LDY #REAVEC Copy table into ram.
LDB #20
DRIVE2 LDA 0,X+
STA 0,Y+
DECB
BNE DRIVE2
PULS X,Y
JMP [DRVVEC]
*
* Check for drive ready.
* Entry: (X) = FCB address (3,X contains drive number)>
* Exit: (B) = Error condition, (Z)=0 AND (C)=1 if drive is not ready.
CHKRDY JMP [CHKVEC]
*
* Quick drive ready check.
* Entry: (X) = FCB address (3,X contains drive number).
* Exit: (B) = Error condition, (Z)=0 AND (c)=1 if drive not ready.
CHKQIK JMP [QUIVEC]
*
* Init (cold start).
* Entry: no parameters.
* Exit: no change.
DINIT CLRA
DINIT1 STA DRVNUM Init each valid drive in turn.
LDX #DRVNUM-3
BSR DRVSEL
BCS DINIT2
JSR [INIVEC]
DINIT2 LDA DRVNUM
INCA
CMPA #4
BNE DINIT1
RTS
*
* Warm start.
* Entry: no parameters.
* Exit: no change.
DWARM JMP [WARVEC]
*
* Seek track.
* Entry: (A) = Track number.
* (B) = Sector number.
* Exit: (B) = Error condition, (Z)=1 if no error.
SEEKTS JMP [SEEVEC]
*
*
*****************************************************
* ROMdisk drivers *
* --------------- *
* Drivers to support a ROMdisk in the external RAM *
* of the SYS09. The ROMdisk base address is $10000 *
*****************************************************
* Dummy return for ROM disk (write protected!)
*
* MAP RAM DISK INTO MEMORY SPACE
*
MAPIN TFR CC,A ; Save state of interrupt masks
STA CCSAVE
ORCC #FFLAG+IFLAG ; Mask interrupts while IO mapped out
LDU #DTYPTAB ; Point to Drive Type table
LDB DRVNUM ; Get working drive number
LDB B,U
LDU #DOFFTAB
LDA TRACK
ADDA B,U ; Add Base offset into RAM
ANDA #$F0 ; Mask MSN
STA ,-S ; Save A on stack
*
LDA SECTOR
SUBA #1 ; Sectors 1 to 14 => 0 to 13
EORA #$0F ; Complement LSNybble
ANDA #$0F
*
ADDA ,S+ ; Add sector to LSN of Track and pop
STA DATREG+MAPPAG
*
LDA TRACK ; LSN of Track indexes into 4K page
ANDA #$0F
ADDA #MAPPAG*16
CLRB
TFR D,U
RTS
*
* MAP RAM DISK OUT OF MEMORY
*
MAPOUT LDA #MAPPAG ; Point to the Flex page
EORA #$0F ; Complement LSNybble
STA DATREG+MAPPAG ; map in Flex page
LDA CCSAVE ; restore interrupt masks
TFR A,CC
RTS
*
* Seek track and sector
* A holds track number (0-32)
* B holds sector number (1-14)
*
ESEEK STA TRACK
STB SECTOR
ANDCC #$FE ; CLEAR CARRY
ORCC #$04 ; SET Z
RTS
*
* MARK DISK READ ONLY
*
EDUMMY LDB #$40
TSTB
ORCC #$01
RTS
*
EREAD PSHS X,Y,U push sequentialy to preserve order on stack
LBSR ESEEK
LBSR MAPIN build external ram address
*
LDY #BUFFER
CLRB
ERLOOP1 LDA 0,U+ move 256 bytes to buffer from external RAM
STA 0,Y+
DECB
BNE ERLOOP1
*
LBSR MAPOUT
*
LDY #BUFFER
CLRB
ERLOOP2 LDA 0,Y+ move 256 bytes from buffer to Flex RAM
STA 0,X+
DECB
BNE ERLOOP2
*
CLRB
PULS X,Y,U,PC restore all registers
*
* check for marker bytes $AA55 in first bytes of first track/sector
*
*ECHECK CLRA
* LDB #1
* LDX #BUFFER
* BSR EREAD
* LDD BUFFER
* CMPD #$AA55
* BNE EERR
* LBRA DDUMMY
*EERR LDB #$80 not ready bit set
* TSTB
* ORCC #$01
* RTS
ECHECK CLRB
RTS
*
* Write Sector
*
EWRITE PSHS X,Y,U
LBSR ESEEK
LDU #DTYPTAB ; Point to Drive Type table
LDB DRVNUM ; Get working drive number
LDB B,U ; Fetch Drive type
CMPB #DTYPRAM ; Is it a RAM Disk ?
BEQ EWOK ; Yep, can write to it
CMPB #DTYPROM ; Allow writes to ROM Disk too
BEQ EWOK
LBRA EDUMMY ; Nope report read only
*
EWOK LDY #BUFFER
CLRB
EWLOOP1 LDA 0,X+ move 256 bytes to buffer from Flex RAM
STA 0,Y+
DECB
BNE EWLOOP1
*
LBSR MAPIN
*
LDY #BUFFER
CLRB
EWLOOP2 LDA 0,Y+ move 256 bytes from buffer to external RAM
STA 0,U+
DECB
BNE EWLOOP2
*
LBSR MAPOUT
*
CLRB
PULS X,Y,U,PC
*
*
*****************************************************
* FlexNet drivers *
* --------------- *
* Drivers to support a remote connection via the *
* serial port using the FlexNet protocol as defined *
* in FLEXNet_421B *
*****************************************************
*
*
* read sector from remote drive
*
NREAD PSHS B
PSHS A
CLR CHKSUM clear checksum
CLR CHKSUM+1
*
LDA #'s Send read sector command
JSR SCHAR
BCC NRD_DNR if timeout, then flag drive not ready
*
LDA DRVNUM send drive
JSR SCHAR
BCC NRD_DNR
*
PULS A send track
JSR SCHAR
BCC NRD_DNR
*
PULS A send sector
JSR SCHAR
BCC NRD_DNR
*
* transfer 256 bytes
CLRB
NREAD1 JSR RCHAR read byte
BCC NRD_DNR if timeout, then flag drive not ready
STA 0,X+
ADDA CHKSUM+1 update checksum
STA CHKSUM+1
BCC NREAD2
INC CHKSUM
NREAD2 DECB
BNE NREAD1
*
* compare checksums
JSR RCHAR get checksum msb
BCC NRD_DNR
PSHS A
JSR RCHAR get checksum lsb
BCC NRD_DNR
TFR A,B
PULS A
CMPD CHKSUM compare checksums
BNE NRD_ERR if checksum error, then flag crc read error
*
LDA #ACK no checksum error, send ACK char
JSR SCHAR
BCC NRD_DNR
CLRB all OK, flag no error
BRA NRD_END
*
NRD_DNR LDB #16 flag drive not ready
BRA NRD_END
*
NRD_ERR LDA #NAK send NAK
JSR SCHAR
BCC NRD_DNR
LDB #09 flag crc read error
*
NRD_END STB CHKSUM used by VERIFY
TSTB
RTS
*
*
* write sector to remote drive
*
NWRITE PSHS B
PSHS A
CLR CHKSUM clear checksum
CLR CHKSUM+1
*
LDA #'r Send write sector command
JSR SCHAR
BCC NRD_DNR if timeout, then flag drive not ready
*
LDA DRVNUM send drive
JSR SCHAR
BCC NRD_DNR
*
PULS A send track
JSR SCHAR
BCC NRD_DNR
*
PULS A send sector
JSR SCHAR
BCC NRD_DNR
*
* transfer 256 bytes
CLRB
NWRITE1 LDA 0,X+
JSR SCHAR write byte
BCC NRD_DNR if timeout, then flag drive not ready
ADDA CHKSUM+1 update checksum
STA CHKSUM+1
BCC NWRITE2
INC CHKSUM
NWRITE2 DECB
BNE NWRITE1
*
* compare checksums
LDA CHKSUM
JSR SCHAR send checksum msb
BCC NRD_DNR
LDA CHKSUM+1
JSR SCHAR send checksum lsb
BCC NRD_DNR
*
JSR RCHAR get checksum response
BCC NRD_DNR
CMPA #ACK
BNE NWR_ERR if checksum error, then flag write error
*
CLRB all OK, flag no error
BRA NWR_END
*
NWR_ERR LDB #10 flag write error
*
NWR_END STB CHKSUM used by VERIFY
TSTB
RTS
*
*
* verify last sector written to remote drive
*
NVERIFY LDB CHKSUM test last checksum
TSTB
RTS
*
*
* quck check and check drive ready
*
NCHECK LDA #'Q quick check command
JSR SCHAR
BCC NCK_ERR if timeout, then flag drive not ready
 
JSR RCHAR get response from host
BCC NCK_ERR
CMPA #ACK
BNE NCK_ERR if NAK, then flag drive not ready
 
CLRB all OK, flag drive ready
BRA NCK_END
*
NCK_ERR LDB #16 report drive not ready
ORCC #$01 check needs carry set as well
*
NCK_END TSTB
RTS
*
*
* recieve char from remote drive.
* timeout if no response for approx 1s.
* Entry: no parameters
* Exit: (A) = recieved char, (C)=1 if valid char, (C)=0 if timeout.
*
RCHAR PSHS X,Y
*
LDX #1000 1000x inner loop
RCHAR1 LDY #DELCON delay constant for inner loop (approx 1ms).
RCHAR2 LDA ACIAC1 test for recieved char
ASRA
BCS RCHAR3 get character
LEAY -1,Y else, continue to count delay
BNE RCHAR2
LEAX -1,X
BNE RCHAR1
PULS X,Y,PC return with error if timed out
*
RCHAR3 LDA ACIAD1 return data (carry bit still set)
PULS X,Y,PC
*
*
* transmit char to remote drive.
* timeout if no response for approx 1s. (allows for use of hardware flow control)
* Entry: (A) = char to transmit
* Exit: (A) = recieved char, (C)=1 if valid char, (C)=0 if timeout.
*
SCHAR PSHS X,Y
PSHS A
*
LDX #1000 1000x inner loop
SCHAR1 LDY #DELCON delay constant for inner loop (approx 1ms).
SCHAR2 LDA ACIAC1 test for space in transmit FIFO
ASRA
ASRA
BCS SCHAR3 send character
LEAY -1,Y else, continue to count delay
BNE SCHAR2
LEAX -1,X
BNE SCHAR1
PULS A
PULS X,Y,PC return with error if timed out
*
SCHAR3 PULS A
STA ACIAD1 send data (carry bit still set)
PULS X,Y,PC
*
** 'UF' Format RAMdisc to FLEX standard.
*
DISFOS FCB $0A,$0D
FCC 'Formating RAMdisk... '
FCB 4
MESS6 FCB $0A,$0D,4
FCC 'Ramdisk not allocated! '
FCB 4
*
UFSUB LDX #DISFOS
JSR PDATA1
LDX #DTYPTAB search for allocated ramdisk
CLRB
FMT9 LDA B,X
CMPA #DTYPRAM driver type 1 is ramdisk
BEQ FFOUND
INCB
CMPB #4 end of table? then not allocated.
BNE FMT9
LDX #MESS6
JSR PDATA1
RTS
*
FFOUND STB DRVNUM
LDX #DRVNUM-3
JSR DRVSEL
*
* set up free chain
*
LDX #BUFFER clear out buffer
CLRA
CLRB
DFL1 STA 0,X+
DECB
BNE DFL1
*
CLR TRACK
LDA #1
STA SECTOR
DFL2 LDX #BUFFER
LDA TRACK
STA 0,X
LDA SECTOR
INCA
CMPA #RMAXSEC+1 last sector on track?
BNE DFL3
INC 0,X
LDA #1
DFL3 STA 1,X
LDA TRACK
LDB SECTOR
JSR WRITSC
INC SECTOR
LDA SECTOR
CMPA #RMAXSEC+1
BNE DFL2
LDA #1
STA SECTOR
INC TRACK
LDA TRACK
CMPA #RMAXTRK
BNE DFL2
* break free chain at last track/sector
LDX #BUFFER
LDA #RMAXTRK-1
LDB #RMAXSEC
JSR READSC
LDX #BUFFER
CLR 0,X
CLR 1,X
LDA #RMAXTRK-1
LDB #RMAXSEC
JSR WRITSC
* set up sector structure, SIR, directory etc
LDX #BUFFER
CLRA
LDB #RMAXSEC
JSR READSC
LDX #BUFFER
CLR 0,X break end of directory chain
CLR 1,X
CLRA
LDB #RMAXSEC
JSR WRITSC
*
LDX #BUFFER
CLRA
LDB #3 set up SIR
JSR READSC
LDX #BUFFER
CLR 0,X break forward link
CLR 1,X
LDD #$5241 set volume name (RAMDISK )
STD 16,X
LDD #$4D44
STD 18,X
LDD #$4953
STD 20,X
LDD #$4B20
STD 22,X
LDD #1 volume number
STD 27,X
LDD #$0101 first trk/sec 01-01
STD 29,X
LDA #RMAXTRK-1
LDB #RMAXSEC
STD 31,X
STD 38,X
LDD #RTOTSEC total DATA sectors (2912-14)
STD 33,X
*
LDA #01 month set default creation date (SYS09's birthday!)
STA 35,X
LDA #07 day
STA 36,X
LDA #07 year
STA 37,X
*
RF3 CLRA
LDB #3
JSR WRITSC
*
LDX #BUFFER
CLRA
LDB #1
JSR READSC
LDX #BUFFER
LDA #$AA set the init flag
STA 0,X
LDA #$55
STA 1,X
CLRA
LDB #1
JMP WRITSC
*
********************************
* System specific Boot *
* command goes here. *
********************************
*
* Boot FLEX from the FPGA's internal pre-loaded scratch RAM
*
UBMESS FCB $08, $08
FCC 'Booting internal FLEX....'
FCB $0D,$0A,$04
*
UBSUB LDX #UBMESS
JSR PDATA1
*
LDX #$D3E5
LDY #CONTAB Overlay console driver table
UB1 LDD 0,Y++
STD 0,X++
CMPX #$D3FD
BNE UB1
*
LDX #$DE00 Overlay disk driver table
LDY #DISTAB
UB2 LDD 0,Y++
STD 0,X++
CMPX #$DE1E
BNE UB2
*
UBEND JMP $CD00
*
* FLEX console jump table.
CONTAB FDB INPNE INPUT NO ECHO
FDB DUMMY INTERRUPT HANDLER
FDB MONRAM+$02 SWI VECTOR
FDB MONRAM+$08 IRQ VECTOR
FDB DUMMY TIMER OFF
FDB DUMMY TIMER ON
FDB DUMMY TIMER INITIALIZATION
FDB CONTRL MONITOR
FDB DUMMY TERMINAL INITIALIZATION
FDB STATUS INPUT CHECK
FDB OUTP TERMINAL OUTPUT
FDB INPE TERMINAL INPUT WITH ECHO
*
* FLEX disk jump table.
DISTAB JMP READSC
JMP WRITSC
JMP BUSY
JMP RESTR1
JMP DRVSEL
JMP CHKRDY
JMP CHKQIK
JMP DINIT
JMP DWARM
JMP SEEKTS
*
* Monitor jumps
*
PDATA1 JMP [PDATAV]
OUTP JMP [OUTCHV]
INPE JMP [INCHEV]
INPNE JMP [INCHV]
STATUS JMP [INCHKV]
CONTRL JMP [MONITV]
DUMMY RTS
*
** 'UL' LOAD ROM DISK VIA SERIAL PORT
*
ULMES FCC 'Serial ROM Disk upload ...'
FCB $0D,$0A,$04
ULMES1 FCC 'ROM Disk Loaded'
FCB $0D,$0A,$04
*
ULSUB LDX #ULMES
JSR PDATA1
*
LDA #$00
STA DRVNUM
CLRA TRACK 0
LDB #$01 SECTOR 1
ULLOOP0 STA TRACK
STB SECTOR`
LBSR MAPIN
*
CLRB xfer 256 bytes at a time.
ULLOOP1 JSR LRBYTE transfer should be hex bytes
STA ,U+
DECB
BNE ULLOOP1
*
LBSR MAPOUT
*
LDA TRACK
LDB SECTOR
INCB
CMPB #EMAXSEC+1
BNE ULLOOP0
LDB #1
INCA
CMPA #EMAXTRK
BNE ULLOOP0
*
ULEXIT LDX #ULMES1
JMP PDATA1
*
* Read a byte from the serial port
*
LRBYTE PSHS B
BSR LRHEX Get hex digit.
ASLA
ASLA Shift to msb.
ASLA
ASLA
TFR A,B Save in B.
BSR LRHEX Get next digit.
PSHS B
ADDA 0,S+ Add together bytes.
PULS B,PC
*
LRHEX JSR INTER
BVS LRHEX
SUBA #$30 Remove ascii bias.
BMI LRHEX
CMPA #$09 Number?
BLE LRHEX1 Yes.
CMPA #$11 Keep testing.
BMI LRHEX
CMPA #$16
BGT LRHEX
SUBA #$07
LRHEX1 RTS
*
* ACIA INPUT TEST
*
INTEST LDA ACIAC1
BITA #$01
RTS
*
* RESET ACIA
*
ACIRST LDA #$03 master reset
STA ACIAC1
LDA #$11
STA ACIAC1
RTS
*
* ACIA INPUT
*
INTER LDA #16
STA DELCNT+0
CLR DELCNT+1
CLR DELCNT+2
INTER0 LDA ACIAC1
BITA #$01
BNE INTER1
BITA #$78
BEQ INTER2
BSR ACIRST
BRA INTER
*
INTER1 LDA ACIAD1
ANDCC #VFLAG
RTS
*
INTER2 DEC DELCNT+2
BNE INTER0
DEC DELCNT+1
BNE INTER0
DEC DELCNT+0
BNE INTER0
CLRA
ORCC #VFLAG
RTS
*
* ACIA OUTPUT
*
OUTTER PSHS A
*
OUTTE1 LDA ACIAC1
BITA #$02
BNE OUTTE2
BITA #$78
BEQ OUTTE1
BSR ACIRST
BRA OUTTE1
*
OUTTE2 PULS A
STA ACIAD1
RTS
*
** 'UX' Xmodem ROM Disk upload
*
UXMES FCB $0D,$0A
FCC 'Xmodem ROM Disk Upload'
FCB 4
UXMES1 FCB $0D,$0A
FCC 'Upload Complete'
FCB 4
UXMES2 FCB $0D,$0A
FCC 'Upload Error'
FCB 4
*
UXSUB LDX #UXMES
LBSR PDATA1
*
LDA #1
STA BLKNUM
LDX #XSTSTR
STX XSTATE
*
LDA #$00
STA DRVNUM
CLRA TRACK 0
LDB #$01 SECTOR 1
UXLOOP0 STA TRACK
STB SECTOR
LBSR MAPIN
*
CLRB xfer 256 bytes at a time.
UXLOOP1 LBSR XBYTE transfer should be hex bytes
BCS UXERR
STA ,U+
DECB
BNE UXLOOP1
*
LBSR MAPOUT
*
LDA TRACK
LDB SECTOR
INCB
CMPB #EMAXSEC+1
BNE UXLOOP0
LDB #1
INCA
CMPA #EMAXTRK
BNE UXLOOP0
*
UXEXIT LDX #UXMES1
JMP PDATA1
*
UXERR LBSR MAPOUT
LDX #UXMES2
LBRA PDATA1
*
* Get a Byte using XModem protocol
* Carry clear => no errors
* Carry set => errors
*
XBYTE PSHS X
LDX XSTATE
*
XBYTE0 LBSR INTER
BVC XBYTE1
LDA #NAK
LBSR OUTTER
LDX #XSTSTR
BRA XBYTE0
*
XBYTE1 JSR ,X
BNE XBYTE0
STX XSTATE
PULS X,PC
*
* START - LOOK FOR SOH (START OF HEADER) = $01
*
XSTSTR CMPA #SOH
BNE XSTSTR1
LDX #XSTBLK
ANDCC #$FF-CFLAG-ZFLAG No abort, no valid data (no exit)
RTS
*
XSTSTR1 CMPA #EOT
BNE XSTSTR2
LDA #ACK
LBSR OUTTER
ORCC #CFLAG+ZFLAG Set (c)=1 abort & exit
RTS
*
XSTSTR2 CMPA #CAN
BNE XSTSTR3
ORCC #CFLAG+ZFLAG Set (c)=1 abort & exit
RTS
*
XSTSTR3 ANDCC #$FF-CFLAG-ZFLAG
RTS
*
* Got SOH
* Now get block number
*
XSTBLK CMPA BLKNUM
BNE XSTBLKE
LDX #XSTCOM
ANDCC #$FF-CFLAG-ZFLAG No abort, No valid data (no exit)
RTS
*
* Error in block number
*
XSTBLKE LDA #NAK
LBSR OUTTER
LDX #XSTSTR
ANDCC #$FF-CFLAG-ZFLAG No abort, No valid data (no exit)
RTS
*
* Get complement of block number
*
XSTCOM COMA
CMPA BLKNUM
BNE XSTBLKE
CLR CHKSUM
LDA #128
STA BYTCNT
LDX #XSTDAT
ANDCC #$FF-CFLAG-ZFLAG No abort, No valid data (no exit)
RTS
*
* Get data bytes
*
XSTDAT PSHS A
ADDA CHKSUM
STA CHKSUM
PULS A
DEC BYTCNT
BNE XSTDAT1
LDX #XSTCHK
XSTDAT1 ANDCC #$FF-CFLAG No abort
ORCC #ZFLAG Valid data (exit)
RTS
*
* Byte count reached zero
* Check checksum byte
*
XSTCHK CMPA CHKSUM
BNE XSTCHK1 retry if wrong checksum
*
* Checksum OK ...
* increment block number
* and send ACK
*
INC BLKNUM
LDA #ACK
BRA XSTCHK2
*
* Checksum Error detected ...
* Reset Sector counter in ACCB to last 128 byte boundary
* and send NAK
*
XSTCHK1 PSHS B
TFR U,D
DECB
ANDB #128
TFR D,U
PULS B
LDA #NAK
XSTCHK2 LBSR OUTTER
LDX #XSTSTR
ANDCC #$FF-CFLAG-ZFLAG No abort, no valid data (no exit)
RTS
*
** 'UP' Load ROMdisk via config PROM.
*
UPMES FCB $08,$08
FCC 'Load ROM disk from config PROM.'
FCB 4
UPMES1 FCC 'Found SYNC, loading data...'
FCB $0A,$0D,4
UPMES2 FCC 'ROM Disk Loaded.'
FCB $0A,$0D,4
UPMES3 FCC 'ROM Disk Not Found.'
FCB $0A,$0D,4
*
UPSUB LDX #UPMES
JSR PDATA1
*
BSR UPRESET
LDY #$0020 Set up count for 2 MBit
LDX #$0000
UPSUB1 BSR UPBIT Shift in bit
BSR UPSYNC Test for Sync pattern`
BEQ UPSUB4 Skip if found
LEAX -1,X Count Down inner loop
CMPX #$0000
BNE UPSUB1 Branch if inner loop not complete
LEAY -1,X Count down outer loop
CMPY #$0000
BNE UPSUB1 Branch if outer loop not complete
*
LDX #UPMES3 2MBits scanned, no synch, report error
JMP PDATA1
*
UPSUB4 LDX #UPMES1 Sync found, now load disk
JSR PDATA1
*
CLRA
STA DRVNUM select Drive 0
LDB #$01
UPSUB2 STA TRACK track 0
STB SECTOR sector 1
*
LBSR MAPIN map in buffer
CLRB 256 byte sector
UPSUB3 BSR UPBYTE read byte from prom
STA ,U+ Store in buffer
DECB
BNE UPSUB3 Loop until sector read`
LBSR MAPOUT map out buffer
*
LDA TRACK Advance sector
LDB SECTOR
INCB
CMPB #EMAXSEC+1 Wrap on max sector count
BNE UPSUB2
LDB #1
INCA Advance track
CMPA #EMAXTRK
BNE UPSUB2
*
UPEXIT LDX #UPMES2 Load complete, report message
JMP PDATA1
*
* Reset Serial PROM
*
UPRESET LDA #PRSTHI Strobe the reset line
STA PROMREG
LDA #PRSTLO
STA PROMREG
LDX #$0000 Delay a while`
UPRST1 LEAX -1,X
CMPX #$0000
BNE UPRST1
STX SYNCREG+0 Clear Sync Shift Register
STX SYNCREG+2
RTS
*
* Input 1 Bit From PROM
*
UPBIT LDA #PCLKHI
STA PROMREG
LDA #PCLKLO
STA PROMREG
LDA PROMREG
LSRA
ASL SYNCREG+3
RTS
*
* Test for 32 bit Sync Word
*
UPSYNC ROL SYNCREG+2
ROL SYNCREG+1
ROL SYNCREG+0
LDD #SYNCLO
CMPD SYNCREG+2
BNE UPSYNCX
LDD #SYNCHI
CMPD SYNCREG+0
UPSYNCX RTS
*
* Input 1 Byte From PROM
*
UPBYTE PSHS B
LDB #8
UPBYTE1 BSR UPBIT
DECB
BNE UPBYTE1
LDA SYNCREG+3
PULS B,PC
*
***** NEXTCMD *****
*
NEXTEXT LBSR INPE GET ONE CHAR. FROM TERMINAL
ANDA #$7F STRIP PARITY FROM CHAR.
TFR A,B
LDA #$20
LBSR OUTP PRNT SPACE
CMPB #$60
BLE NXTEX0
SUBB #$20
*
***** DO TABLE LOOKUP *****
* FOR COMMAND FUNCTIONS
*
NXTEX0 LDX #EXTTAB POINT TO JUMP TABLE
NXTEX1 CMPB ,X+ DOES COMMAND MATCH TABLE ENTRY ?
BEQ JMPEXT BRANCH IF MATCH FOUND
LEAX 2,X POINT TO NEXT ENTRY IN TABLE
CMPX #EXTEND REACHED END OF TABLE YET ?
BNE NXTEX1 IF NOT END, CHECK NEXT ENTRY
LDX #MSGWHAT POINT TO MSG "WHAT?"
LBRA PDATA1 PRINT MSG AND RETURN
JMPEXT JMP [,X] JUMP TO COMMAND ROUTINE
*
* EXTENDED COMMAND JUMP TABLE
*
EXTTAB EQU *
FCC 'B' BOOT FLEX
FDB UBSUB
FCC 'L' LOAD ROM DISK OVER SERIAL PORT
FDB ULSUB
FCC 'F' FORMAT RAM DISK
FDB UFSUB
FCC 'P' LOAD ROM DISK FROM PROM
FDB UPSUB
FCC 'X' XMODEM ROM DISK UPLOAD
FDB UXSUB
*
EXTEND EQU *
*
MSGWHAT FCC "WHAT ?"
FCB $0A,$0D,$04
END
/flex9ide.sh
0,0 → 1,3
../../Tools/as09/as09.exe flex9ide.asm -l > flex9ide.lst
../../Tools/epedit/epedit.exe flex9ide.aux
 
/flex9ram.aux
0,0 → 1,10
t m
l FLEX9RAM.S19
t h
s flex9_ram_b16_0.vhd c000 c7ff
s flex9_ram_b16_1.vhd c800 cfff
s flex9_ram_b16_2.vhd d000 d7ff
s flex9_ram_b16_3.vhd d800 dfff
s flex9_ram_b16_ext.vhd f000 f7ff
q
 
/f9-var.asm
0,0 → 1,59
*
** TTYSET PARAMETERS
*
ORG $CC00
BSPCHR FCB $08
DELCHR FCB $18
EOLCHR FCB $3A
DEPCNT FCB 25
WIDCNT FCB $00
NULCNT FCB $04
TABCHR FCB '@
BSECHR FCB $00
EJTCNT FCB $00
PAUSE FCB $FF
ESCCHR FCB $1B
SYSDRV FCB 0
WRKDRV FCB 1
ZCC0D FCB $00
DATERG EQU *
MONTH FCB $00
DAY FCB $00
YEAR FCB $00
LASTRM FCB $00
UCTVEC FDB $0000
LINPTR FDB $0000
ESCVEC FDB $0000
CURCHR FCB $00
PRVCHR FCB $00
CURLIN FCB $00
LODOFF FDB $0000
TRNFLG FCB $00
TRNVEC FDB $0000
ERRTYP FCB $00
SIOFLG FCB $00
OUTSWT FCB $00
INPSWT FCB $00
FOPADR FDB $0000
FIPADR FDB $0000
CMDFLG FCB $00
CURCOL FCB $00
FCB $00
MEMEND FDB $BFFF
ERRVEC FDB $0000
FIEFLG FCB $01
ZCC30 FCB $00
ZCC31 FCB $00,$00,$00
ZCC34 FCB $00,$00,$00,$00,$00,$00,$00
ZCC3D EQU $CC3D
ZCC3F EQU $CC3F
ZCC43 EQU $CC43
ZCC45 EQU $CC45
ZCC47 EQU $CC47
ORG $CC49
MAPUP FCB $60 MAP LOWER TO UPPERCASE
ZCC4A EQU $CC4A
ZCC4B EQU $CC4B
ZCC4C EQU $CC4C
ZCC4D EQU $CC4D
END
/flex9cf8.aux
0,0 → 1,9
t m
l FLEX9CF8.S19
t h
s flex9_cf8_b16_0.vhd c000 c7ff
s flex9_cf8_b16_1.vhd c800 cfff
s flex9_cf8_b16_2.vhd d000 d7ff
s flex9_cf8_b16_3.vhd d800 dfff
q
 
/f9-equ.asm
0,0 → 1,8
Z0000 EQU $0000
Z0005 EQU $0005
Z0044 EQU $0044
Z00A0 EQU $00A0
ZC07F EQU $C07F
LINBUF EQU $C080
ZC0FF EQU $C0FF
END
/f9-spool.asm
0,0 → 1,134
*
** PRINTER SPOOLING
*
ORG $C700
PRSPL1 JMP ZC721
PRSPL2 JMP *
PRSPL3 JMP ZC747
PRSPL4 JMP ZC785
PRSPL5 JMP ZC795
PRSPL6 JMP ZC71F
*
** SPOOLER SCRATCH AREA
*
ZC712 FCB $0C,$00,$00,$00,$00,$C8,$10
ZC719 FCB $C8,$10
QCNT FCB $00
ZC71C FCB $00
ZC71D FCB $00
ZC71E FCB $00
*
ZC71F RTI
NOP
*
ZC721 ORCC #$10
LDX ZCC31
STS 2,X
TST ZCC34
BNE ZC73F
LDX #ZCCFC
INC ZCC34
TST ,X
BEQ ZC73F
ZC738 STX ZCC31
LDS $02,X
RTI
*
ZC73F LDX #ZCCF8
CLR ZCC34
BRA ZC738
*
ZC747 ORCC #$10
TST QCNT
BEQ ZC777
LDX ZC719
LDA ,X
PSHS A
LDD $01,X
LDX #ZCAC0
STD $40,X
PULS A
STA $03,X
CLR ,X
LDA #$01
STA $02,X
CLR $22,X
CLR $3B,X
ZC76D TST ZC71E
BEQ ZC79B
SWI3
NOP
BRA ZC76D
*
ZC777 ANDCC #$EF
ZC779 JSR [TOFVEC]
CLR ZCCFC
SWI3
NOP
BRA ZC779
*
ZC785 ORCC #$10
TST ZCC30
BEQ ZC791
SWI3
NOP
BRA ZC785
*
ZC791 INC ZCC30
RTS
*
ZC795 CLR ZCC30
ANDCC #$EF
RTS
*
ZC79B TST ZC71D
BNE ZC7C7
LDX #ZCAC0
JSR FMS
BNE ZC7C7
TST ZC71C
BEQ ZC7BC
CLR ZC71C
CMPA #$0A
BEQ ZC7C3
PSHS A
LDA #$0A
BSR ZC7F6
PULS A
ZC7BC CMPA #$0D
BNE ZC7C3
STA ZC71C
ZC7C3 BSR ZC7F6
BRA ZC79B
*
ZC7C7 LDA #$0D
BSR ZC7F6
LDA #$0A
BSR ZC7F6
LDA ZC712
BSR ZC7F6
CLR ZC71D
LDX ZC719
TST $03,X
BEQ ZC7E3
DEC $03,X
JMP ZC747
*
ZC7E3 LEAX $04,X
CMPX #FCB
BNE ZC7ED
LDX #ZC810
ZC7ED STX ZC719
DEC QCNT
JMP ZC747
*
ZC7F6 JSR PCHK
BMI ZC800
SWI3
NOP
BRA ZC7F6
*
ZC800 JMP POUT
ZC810 EQU $C810
ZC838 EQU $C838
END
/flex9ide.asm
0,0 → 1,13
NAM FLEX9 SOURCE
INCLUDE "f9-moneq.asm"
INCLUDE "f9-equ.asm"
INCLUDE "f9-spool.asm"
INCLUDE "f9-sfcb.asm"
INCLUDE "f9-init.asm"
INCLUDE "f9-var.asm"
INCLUDE "f9-data.asm"
INCLUDE "f9-cli.asm"
INCLUDE "f9-monio.asm"
INCLUDE "f9-fms.asm"
INCLUDE "f9-dkide.asm"
END COLDS
/flex9ads.sh
0,0 → 1,13
../../Tools/as09/as09.exe flex9ads.asm -l > flex9ads.lst
/f9-dkram.asm
0,0 → 1,192
*
** FLEX 9 DISK DRIVERS
*
* FOR SYS09BUG ON THE DIGILENT SPARTAN 3 STARTER BOARD
* WITH I/O MAPPED AT $XE000
* AND ROM MAPPED AT $XF000
* THE DIGILENT SPARTAN 3 STARTER BOARD HAS 1MBYTE OF SRAM
* THE FIRST 64K IS USED BY FLEX,
* THE SECOND 192K IS USED AS A ROM DISK
* THE REMAINING RAM IS USED FOR A RAM DISK
*
* These drivers should also work on the B5-X300 board
* although there is only enough room for the ROM Disk.
*
IMASK EQU $10 IRQ MASK CC
FMASK EQU $40 FIRQ MASK CC
TRPAGE EQU $0E PAGE $E000 DAT ADDRESS
DATREG EQU $FFF0 DAT REGISTERS
ORG $DE00
*
* DISK DRIVER JUMP TABLE LAST UPDATE: 22/12/2006
* Disk driver for RAM Disk.
*
* 14 SECTORS PER TRACK
* 16 * N TRACKS PER DISK
*
* ROM DISK OCCUPIES $10000 - $1E000, $20000 - $2E000, $30000 - $3E000
* RAM DISK OCCUPIES $40000 - $4E000 ... $F0000 - $FE000
* Track Buffer page mapped at $E000 - $EFFF
* TRPAGE = $0E = 14 x $1000 (4 K pages)
* LEAST SIGNIFICANT NYBBLE OF THE DAT IS INVERTED
* ON SWTPC ROM AT $XF000 AND IO AT $XE000
* APPEARS THROUGHOUT THE MEMORY SO MUST BE SKIPPED OVER
* WHEN USING RAM AS A RAMDISK.
* THE MSN OF THE TRACK MAPS INTO THE MSN OF THE DAT
* THE LSN OF THE TRACK NUMBER INDEXES INTO THE 4K RAM PAGE
* THE SECTOR MAPS INTO THE LSN OF THE DAT WHICH IS INVERTED
*
*
READ JMP READSC
WRITE JMP WRITSC
VERIFY JMP BUSY
RESTOR JMP RESTR1
DRIVE JMP DRVSEL
DRVRDY JMP CHKDRV
QUICK JMP CHKDRV
COLDDR JMP INITDR
WARMDR JMP WARMD1
SEEK JMP SEEKTS
*
* RAM SPACE
*
WRKDR FDB 0
WRKTR FDB 0,0,0,0
SECPTR FDB 0
TRKCNT FCB 0
SECCNT FCB 0
VERERR FCB 0
CCSAVE FCB 0
*
DRVBAS FCB $10 DRIVE 0
FCB $40 DRIVE 1
FCB $40 DRIVE 2
FCB $40 DRIVE 3
*
INITDR RTS
WARMD1 RTS
*
* Seek track and sector
* A holds track number (0-32)
* B holds sector number (1-14)
*
SEEKTS STA TRKCNT
STB SECCNT
ANDCC #$FE ; CLEAR CARRY
ORCC #$40 ; SET Z
RTS
*
* MAP RAM DISK INTO I/O SPACE
*
MAPIN TFR CC,A ; Save state of interrupt masks
STA CCSAVE
ORCC #FMASK+IMASK ; Mask interrupts while IO mapped out
LDA TRKCNT
LDU #DRVBAS ; Point to Drive base offset
LDB WRKDR ; Get working drive number
ADDA B,U ; Add Base offset into RAM
ANDA #$F0 ; Mask MSN
STA ,-S ; Save A on stack
*
LDA SECCNT
SUBA #1 ; Sectors 1 to 14 => 0 to 13
EORA #$0F ; Complement LSNybble
ANDA #$0F
*
ADDA ,S+ ; Add sector to LSN of Track and pop
STA DATREG+TRPAGE
*
LDA TRKCNT ; LSN of Track indexes into 4K page
ANDA #$0F
ADDA #TRPAGE*16
STA SECPTR
CLR SECPTR+1
LDU SECPTR
RTS
*
* MAP RAM DISK OUT OF MEMORY
*
MAPOUT LDA #TRPAGE ; Point to the I/O page
EORA #$0F ; Complement LSNybble
STA DATREG+TRPAGE ; map in I/O page
LDA CCSAVE ; restore interrupt masks
TFR A,CC
RTS
*
* READ DISK DRIVER
*
READSC LBSR SEEKTS ; SEEK TRACK & SECTOR
PSHS U,X
BSR MAPIN ; MAP RAM DISK INTO I/O SPACE
*
CLRB
READ3 LDA ,U+
STA ,X+ ; Move Sector to FCB
INCB
BNE READ3
*
BSR MAPOUT ; MAP RAM DISK OUT OF I/O SPACE
CLRB ; Z SET C CLEAR
PULS U,X,PC ; Restore registers and return
*
* WRITE DISK DRIVER
*
WRITSC BSR SEEKTS ; SEEK TRACK & SECTOR
PSHS U,X
BSR MAPIN ; MAP RAM DISK INTO I/O SPACE
*
CLRB
WRIT3 LDA ,X+ ; COPY FCB BLOCK TO RAM DISK
STA ,U+
INCB
BNE WRIT3
*
BSR MAPOUT ; MAP OUT RAM DISK
CLRB ; SET Z, CLEAR C
PULS U,X,PC ; Restore registers and return
*
* RESTORE DISK DRIVER (SEEK TRACK 00)
*
RESTR1 PSHS A
CLRA ; Track 0
LDAB #$01 ; Sector 1
LBSR SEEKTS
PULS A,PC
*
* CHECK FOR BUSY
* Doubles as VERIFY
*
BUSY CLRB Never busy
RTS
*
* DRIVE SELECT DISK DRIVER
*
DRVSEL PSHS X
LDA 3,X GET DRIVE # FROM FCB
CMPA #3
BLS DRVS2 IF > 3, SET IT TO 0
CLRA
DRVS2 BSR MXWT MOVE X TO WORKING TRK
LDB TRKCNT
STB 0,X SAVE TRACK
STA WRKDR SAVE DESIRED DRV AS WORKING DRV
BSR MXWT MOVE X TO WORKING TRK
LDA 0,X GET WORKING TRK ON DESIRED DRV
STA TRKCNT UPDATE 1771 TRACK REG
CLRB ; SET Z, CLEAR C
PULS X,PC
*
* MOVE INDEX REG TO POINT TO
* WORKING TRACK STORAGE
*
MXWT LDX #WRKTR POINT TO START OF STG
LDB WRKDR GET WORKING DRIVE
ABX
MXWT2 RTS
*
* CHECK DRIVE READY DISK DRIVER
*
CHKDRV LDA 3,X
CLRB ; CLEAR C, SET Z
RTS
END
/f9-dkcf8.asm
0,0 → 1,189
*
** FLEX 9 COMPACT FLASH DISK DRIVERS
*
* FOR SYS09BUG 1.2 ON THE BURCHED B5-X300
* WITH I/O MAPPED AT $XE000
* AND ROM MAPPED AT $XF000
* THE BURCHED B5-X300 HAS 256KBYTES OF SRAM
* THE FIRST 64K IS USED BY FLEX,
* THE SECOND 192K MAY BE USED AS A RAM DISK
*
*
IMASK EQU $10 IRQ MASK CC
FMASK EQU $40 FIRQ MASK CC
DATREG EQU $FFF0 DAT REGISTERS
*
CF_BASE EQU $E040
CF_DATA EQU CF_BASE+0
CF_ERROR EQU CF_BASE+1 ; read error
CF_FEATURE EQU CF_BASE+1 ; write feature
CF_SECCNT EQU CF_BASE+2
CF_SECNUM EQU CF_BASE+3
CF_CYLLO EQU CF_BASE+4
CF_CYLHI EQU CF_BASE+5
CF_HEAD EQU CF_BASE+6
CF_STATUS EQU CF_BASE+7 ; read status
CF_COMAND EQU CF_BASE+7 ; write command
*
* Command Equates
*
CMDREAD EQU $20 ; Read Single sector
CMDWRITE EQU $30 ; Write Single sector
CMDFEATURE EQU $EF
FEAT8BIT EQU $01 ; enable 8 bit transfers
HEADLBA EQU $E0
*
* Status bit equates
*
BSY EQU $80
DRDY EQU $40
DRQ EQU $08
ERR EQU $01
ORG $DE00
*
* DISK DRIVER JUMP TABLE
*
READ JMP READSC
WRITE JMP WRITSC
VERIFY JMP BUSY
RESTOR JMP RESTR1
DRIVE JMP DRVSEL
DRVRDY JMP CHKDRV
QUICK JMP CHKDRV
COLDDR JMP INITDR
WARMDR JMP WARMD1
SEEK JMP SEEKTS
*
* RAM SPACE
*
DRVNUM FCB 0
*
*
* INITIALIZE CF CARD FOR 8 BIT LBA MODE
*
INITDR BSR WAITRDY
LDA #HEADLBA
STA CF_HEAD
LDA #FEAT8BIT
STA CF_FEATURE
LDA #CMDFEATURE
STA CF_COMAND
BRA WAITRDY
*
* RESTORE DISK DRIVER (SEEK TRACK 00)
*
RESTR1 BSR DRVSEL
CLRA ; Track 0
LDB #$01 ; Sector 1
*
* Seek track and sector
* A holds track number (0 - ??)
* B holds sector number (1 - ??)
* Sector numbers starts from 1
* subtract 1 to start from sector 0 on CF
*
SEEKTS DECB
STB CF_SECNUM
STA CF_CYLLO
LDB DRVNUM
STB CF_CYLHI
LDB #$01
STB CF_SECCNT
CLRB
WARMD1 RTS
*
* READ SECTORS FROM CF
*
*
READSC BSR SEEKTS
LDA #CMDREAD ; IDE READ MULTIPLE
STA CF_COMAND
BSR WAITRDY
*
* READ LOOP
*
CLRB
RDLP1 BSR WAITDRQ
LDA CF_DATA
STA ,X+
DECB
BNE RDLP1
*
CLRB
RDLP2 BSR WAITDRQ
LDA CF_DATA
DECB
BNE RDLP2
*
BSR WAITRDY
CLRB
RTS
*
* WRITE SECTOR TO CF
*
WRITSC BSR SEEKTS ; SEEK TRACK & SECTOR
LDA #CMDWRITE; IDE WRITE MULTIPLE
STA CF_COMAND
BSR WAITRDY
*
* WRITE LOOP
*
CLRB
WRTLP1 BSR WAITDRQ
LDA ,X+
STA CF_DATA
DECB
BNE WRTLP1
*
CLRB
WRTLP2 BSR WAITDRQ
CLRA
STA CF_DATA
DECB
BNE WRTLP2
*
BSR WAITRDY
CLRB
RTS
*
* CHECK FOR BUSY
* Doubles as VERIFY
*
BUSY CLRB Never busy
RTS
*
* DRIVE SELECT DISK DRIVER
*
DRVSEL LDA 3,X GET DRIVE # FROM FCB
CMPA #3
BLS DRVS2 IF > 3, SET IT TO 0
CLRA
DRVS2 STA DRVNUM
CLRB ; SET Z, CLEAR C
RTS
*
* CHECK DRIVE READY DISK DRIVER
*
CHKDRV LDA 3,X
CLRB ; CLEAR C, SET Z
RTS
*
* WAIT UNTIL READY
*
WAITRDY LDA CF_STATUS
BITA #BSY
BNE WAITRDY
LDA CF_STATUS
BITA #DRDY
BEQ WAITRDY
RTS
*
* WAIT FOR DATA REQUEST
*
WAITDRQ LDA CF_STATUS
BITA #DRQ
BEQ WAITDRQ
RTS
*
END
 
/flex_ram_vhd
0,0 → 1,162
--
-- Flex9 O/S Initialised 8KByte RAM
--
-- v1.0 - 22 December 2006 - John Kent
-- v1.1 - 1 February 2008 - David Burnette
-- reworked to use autogenerated block ram utility
 
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
library unisim;
use unisim.vcomponents.all;
 
entity flex_ram is
Port (
clk : in std_logic;
rst : in std_logic;
cs : in std_logic;
rw : in std_logic;
addr : in std_logic_vector (12 downto 0);
rdata : out std_logic_vector (7 downto 0);
wdata : in std_logic_vector (7 downto 0)
);
end flex_ram;
 
architecture rtl of flex_ram is
 
signal we : std_logic;
signal cs0 : std_logic;
signal cs1 : std_logic;
signal cs2 : std_logic;
signal cs3 : std_logic;
signal dp0 : std_logic;
signal dp1 : std_logic;
signal dp2 : std_logic;
signal dp3 : std_logic;
signal rdata0 : std_logic_vector(7 downto 0);
signal rdata1 : std_logic_vector(7 downto 0);
signal rdata2 : std_logic_vector(7 downto 0);
signal rdata3 : std_logic_vector(7 downto 0);
 
component FLEX9_C000
Port (
clk : in std_logic;
rst : in std_logic;
cs : in std_logic;
rw : in std_logic;
addr : in std_logic_vector (10 downto 0);
rdata : out std_logic_vector (7 downto 0);
wdata : in std_logic_vector (7 downto 0)
);
end component;
component FLEX9_C800
Port (
clk : in std_logic;
rst : in std_logic;
cs : in std_logic;
rw : in std_logic;
addr : in std_logic_vector (10 downto 0);
rdata : out std_logic_vector (7 downto 0);
wdata : in std_logic_vector (7 downto 0)
);
end component;
component FLEX9_D000
Port (
clk : in std_logic;
rst : in std_logic;
cs : in std_logic;
rw : in std_logic;
addr : in std_logic_vector (10 downto 0);
rdata : out std_logic_vector (7 downto 0);
wdata : in std_logic_vector (7 downto 0)
);
end component;
component FLEX9_D800
Port (
clk : in std_logic;
rst : in std_logic;
cs : in std_logic;
rw : in std_logic;
addr : in std_logic_vector (10 downto 0);
rdata : out std_logic_vector (7 downto 0);
wdata : in std_logic_vector (7 downto 0)
);
end component;
 
begin
 
addr_c000 : FLEX9_C000 port map (
clk => clk,
rst => rst,
cs => cs0,
rw => rw,
addr => addr(10 downto 0),
wdata => wdata,
rdata => rdata0
);
 
addr_c800 : FLEX9_C800 port map (
clk => clk,
rst => rst,
cs => cs1,
rw => rw,
addr => addr(10 downto 0),
wdata => wdata,
rdata => rdata1
);
addr_d000 : FLEX9_D000 port map (
clk => clk,
rst => rst,
cs => cs2,
rw => rw,
addr => addr(10 downto 0),
wdata => wdata,
rdata => rdata2
);
addr_d800 : FLEX9_D800 port map (
clk => clk,
rst => rst,
cs => cs3,
rw => rw,
addr => addr(10 downto 0),
wdata => wdata,
rdata => rdata3
);
 
my_flex : process ( rw, addr, cs, rdata0, rdata1, rdata2, rdata3 )
begin
we <= not rw;
case addr(12 downto 11) is
when "00" =>
cs0 <= cs;
cs1 <= '0';
cs2 <= '0';
cs3 <= '0';
rdata <= rdata0;
when "01" =>
cs0 <= '0';
cs1 <= cs;
cs2 <= '0';
cs3 <= '0';
rdata <= rdata1;
when "10" =>
cs0 <= '0';
cs1 <= '0';
cs2 <= cs;
cs3 <= '0';
rdata <= rdata2;
when "11" =>
cs0 <= '0';
cs1 <= '0';
cs2 <= '0';
cs3 <= cs;
rdata <= rdata3;
when others =>
null;
end case;
end process;
 
end architecture rtl;
 
/flex9ads.asm
0,0 → 1,13
NAM FLEX9 FOR THE ADS6809
INCLUDE "f9-moneq.asm"
INCLUDE "f9-equ.asm"
INCLUDE "f9-spool.asm"
INCLUDE "f9-sfcb.asm"
INCLUDE "f9-init.asm"
INCLUDE "f9-var.asm"
INCLUDE "f9-data.asm"
INCLUDE "f9-cli.asm"
INCLUDE "f9-monio.asm"
INCLUDE "f9-fms.asm"
INCLUDE "f9-dkfdc.asm"
END COLDS
/f9-init.asm
0,0 → 1,101
*
** FLEX INITIATION
*
ORG $CA00
ZCA00 BRA ZCA08
ZCA02 JSR >ZCAAC
RTS
ZCA06 SUBB #$A0
ZCA08 LDA #$39
STA >ZD3FD
LDX >MEMEND
LEAX $00A1,X
STX >ZCA06
JSR [TINVEC]
LDX >INVEC
STX >INCH+1
STX >INCH2+1
LDX >OUTVEC
STX >OUTCH+1
STX >OUTCH2+1
LDX >STAVEC
STX >ZCD4E+1
LDX #Z00A0
LDB #$B9
ZCA38 LDA ,X
STB ,X
NOP
CMPB ,X
BNE ZCA4C
STA ,X
LEAX $0400,X
CMPX >ZCA06
BNE ZCA38
ZCA4C LEAX $FF5F,X
STX >MEMEND
LDX #WARMS
STX >ESCVEC
LDX #TTLSTR
JSR >PSTRG1
JSR >PCRLF1
BSR ZCA02
JSR >PCRLF1
LDX #FCB
LDA #$01
STA ,X
JSR >FMS
BEQ ZCA7B
LDA $01,X
JSR >ZD200
JMP >WARM1
 
ZCA7B LDX #LINBUF
ZCA7E STX >LINPTR
LDX #FCB
JSR >FMS
BEQ ZCA8E
PSHS Y,X
JMP >ZD2D7
 
ZCA8E LDX >LINPTR
STA ,X+
CMPA #$0D
BNE ZCA7E
LDX #FCB
JSR >ZD1F4
LDX #LINBUF
STX >LINPTR
LDX #WARM1
STX >ZCC43
JMP >ZD32E
 
ZCAAC LDX #DATSTR
JSR >PSTRG1
JSR >INBUF1
BSR ZCACB
BCS ZCAAC
STA >MONTH
BSR ZCACB
BCS ZCAAC
ZCAC0 STA >DAY
BSR ZCACB
BCS ZCAAC
STA >YEAR
RTS
 
ZCACB JSR >INDEC1
BCS ZCADB
LDA >LODOFF+1
TSTB
BEQ ZCAD9
ANDCC #$FE
RTS
 
ZCAD9 ORCC #$01
ZCADB RTS
 
TTLSTR FCC "6809 FLEX V3.01"
FCB $04
DATSTR FCC "DATE (MM,DD,YY)? "
FCB $04
END
/flex9ram.sh
0,0 → 1,3
../../Tools/as09/as09.exe flex9ram.asm -l > flex9ram.lst
../../Tools/epedit/epedit.exe flex9ram.aux
 
/flex9cf8.sh
0,0 → 1,2
../../Tools/as09/as09.exe flex9cf8.asm -l > flex9cf8.lst
../../Tools/epedit/epedit.exe flex9cf8.aux
/f9-cli.asm
0,0 → 1,814
*********************************************
*
* FLEX COMMAND LINE INTERPRETER & SUBROUTINES
*
*********************************************
ORG $CD00
*
** FLEX JUMPS
*
COLDS JMP >COLD1
WARMS JMP >WARM1
RENTER JMP >RENT1
INCH JMP >INCH
INCH2 JMP >INCH2
OUTCH JMP >OUTCH
OUTCH2 JMP >OUTCH2
GETCHR JMP >GETCH1
PUTCHR JMP >PUTCH1
INBUFF JMP >INBUF1
PSTRNG JMP >PSTRG1
CLASS JMP >CLASS1
PCRLF JMP >PCRLF1
NXTCH JMP >NXTCH1
RSTRIO JMP >RSTIO1
GETFIL JMP >GETFL1
LOAD JMP >LOAD1
SETEXT JMP >SETEX1
ADDBX JMP >ADDBX1
OUTDEC JMP >OUTDC1
OUTHEX JMP >OUTHX1
RPTERR JMP >RPTER1
GETHEX JMP >GETHX1
OUTADR JMP >OUTAD1
INDEC JMP >INDEC1
DOCMND JMP >DOCMD1
ZCD4E JMP >ZCD4E
JMP >ZCE05
JMP >ZCE05
*
** COLD START ENTRY
*
COLD1 LDS #ZC07F
ZCD5B CLR >LASTRM
JSR >ZD400
CLR >CMDFLG
JSR >ZD3FD
*
** WARM START ENTRY
*
WARM1 LDS #ZC07F
JSR >WARMDR
LDX #WARMS
STX >ESCVEC
LDX #PRSPL1
STX [SWIVVC]
LDX >IHNDVC
STX [IRQVVC]
LDX #ZCCF8
STX >ZCC31
CLR >ZCC34
CLR >ZCC4C
BSR RSTIO1
LDA >LASTRM
CMPA >EOLCHR
BNE ZCD9D
INC >LINPTR+1
BRA RENT1
 
ZCD9D TST >CMDFLG
LBNE ZD33B
JSR >FMSCLS
BNE ZCD5B
LDX #PMTSTR
JSR >PSTRG1
BSR INBUF1
*
** MAIN CONTROL LOOP
*
RENT1 JSR >ZD0D4
CMPA #$0D
BEQ ZCD9D
ZCDB8 LDX #FCB
INC >ZCC0D
JSR >GETFL1
BCS ZCDD9
LDX #CMDTBL
BSR ZCE06
BEQ ZCDD3
LDX >UCTVEC
BEQ ZCDD6
BSR ZCE06
BNE ZCDD6
ZCDD3 JMP [$01,X]
 
ZCDD6 JSR >ZD22E
ZCDD9 LDX #WOTMSG
LDA #$15
ZCDDE STA >ERRTYP
ZCDE1 JSR >PSTRG1
ZCDE4 CLR >LASTRM
JMP >WARM1
*
** RESTORE IO VECTORS
*
RSTIO1 LDX >OUTCH2+1
STX >OUTCH+1
LDX >INCH2+1
STX >INCH+1
CLR >INPSWT
CLR >OUTSWT
CLR >SIOFLG
CLR >FIPADR
CLR >FOPADR
ZCE05 RTS
 
ZCE06 LDY #ZC844
ZCE0A LDA ,Y+
CMPA #$5F
BLS ZCE12
SUBA #$20
ZCE12 CMPA ,X+
BNE ZCE1E
TST ,X
BNE ZCE0A
TST ,Y
BEQ ZCE2A
ZCE1E TST ,X+
BNE ZCE1E
LEAX $02,X
TST ,X
BNE ZCE06
ANDCC #$FB
ZCE2A RTS
*
** GET USER COMMAND LINE
*
INBUF1 LDX #LINBUF
STX >LINPTR
ZCE31 JSR >GETCH1
CMPA >DELCHR
BEQ ZCE56
CMPA >BSPCHR
BEQ ZCE5D
CMPA #$0D
BEQ ZCE4F
CMPA #$0A
BEQ ZCE78
CMPA #$1F
BLS ZCE31
ZCE4A CMPX #ZC0FF
BEQ ZCE31
ZCE4F STA ,X+
CMPA #$0D
BNE ZCE31
RTS
 
ZCE56 LDX #QRYSTR
BSR PSTRG1
BRA INBUF1
 
ZCE5D CMPX #LINBUF
BEQ ZCE56
LEAX -$01,X
LDA >BSECHR
CMPA #$08
BNE ZCE73
LDA #$20
JSR >ZCF66
LDA >BSECHR
ZCE73 JSR >ZCF66
BRA ZCE31
 
ZCE78 LDA #$0D
JSR >PUTCH1
LDA #$20
BRA ZCE4A
 
PSTRG1 BSR PCRLF1
ZCE83 LDA ,X
CMPA #$04
BEQ ZCEF8
JSR >PUTCH1
LEAX $01,X
BRA ZCE83
 
ZCE90 JSR >ZCD4E
BEQ ZCEFA
JSR [ZD3E5]
CMPA >ESCCHR
BNE ZCEFA
ZCE9E CLR >CURLIN
ZCEA1 JSR [ZD3E5]
CMPA >ESCCHR
BEQ ZCEFA
CMPA #$03 CTRL C
BNE ZCEA1
CLR >LASTRM
JMP [ESCVEC]
*
** PRINT CR, LINEFEED
*
PCRLF1 TST >SIOFLG
BNE ZCEE1
BSR ZCE90
LDA >DEPCNT
BEQ ZCEE1
CMPA >CURLIN
BHI ZCEDE
CLR >CURLIN
TST >PAUSE
BEQ ZCED0
BSR ZCE9E
ZCED0 PSHS B
LDB >EJTCNT
BEQ ZCEDC
ZCED7 BSR ZCEE1
DECB
BNE ZCED7
ZCEDC PULS B
ZCEDE INC >CURLIN
ZCEE1 LDA #$0D
BSR PUTCH1
LDA #$0A
BSR PUTCH1
PSHS B
LDB >NULCNT
BEQ ZCEF6
ZCEF0 CLRA
BSR PUTCH1
DECB
BNE ZCEF0
ZCEF6 PULS B
ZCEF8 ANDCC #$FE
ZCEFA RTS
*
** GET A CHARACTER HONOURING TTYSET
*
GETCH1 TST >INPSWT
BNE ZCF1A
TST >FIPADR
BEQ ZCF15
BSR ZCF21
TST >FIEFLG
BEQ ZCF1D
TST >FOPADR
BEQ ZCF1D
BSR ZCF66
BRA ZCF1D
ZCF15 JSR >INCH
BRA ZCF1D
 
ZCF1A JSR >INCH2
ZCF1D CLR >CURLIN
RTS
 
ZCF21 STX >ZCC47
LDX >FIPADR
BRA ZCF2F
 
ZCF29 STX >ZCC47
LDX >FOPADR
ZCF2F JSR >FMS
BNE ZCF38
LDX >ZCC47
RTS
 
ZCF38 CLR >FOPADR
JSR >RPTER1
JMP >WARMS
*
** OUTPUT CHARACTER HONOURING TTYSET
*
PUTCH1 TST >SIOFLG
BNE ZCF66
CMPA #$1F
BHI ZCF4F
CLR >CURCOL
BRA ZCF66
 
ZCF4F INC >CURCOL
PSHS A
LDA >WIDCNT
BEQ ZCF64
CMPA >CURCOL
BCC ZCF64
JSR >PCRLF1
INC >CURCOL
ZCF64 PULS A
ZCF66 PSHS A
TST >OUTSWT
BNE ZCF80
TST >FOPADR
BEQ ZCF76
BSR ZCF29
BRA ZCF83
 
ZCF76 TST >FIPADR
BNE ZCF83
JSR >OUTCH
BRA ZCF83
ZCF80 JSR >OUTCH2
ZCF83 PULS A
RTS
 
OUTDC1 CLR >ZCC4A
STB >TRNFLG
LDA #$04
STA >ZCC4D
LDD ,X
LDX #DECTBL
ZCF96 BSR ZCFA3
LEAX $02,X
DEC >ZCC4D
BNE ZCF96
TFR B,A
BRA OUTHXR
 
ZCFA3 CLR >ZCC4B
ZCFA6 CMPD ,X
BCS ZCFB2
SUBD ,X
INC >ZCC4B
BRA ZCFA6
 
ZCFB2 PSHS A
LDA >ZCC4B
BNE ZCFC9
TST >ZCC4A
BNE ZCFC9
TST >TRNFLG
BEQ ZCFCE
LDA #$20
BSR ZCFEA
BRA ZCFCE
 
ZCFC9 INC >ZCC4A
BSR OUTHXR
ZCFCE PULS PC,A
*
** DISPLAY HEX ADDRESS
*
OUTAD1 BSR OUTHX1
LEAX $01,X
*
** OUPUT HEX BYTE
*
OUTHX1 LDA ,X
BSR OUTHXL
LDA ,X
BRA OUTHXR
 
OUTHXL LSRA
LSRA
LSRA
LSRA
OUTHXR ANDA #$0F
ADDA #$30
CMPA #$39
BLS ZCFEA
ADDA #$07
ZCFEA JMP >PUTCH1
*
** CLASSIFY CHARACTER ALHA/NUMERIC
*
CLASS1 CMPA #'0
BCS ZD005
CMPA #'9
BLS ZD00B
CMPA #'A
BCS ZD005
CMPA #'Z
BLS ZD00B
CMPA #'a $61
BCS ZD005
CMPA #'z $7A
BLS ZD00B
ZD005 ORCC #$01
STA >LASTRM
RTS
ZD00B ANDCC #$FE
RTS
*
** GET NEXT CHARACTER FROM FILE
*
NXTCH1 PSHS X
LDX >LINPTR
LDA >CURCHR
STA >PRVCHR
ZD019 LDA ,X+
STA >CURCHR
CMPA #$0D
BEQ ZD032
CMPA >EOLCHR
BEQ ZD032
STX >LINPTR
CMPA #$20
BNE ZD032
CMPA ,X
BEQ ZD019
ZD032 BSR CLASS1
PULS PC,X
*
** PARSE FILE SPEC. IN LINE BUFFER
*
GETFL1 LDA #$15
STA $01,X
LDA #$FF
STA $03,X
CLR $04,X
CLR $0C,X
JSR >ZD0D4
LDA #$08
STA >ZCC4B
BSR ZD080
BCS ZD07C
BNE ZD05F
BSR ZD080
BCS ZD07C
BNE ZD05F
CMPX >ZCC3F
BEQ ZD0C7
BSR ZD080
BLS ZD0C7
ZD05F LDX >ZCC3F
TST $04,X
BEQ ZD0C7
TST $03,X
BPL ZD079
TST >ZCC0D
BEQ ZD074
LDA >SYSDRV
BRA ZD077
 
ZD074 LDA >WRKDRV
ZD077 STA $03,X
ZD079 CLR >ZCC0D
ZD07C LDX >ZCC3F
RTS
 
ZD080 BSR NXTCH1
BCS ZD0C7
CMPA #$39
BHI ZD09D
LDX >ZCC3F
TST $03,X
BPL ZD0C7
ANDA #$03
STA $03,X
JSR >NXTCH1
BCC ZD0C7
ZD098 CMPA #$2E
ANDCC #$FE
RTS
 
ZD09D LDB >ZCC4B
BMI ZD0C7
PSHS B
SUBB #$05
STB >ZCC4B
PULS B
ZD0AB CMPA >MAPUP
BCS ZD0B2
SUBA #$20
ZD0B2 STA $04,X
LEAX $01,X
DECB
JSR >NXTCH1
BCC ZD0C4
CMPA #$2D
BEQ ZD0C4
CMPA #$5F
BNE ZD0CA
ZD0C4 TSTB
BNE ZD0AB
ZD0C7 ORCC #$01
RTS
 
ZD0CA TSTB
BEQ ZD098
CLR $04,X
LEAX $01,X
DECB
BRA ZD0CA
 
ZD0D4 STX >ZCC3F
LDX >LINPTR
ZD0DA LDA ,X
CMPA #$20
BNE ZD0E4
LEAX $01,X
BRA ZD0DA
ZD0E4 STX >LINPTR
LDX >ZCC3F
RTS
*
** DEFAULT FILE EXTENSION
*
SETEX1 PSHS Y,X
LDB $0C,X
BNE ZD109
LDY #EXTTBL
CMPA #$0B
BHI ZD109
LDB #$03
MUL
LEAY B,Y
LDB #$03
ZD100 LDA ,Y+
STA $0C,X
LEAX $01,X
DECB
BNE ZD100
ZD109 PULS PC,Y,X
*
** STANDARD FILE NAME EXTTENSIONS
*
EXTTBL FCC "BIN"
FCC "TXT"
FCC "CMD"
FCC "BAS"
FCC "SYS"
FCC "BAK"
FCC "SCR"
FCC "DAT"
FCC "BAC"
FCC "DIR"
FCC "PRT"
FCC "OUT"
*
** READ A HEX ADDRESS FROM THE LINE BUFFER
*
GETHX1 JSR >ZD21E
ZD132 JSR >NXTCH1
BCS ZD159
BSR ZD15F
BCS ZD153
PSHS B
LDB #$04
ZD13F ASL >LODOFF+1
ROL >LODOFF
DECB
BNE ZD13F
PULS B
ADDA >LODOFF+1
STA >LODOFF+1
INCB
BRA ZD132
 
ZD153 JSR >NXTCH1
BCC ZD153
RTS
 
ZD159 LDX >LODOFF
ANDCC #$FE
RTS
 
ZD15F SUBA #$47
BPL ZD172
ADDA #$06
BPL ZD16B
ADDA #$07
BPL ZD172
ZD16B ADDA #$0A
BMI ZD172
ANDCC #$FE
RTS
 
ZD172 ORCC #$01
RTS
 
INDEC1 JSR >ZD21E
ZD178 JSR >NXTCH1
BCS ZD159
CMPA #$39
BHI ZD153
ANDA #$0F
PSHS B
PSHS A
LDD >LODOFF
ASLB
ROLA
ASLB
ROLA
ASLB
ROLA
ADDD >LODOFF
ADDD >LODOFF
ADDB ,S+
ADCA #$00
STD >LODOFF
PULS B
INCB
BRA ZD178
*
** LOAD BINARY FILE
*
LOAD1 CLR >TRNFLG
ZD1A5 BSR ZD1E4
CMPA #$02
BEQ ZD1C0
CMPA #$16
BNE ZD1A5
BSR ZD1E4
STA >TRNVEC
BSR ZD1E4
STA >TRNVEC+1
LDA #$01
STA >TRNFLG
BRA ZD1A5
 
ZD1C0 BSR ZD1E4
TFR A,B
BSR ZD1E4
EXG A,B
ADDD >LODOFF
STD >ZCC3D
BSR ZD1E4
TFR A,B
TSTA
BEQ ZD1A5
ZD1D5 BSR ZD1E4
LDX >ZCC3D
STA ,X+
STX >ZCC3D
DECB
BNE ZD1D5
BRA ZD1A5
 
ZD1E4 LDX #FCB
JSR >FMS
BEQ ZD1FD
LDA $01,X
CMPA #$08
BNE ZD200
LEAS $02,S
ZD1F4 LDA #$04
STA ,X
JSR >FMS
BNE ZD20A
ZD1FD ANDCC #$FE
RTS
 
ZD200 STA >ERRTYP
CMPA #$04
BNE ZD20A
ORCC #$01
RTS
 
ZD20A BSR RPTER1
JMP >ZCDE4
*
** 'GET' - LOAD BINARY FILE
*
GETCMD LDA #$00
BSR ZD248
BCS ZD224
BSR ZD21E
INC >ZCC4C
BSR LOAD1
BRA GETCMD
 
ZD21E CLRA
CLRB
STD >LODOFF
RTS
 
ZD224 LDB >ZCC4C
LBEQ ZCDD9
JMP >WARMS
 
ZD22E LDA #$02
BSR ZD254
BSR ZD21E
JSR >LOAD1
LDB >TRNFLG
BEQ ZD240
JMP [TRNVEC]
 
ZD240 LDX #NTRMSG
LDA #$81
JMP >ZCDDE
 
ZD248 PSHS A
LDX #FCB
JSR >GETFL1
PULS A
BCS ZD26E
ZD254 LDX #FCB
JSR >SETEX1
LDX #FCB
LDA #$01
STA ,X
JSR >ZD1E4
LBCS ZD323
LDA #$FF
STA $3B,X
RTS
 
ZD26E LDA >LASTRM
CMPA #$0D
BEQ ZD27C
CMPA >EOLCHR
LBNE ZCDD9
ZD27C ORCC #$01
RTS
 
RPTER1 PSHS Y,X
LDA $01,X
STA >ERRTYP
BEQ ZD2EB
JSR >RSTIO1
LDY >ERRVEC
BNE ZD299
CMPA #$10
BEQ ZD2ED
LDY #ZD361
ZD299 LDX #FCB
TST $02,X
BEQ ZD2A9
LDA #$04
STA ,X
JSR >FMS
BNE ZD2D7
ZD2A9 LDX #ZC838
LDB #$0B
BSR ZD31E
LDX #FCB
LDA >SYSDRV
STA $03,X
LDA #$01
STA ,X
JSR >FMS
BNE ZD2D7
LDA >ERRTYP
DECA
ASRA
ASRA
INCA
CLR $20,X
STA $21,X
LDA #$15
STA ,X
JSR >FMS
BEQ ZD2F5
ZD2D7 LDX #DERMSG
JSR >PSTRG1
LDX >ZCC3F
LDA >ERRTYP
STA $01,X
CLR ,X
CLRB
JSR >OUTDC1
ZD2EB PULS PC,Y,X
 
ZD2ED LDX #DNRMSG
JSR >PSTRG1
BRA ZD2EB
 
ZD2F5 JSR >PCRLF1
LDX #FCB
LDA >ERRTYP
DECA
ANDA #$03
LDB #$3F
MUL
ADDB #$04
STB $22,X
ZD309 JSR >FMS
BNE ZD2D7
JSR >PUTCH1
CMPA #$0D
BNE ZD309
LDA #$04
STA ,X
JSR >FMS
BRA ZD2EB
ZD31E PSHS Y,X
JMP >ZD100
 
ZD323 LDX #NFDMSG NOT FOUND
JMP >ZCDE1
*
** CALL FLEX AS A SUBROUTINE
*
DOCMD1 PULS B,A
STD >ZCC43
ZD32E STS >ZCC45
CLR >ERRTYP
INC >CMDFLG
JMP >ZCDB8
ZD33B CLR >CMDFLG
LDS >ZCC45
LDB >ERRTYP
JMP [ZCC43]
*
** ADD ACCB TO IX
*
ADDBX1 ABX
RTS
 
ZD34B TST >ZCCFC
BNE ZD354
JMP [MONVEC]
 
ZD354 LDX #FCB
LDA #$1B
STA $01,X
JSR >RPTER1
JMP >WARM1
 
ZD361 FCC /ERRORS/
FCB $00,$00
FCC /SYS/
END
/f9-data.asm
0,0 → 1,36
*
** STRINGS AND MESSAGES
*
ORG $CC4E
PMTSTR FCC "+++"
FCB $04
QRYSTR FCC "???"
FCB $04
WOTMSG FCC "WHAT?"
FCB $04
NTRMSG FCC "CAN'T TRANSFER"
FCB $04
NFDMSG FCC "NOT FOUND"
FCB $04
DERMSG FCC "DISK ERROR #"
FCB $04
DNRMSG FCC "DRIVES NOT READY"
FCB $04
*
** MEMORY RESIDENT COMMANDS
*
CMDTBL FCC "GET"
FCB $00
FDB GETCMD
FCC "MON"
FCB $00
FDB ZD34B
FCB $00
*
** DECIMAL CONVERSION TABLE
*
DECTBL FDB 10000
FDB 1000
FDB 100
FDB 10
END
/flex9ide.aux
0,0 → 1,9
t m
l FLEX9IDE.S19
t h
s flex9_ide_b16_0.vhd c000 c7ff
s flex9_ide_b16_1.vhd c800 cfff
s flex9_ide_b16_2.vhd d000 d7ff
s flex9_ide_b16_3.vhd d800 dfff
q
 
/f9-dkfdc.asm
0,0 → 1,372
*
** FLEX 9 DISK DRIVERS
** FOR SINGLE/DOUBLE SIDED 5" DRIVES ONLY.
** USING FD1771.
** SIDES MAY BE TREATED AS SEPERATE DISKS.
**
** BY J.E.KENT 1 JAN 1982
*
*
** F.D. CONTROLLER
*
DRVREG EQU $E014
MOTOR EQU %10000000
SIDESL EQU %01000000
DRIVSL EQU %00000001
CMDREG EQU $E018
TRKREG EQU $E019
SECREG EQU $E01A
DATREG EQU $E01B
*
** FD1771 DISK CONTROLLER INSTRUCTIONS
*
** TYPE I INSTRUCTIONS:
*
IREST EQU $00 RESTORE (SEEK TRACK 0)
ISEEK EQU $10 SEEK TRACK
ISTEP EQU $20 STEP ONE TRACK (IN/OUT)
ISTIN EQU $40 STEP IN ONE TRACK
ISTOUT EQU $60 STEP OUT ONE TRACK
*
** BIT FIELDS FOR TYPE I INSTRUCTIONS
*
SMR6 EQU $00 6MSEC STEPPING RATE
SMR12 EQU $01 12 MSEC STEPPING RATE
SMR20 EQU $02 20 MSEC
SMR40 EQU $03 40 MSEC
*
BVERIF EQU $04 VERIFY BIT (1=ON)
BHDLD EQU $08 HEAD LOAD (1=LOAD HEAD AT BEGINING)
BUPDAT EQU $10 UPDATE TRACK REGISTER (1=TRUE)
*
** TYPE II INSTRUCTIONS
*
IREAD EQU $80 READ SECTOR
IWRITE EQU $A0 WRITE SECTOR
*
** BIT FIELD FOR TYPE II
*
BDAMFB EQU $00 $FB DATA ADDRESS MARK
BDAMFA EQU $01 $FA DATA ADDREES MARK
BDAMF9 EQU $02 $F9 DATA ADDRESS MARK
BDAMF8 EQU $03 $F8 DATA ADDRESS MARK
BEHLD EQU $04 ENABLE HLD & 10 MSEC DELAY (1=ACTIVE)
BBLEN EQU $08 BLOCK LENGTH (1=IBM FORMAT 128 - 1024 BYTES)
BMREC EQU $10 MULTIPLE RECORD (0=SINGLE, 1=MULTIPLE)
*
** TYPE III INSTRUCTIONS
*
IRDADD EQU $C4 READ ADDRESS
IRDTRK EQU $E4 READ TRACK
IWRTRK EQU $F4 WRITE TRACK
*
** BIT FIELD TYPE III (READ TRACK ONLY)
*
BSYNC EQU $01 SYNCRONIZE FLAG (0=SYNC TO AM)
*
** TYPE IV NSTRUCTION
*
IFINTR EQU $D0 FORCE INTERRUPT
*
** FORCED INTERRUPT BITS (TYPE IV INSTRUCTION)
*
FI0 EQU $01 NOT READY TO READY TRANSITION
FI1 EQU $02 READY TO NOT READY TRANSITION
FI2 EQU $04 INDEX PULSE
FI3 EQU $08 EVERY 10 MSEC
*
** DISK DRIVER PATCHES
*
ORG $DE00
*
** JUMP TABLE TO DISK DRIVERS
*
READ JMP READSC
WRITE JMP WRITSC
VERIFY JMP VERIF1
RESTOR JMP RESTR1
DRIVE JMP DRVSEL
DRVRDY JMP CHKDRV
QUICK JMP CHKDRV
COLDDR JMP INITDR
WARMDR JMP WARMD1
SEEK JMP SEEK1
*
** CURRNT DRIVE NUMBER ($DE1E)
*
CURDRV FCB $00
*
** HEAD POSITION TABLE ($DE1F)
*
TRKTBL FCB $00 DRIVE 0
FCB $00 DRIVE 1
FCB $00 DRIVE 2
FCB $00 DRIVE 3
*
** ??? ($DE23)
*
FCB 0
*
** DENSITY TABLE: ($DE24)
** HOLDS SECTORS/TRACK FOR DRIVE
** 5" SINGLE DENSITY => 10 SECTORS/TRACK
*
DNSTBL FCB 10,10,10,10 ALL MINIS
*
** DRIVE & DISK CHARACTERISTICS
*
* BITS 1,0 STEPPING RATES
* BIT 2 TRACKS/DISK (0=40 TRACK, 1=80 TRACK)
* BIT 3 TRACKS/DRIVE (0=40 TRACK, 1=80 TRACK)
*
BDVTPI EQU $08
BDKTPI EQU $04
DDCTBL EQU *
FCB BDVTPI+BDKTPI+SMR6
FCB BDVTPI+BDKTPI+SMR6
FCB SMR40
FCB SMR40
*
** DISK DRIVERS
*
* DRIVER INITIATION
*
INITDR LDX #CURDRV
LDB #5
INITD2 CLR ,X+
DECB
BNE INITD2
WARMD1 RTS
*
* READ ONE SECTOR
*
READSC BSR SEEK1
LDA #IREAD+BBLEN+BEHLD
READ2 ORCC #$10
* SEI DISABLE INTERRUPTS
STA CMDREG
LBSR DLY47
LDB #$00
RDLOOP LDA CMDREG
BITA #$02
BNE RDBYTE
BITA #$01
BNE RDLOOP
TFR A,B
BRA RDEXIT
*
RDBYTE LDA DATREG
STA ,X+
DECB
BNE RDLOOP
BSR WAIT
RDEXIT BITB #$1C
ANDCC #$EF
* CLI
RTS
*
** WAIT UNTIL CONTROLLER READY
*
WAIT LDB CMDREG
BITB #$01
BNE WAIT
RTS
*
** SEEK1 TRACK AND SECTOR
** ACCA = TRACK NUMBER
** ACCB = SECTOR NUMBER
*
SEEK1 STB SECREG SET SECTOR
CMPB #10 DOUBLE-SIDED ?
BHI SEEK2 DOUBLE SIDED, FLIP
LDB CURDRV BACK SIDE OF DISK ?
CMPB #1 DRIVE 2-3 BACK SIDE
BHI SEEK3
ANDB #$FF-SIDESL SELECT SIDE 0
BRA SEEK4
*
SEEK2 LDB CURDRV SELECT SIDE 1
SEEK3 ANDB #DRIVSL
ORB #SIDESL
SEEK4 STB DRVREG
*
CMPA TRKREG DIFFERENT TO LAST ?
BEQ FOUND
PSHS A SAVE TRACK NO. ON STACK
*
* IF 80 TRACK DRIVE, & 40 TRACK DISK, FIRST SEEK
* SHOULD NOT UPDATE TRACK REGISTER NOR VERIFY.
*
SUBA TRKREG CALC. DIFFERENCE
TFR A,B
PSHS Y
*
** GET STEPPING RATE FROM TABLE
*
LDY #DDCTBL
LDA CURDRV
ANDA #$01
LDA A,Y
PULS Y
*
** CHECK DRIVE AND DISK TYPE
*
BITA #BDVTPI DRIVE TRACK DENSITY = 48 TPI ?
BEQ SEEKVU YES, SKIP
BITA #BDKTPI DISK TRACK DENSITY = 96 TPI ?
BNE SEEKVU YES, SKIP (DRIVE & DISK MATCH)
*
** HERE IF 40TRACK DISK IN 80 TRACK DRIVE
** USE STEP INSTRUCTIONS TO PREVENT UPDATE OF TRACK REG.
*
ANDA #$03 LEAVE STEPPING RATE BITS
TSTB
BPL STEPIN
NEGB
ORA #ISTOUT
BRA STEPLP
STEPIN ORA #ISTIN
STEPLP PSHS B
BSR SEEK5
PULS B
DECB
BNE STEPLP
*
** SEEK TRACK WITH VERIFY & UPDATE
*
SEEKVU ANDA #$03 RETAIN STEPPING RATE
ORA #ISEEK+BHDLD ($18)
PULS B RESTORE DEST TRACK NO.
STB DATREG YES, SEEK1 NEW TRACK
LBSR DLY47
SEEK5 STA CMDREG
LBSR DLY47
BSR WAIT
BITB #$10 CHECK FOR SEEK1 ERROR
FOUND JMP DLY47
*
** WRITE SECTOR TO DISK
*
WRITSC BSR SEEK1
LDA #IWRITE+BBLEN+BEHLD ($AC)
WRITE2 ORCC #$10
* SEI
STA CMDREG
LBSR DLY47
LDB #$00
WRLOOP LDA CMDREG
BITA #$02
BNE WRBYTE
BITA #$01
BNE WRLOOP
TFR A,B
BRA WREXIT
*
WRBYTE LDA ,X+
STA DATREG
DECB
BNE WRLOOP
LBSR WAIT
WREXIT BITB #$5C
ANDCC #$EF
* CLI
RTS
*
** VERIFY SECTOR WRITTEN
*
VERIF1 LDA #IREAD+BBLEN+BEHLD ($8C)
VERIF2 ORCC #$10
* SEI
STA CMDREG
LBSR DLY47
LBSR WAIT
ANDCC #$EF
* CLI
BITB #$18
RTS
*
** SEEK TRACK ZERO
*
RESTR1 PSHS X
BSR DRVSEL
LDX #DDCTBL
LDA CURDRV
ANDA #1
LDA A,X
ANDA #$03
ORA #IREST+BHDLD
STA CMDREG
BSR DLY47
LBSR WAIT
BITB #$D8 CHECK FOR ERROR
PULS X,PC
*
** SELECT DRIVE
** IX -> FCB
** ACCA = NEW DRIVE NUMBER
*
* SAVE OLD TRACK NUMBER IN TABLE
* AND SET UP TRACK FOR NEW DRIVE
*
*
DRVSEL LDA 3,X
CMPA #3
BLS DRSEL1
LDB #$0F SET ERROR VALUE
* SEC
ORCC #$01
RTS
*
* SAVE TRACK POSITION OF PREVIOUS DRIVE
*
DRSEL1 BSR PNTDRV
LDB TRKREG
STB ,X
*
* SELECT NEW DRIVE
*
DRSEL3 STA CURDRV MAY BE 0 - 3
CMPA #1
BLS DRSEL4 ONE DIRECTORY ?
ANDA #DRIVSL ROUND OFF
ORA #SIDESL SELECT SIDE 1
DRSEL4 STA DRVREG
*
* RESTORE LAST TRACK POSITION FOR THIS DRIVE
*
BSR PNTDRV
LDA ,X
STA TRKREG
BSR DLY47
BRA OK
*
** CHECK IF DRIVE READY
*
CHKDRV LDA 3,X
CMPA #3
BLS OK
LDB #$80
* SEC
ORCC #$01
RTS
 
OK CLRB
* CLC
ANDCC #$FE
RTS
*
* POINT TO TRACK TABLE ENTRY FOR THIS DRIVE
*
PNTDRV LDX #TRKTBL
LDB CURDRV
ANDB #DRIVSL
ABX
RTS
*
** DELAY ROUTINE
*
DLY47 LBSR DLY19
DLY19 LBSR DLY5US
DLY5US RTS
END
 
/flex9ram.asm
0,0 → 1,13
NAM FLEX SOURCE
INCLUDE "f9-moneq.asm"
INCLUDE "f9-equ.asm"
INCLUDE "f9-spool.asm"
INCLUDE "f9-sfcb.asm"
INCLUDE "f9-init.asm"
INCLUDE "f9-var.asm"
INCLUDE "f9-data.asm"
INCLUDE "f9-cli.asm"
INCLUDE "f9-monio.asm"
INCLUDE "f9-fms.asm"
INCLUDE "f9-dkram.asm"
END COLDS
/flex9cf8.asm
0,0 → 1,13
NAM FLEX9 SOURCE
INCLUDE "f9-moneq.asm"
INCLUDE "f9-equ.asm"
INCLUDE "f9-spool.asm"
INCLUDE "f9-sfcb.asm"
INCLUDE "f9-init.asm"
INCLUDE "f9-var.asm"
INCLUDE "f9-data.asm"
INCLUDE "f9-cli.asm"
INCLUDE "f9-monio.asm"
INCLUDE "f9-fms.asm"
INCLUDE "f9-dkcf8.asm"
END COLDS
/f9-sfcb.asm
0,0 → 1,14
*
** SYSTEM FILE CONTROL BLOCK
*
ORG $C840
FCB FCB $FF
FCB $00
FCB $00
FCB $00
ZC844 FCC "STARTUP"
FCB $00
FCC "TXT"
FCB $00
END
 
/f9-moneq.asm
0,0 → 1,106
PAGE
*
***************************************************
* MEMORY MAP EQUATES *
***************************************************
MONIO EQU $E000 I/O SPACE
MONRAM EQU $DFC0 STACK SPACE
MONROM EQU $F800 START OF ROM
MONEXT EQU $F000 EXTENDED COMMANDS
*MONEXT EQU $1000 EXTENDED COMMANDS
*
***************************************************
* SYS09BUG VARIABLE SPACE
***************************************************
*
STACK EQU MONRAM+0 TOP OF INTERNAL STACK / USER VECTOR
SWI3 EQU MONRAM+2 SOFTWARE INTERRUPT VECTOR #3
SWI2 EQU MONRAM+4 SOFTWARE INTERRUPT VECTOR #2
FIRQ EQU MONRAM+6 FAST INTERRUPT VECTOR
IRQ EQU MONRAM+8 INTERRUPT VECTOR
SWI EQU MONRAM+10 SOFTWARE INTERRUPT VECTOR
SVCVO EQU MONRAM+12 SUPERVISOR CALL VECTOR ORGIN
SVCVL EQU MONRAM+14 SUPERVISOR CALL VECTOR LIMIT
LRARAM EQU MONRAM+16 LRA ADDRESSES
CPORT EQU MONRAM+32 RE-VECTORABLE CONTROL PORT
ECHO EQU MONRAM+34 ECHO FLAG
BPTBL EQU MONRAM+35 BREAKPOINT TABLE BASE ADDR
**************************************************
* VDU BYTES *
**************************************************
*
**** ALWAYS KEEP COLADX AND ROWADX TOGETHER ******
COLADX EQU MONRAM+59 CURSOR COLUMN
ROWADX EQU MONRAM+60 CURSOR ROW
**************************************************
*
NEWROW EQU MONRAM+61 NEW ROW TEMP FOR ESCAPE
ESCFLG EQU MONRAM+62 ESCAPE SEQUENCE ACTIVE
*
***************************************************
* SERIAL PORT *
***************************************************
*
ACIAS EQU MONIO+$00 CONTROL PORT
*
***************************************************
* PS/2 KEYBOARD PORT *
***************************************************
*
PS2KBD EQU MONIO+$20 PS/2 KEYBOARD PORT
*
***************************************************
* ADM3A DISPLAY DRIVER VARIABLES *
***************************************************
*
** VIDEO DISPLAY DEFINITIONS
*
VDU EQU MONIO+$30
VDUCHR EQU 0 CHARACTER REGISTER
VDUATT EQU 1 ATTRIBUTE REGISTER
VDUCOL EQU 2 CURSOR COLUMN
VDUROW EQU 3 CURSOR ROW
VDUOFF EQU 4 ROW OFFSET
*
LINLEN EQU 80 LENGTH OF A LINE
NUMLIN EQU 25 NUMBER OF LINES
*
***************************************************
* Serial PROM register
***************************************************
*
** CONFIGURATION PROM DEFINITIONS
*
PROMREG EQU MONIO+$C0
PCLKHI EQU $01 Toggle PROM Clock High
PCLKLO EQU $00 Toggle PROM Clock Low
PRSTHI EQU $02 Toggle PROM Reset High
PRSTLO EQU $00 Toggle PROM Reset Low
SYNCHI EQU $AA55 Synch Pattern High Word
SYNCLO EQU $FF00 Synch Pattern Low Word
*
*
***************************************************
* Dynamic Address Translation Registers
***************************************************
*
** DAT Table
*
IC11 EQU $FFF0 DAT RAM CHIP
*
***************************************************
* START OF ROM *
***************************************************
*
MONITV EQU MONROM+0 FDB MONITOR
NXTCMV EQU MONROM+2 FDB NEXTCMD
INCHV EQU MONROM+4 FDB INCH
INCHEV EQU MONROM+6 FDB INCHE
INCHKV EQU MONROM+8 FDB INCHEK
OUTCHV EQU MONROM+10 FDB OUTCH
PDATAV EQU MONROM+12 FDB PDATA
PCRLFV EQU MONROM+14 FDB PCRLF
PSTRGV EQU MONROM+16 FDB PSTRNG
LRAV EQU MONROM+18 FDB LRA
END
 
/f9-dkide.asm
0,0 → 1,188
*
** FLEX 9 COMPACT FLASH / IDE DISK DRIVERS
*
* FOR SYS09BUG ON THE XESS XSA-3S1000 & XST3.0
* WITH I/O MAPPED AT $XE000
* AND ROM MAPPED AT $XF000
*
* These drivers should work with either
* an IDE disk drive or a IDE CF adapter card
* It uses 16 bit transfer mode,
* as some IDE drives do not support
* the set feature command found on CF cards
* that allows for 8 bit operation
*
*
IMASK EQU $10 IRQ MASK CC
FMASK EQU $40 FIRQ MASK CC
*
CF_BASE EQU $E100
CF_DATA EQU CF_BASE+0
CF_ERROR EQU CF_BASE+2 ; read error
CF_FEATURE EQU CF_BASE+2 ; write feature
CF_SECCNT EQU CF_BASE+4
CF_SECNUM EQU CF_BASE+6
CF_CYLLO EQU CF_BASE+8
CF_CYLHI EQU CF_BASE+10
CF_HEAD EQU CF_BASE+12
CF_STATUS EQU CF_BASE+14 ; read status
CF_COMAND EQU CF_BASE+14 ; write command
CF_AUX EQU CF_BASE+30 ; Reset register
*
* Command Equates
*
CMDREAD EQU $20 ; Read Single sector
CMDWRITE EQU $30 ; Write Single sector
AUXRESET EQU $06
AUXRSTREL EQU $02
HEADLBA EQU $E0
*
* Status bit equates
*
BSY EQU $80
DRDY EQU $40
DRQ EQU $08
ERR EQU $01
ORG $DE00
*
* DISK DRIVER JUMP TABLE
*
READ JMP READSC
WRITE JMP WRITSC
VERIFY JMP BUSY
RESTOR JMP RESTR1
DRIVE JMP DRVSEL
DRVRDY JMP CHKDRV
QUICK JMP CHKDRV
COLDDR JMP INITDR
WARMDR JMP WARMD1
SEEK JMP SEEKTS
*
* RAM SPACE
*
DRVNUM FCB 0
*
*
* INITIALIZE CF CARD
*
INITDR LDD #AUXRESET
STD CF_AUX
LDD #AUXRSTREL
STD CF_AUX
LDD #HEADLBA
STD CF_HEAD
BRA WAITRDY
*
* RESTORE DISK DRIVER (SEEK TRACK 00)
*
RESTR1 BSR DRVSEL
CLRA ; Track 0
LDB #$01 ; Sector 1
*
* Seek track and sector
* A holds track number (0 - ??)
* B holds sector number (1 - ??)
* Sector numbers starts from 1
* subtract 1 to start from sector 0 on CF
*
SEEKTS DECB
PSHS A
CLRA
STD CF_SECNUM
LDB ,S
STD CF_CYLLO
LDB DRVNUM
STD CF_CYLHI
LDB #$01
STD CF_SECCNT
PULS A
CLRB
WARMD1 RTS
*
* READ SECTORS FROM CF
*
*
READSC BSR SEEKTS
LDD #CMDREAD ; IDE READ MULTIPLE
STD CF_COMAND
BSR WAITRDY
*
* READ LOOP
*
PSHS Y
LDY #256
RDLP1 BSR WAITDRQ
LDD CF_DATA
STB ,X+
LEAY -1,Y
BNE RDLP1
PULS Y
*
BSR WAITRDY
CLRB
RTS
*
* WRITE SECTOR TO CF
*
WRITSC BSR SEEKTS ; SEEK TRACK & SECTOR
LDD #CMDWRITE; IDE WRITE MULTIPLE
STD CF_COMAND
BSR WAITRDY
*
* WRITE LOOP
*
PSHS Y
LDY #256
CLRA
WRTLP1 BSR WAITDRQ
LDB ,X+
STD CF_DATA
LEAY -1,Y
BNE WRTLP1
PULS Y
*
BSR WAITRDY
CLRB
RTS
*
* CHECK FOR BUSY
* Doubles as VERIFY
*
BUSY CLRB Never busy
RTS
*
* DRIVE SELECT DISK DRIVER
*
DRVSEL LDA 3,X GET DRIVE # FROM FCB
CMPA #3
BLS DRVS2 IF > 3, SET IT TO 0
CLRA
DRVS2 STA DRVNUM
CLRB ; SET Z, CLEAR C
RTS
*
* CHECK DRIVE READY DISK DRIVER
*
CHKDRV LDA 3,X
CLRB ; CLEAR C, SET Z
RTS
*
* WAIT UNTIL READY
*
WAITRDY LDD CF_STATUS
BITB #BSY
BNE WAITRDY
LDD CF_STATUS
BITB #DRDY
BEQ WAITRDY
RTS
*
* WAIT FOR DATA REQUEST
*
WAITDRQ LDD CF_STATUS
BITB #DRQ
BEQ WAITDRQ
RTS
*
END
 
/readme.txt
0,0 → 1,37
Instructions for Setting up FLEX9
 
XSA-3S1000 + XST3.0 + IDE harddrive
 
1. Build the bitstream by going to the rtl/System09_Xess_-3S1000 and typing
'make bit' in a cygwin shell.
 
2. Connect a serial cable from the XST3.0 board to the serial port on the PC.
 
3. Connect an IDE hard disk to the IDE connector on the XST3 board. It should be
at least 128 MB for 4 logical Flex disk drives.
 
4. Connect a PS/2 keyboard and VGA monitor to the XSA-3S1000 board.
 
5. Open Hyperterm and configure the port for 57600 8-N-1.
 
6. Download the bitstream to the FPGA using 'make xsload'. If you have the USB
download cable, you can build and download the bitstream by typing 'make usbxsload'.
 
7. Use the 'UF' command at the S-BUG prompt to format an empty drive.
 
8. Use the 'UX' command at the S-BUG prompt to download the FLEX9 disk image
using the XModem protocol in Hyperterm. The disk image file is FLEXESS.dsk.
Downloading takes about 11 minutes at 57.6k baud.
 
9. Flex9 is embedded in the bitstream to load in a block RAM on the FPGA. Once
the disk image is downloaded, start FLEX by setting the program counter to $CD00
(using ^P CD00 at the S-BUG prompt), then type 'G' at the S-BUG prompt. If things
are working correctly Flex should request the date then give the "+++" prompt.
 
10. Test the disk drive by typing 'DIR,0' at the flex prompt (no single quotes).
It should list the files on drive 0.
 
11. The UX download program writes a bootstrap loader on the disk after the disk
image is downloaded. The Flex image must be linked to to the boot strap using
the "LINK 0.FLEX9IDE.SYS" command at the FLEX prompt. Then, next time System09
is powered on, simply issue the 'D' command at the S-BUG prompt to boot FLEX.
/f9-monio.asm
0,0 → 1,65
*
** TERMINAL AND PRINTER DRIVERS
** SYS09BUG - Spartan 3 Starter Board
*
** FLEX DRIVER MEMORY MAP:
** C700 - C83F PRINTER SPOOLER
** CCC0 - CCF7 PRINTER DRIVERS
** D370 - D3FF CONSOLE DRIVERS
** DE00 - DFAF DISK DRIVERS
*
*
** INTERRUPT VECTORS
*
IRQVEC EQU MONRAM+$08
SWIVEC EQU MONRAM+$02 SWI3 VECTOR
*
** PRINTER DRIVERS
*
ORG $CCC0
PINIT JMP DUMRTS INITIATE PRINTER
ORG $CCD8
PCHK JMP DUMRTS CHECK IF PRINTER READY
ORG $CCE4
POUT JMP DUMRTS OUTPUT CHR. TO PRINTER
ORG $CCF8
ZCCF8 FCB $01,$00,$00,$00
ZCCFC FCB $00,$00,$00,$00
*
** CONSOLE DRIVER PATCHES:
*
ORG $D370
IHND EQU * INTERRUPT HANDLER
TMON EQU * TIMER ON
TMOFF EQU * TIMER OFF
TMINT EQU * TIMER INITIALIZATION
DUMRTS EQU *
RTS
*
** SBUG MONITOR I/O CALLS
*
TERINZ JMP DUMRTS INITIATE ACIA
INCHNE JMP [MONROM+$04] INPUT WITHOUT ECHO
MONITR JMP [MONROM+$00]
INCHEK JMP [MONROM+$08] CHECK FOR TERMINAL ENTRY
OUTEEE JMP [MONROM+$0A] OUPUT CHARACTER
INEEE JMP [MONROM+$06] INPUT WITH ECHO
 
*
** AUTO BLOCK FDBS
*
ORG $D3E5
ZD3E5 FDB INCHNE INPUT - NO ECHO
IHNDVC FDB IHND IRQ INTERRUPT HANDLER
SWIVVC FDB SWIVEC SWI3 VECTOR LOCATION
IRQVVC FDB IRQVEC IRQ VECTOR LOCATION
TOFVEC FDB TMOFF TIMER OFF ROUTINE
TONVEC FDB TMON TIMER ON ROUTINE
TINVEC FDB TMINT TIMER INITIALIZE ROUTINE
MONVEC FDB MONITR MONITOR RETURN ADDRESS
TERVEC FDB TERINZ TERMINAL INITIATION
STAVEC FDB INCHEK CHECK TERMINAL STATUS
OUTVEC FDB OUTEEE TERMINAL CHAR OUTPUT
INVEC FDB INEEE TERMINAL INPUT CHARACTER
ZD3FD JMP ZCA00
END
/Makefile
0,0 → 1,89
#-----------------------------------------------------------------
# File: Makefile
# Author: David Burnette
# Date: April 7, 2008
#
# Description:
# This makefile generates a VHDL file from assembler source.
# A translate rule in mktargets.mk handles compiling the .asm
# into a S19 record file (.S19) and then running s19tovhd to
# generate a VHDL file with SPARTAN3 block rams with INIT generics
# containing the binary data.
#
# This particular makefile handles generating FLEX9 code.
#
# Usage:
# This make file is called recursively by the board-specific
# makefiles in the 'rtl' directory. The targets generated by
# this makefile are:
#
# make - makes all variants
# make all - makes all variants
# make flex9ide.vhd - Flex for and IDE drive mapped at $E100 with
# 16 bit transfers (Used on XSA-3S1000/XST-3.0)
# make flex9cf8.vhd - Flex for Compact Flash mapped at $E040
# with 8 bit transfers (Used on B5-X300)
# make flex9ram.vhd - Flex with RAM disk drivers (Untested)
# (Used on Spartan 3 Starter board)
# make flex9ads.vhd -
#
# Target Descriptions:
# The first file listed is the source file passed to assembler.
# Remaining files are the dependencies. The option variables
# ADDRS, ENTITY and TOP_RAM are used by the s19tovhd utility
# to generate the VHDL file.
#
# Dependencies:
# This makefile depends on def_rules.mk and the top-level
# ram model file flex_ram_vhd.
#
# Revision History:
# dgb 2008-04-07 Original version
#
#-----------------------------------------------------------------
 
ifeq "$(MKFRAGS)" ""
MKFRAGS := ../../mkfiles
endif
 
include $(MKFRAGS)/def_rules.mk
 
BASE_FLEX_FILES := \
f9-moneq.asm \
f9-equ.asm \
f9-spool.asm \
f9-sfcb.asm \
f9-init.asm \
f9-var.asm \
f9-data.asm \
f9-cli.asm \
f9-monio.asm \
f9-fms.asm
 
all: flex9ide.vhd flex9cf8.vhd flex9ram.vhd flex9ads.vhd
 
flex9ide.vhd: flex9ide.asm $(BASE_FLEX_FILES) f9-dkide.asm
flex9ide.vhd: ADDRS=C000 C800 D000 D800
flex9ide.vhd: ENTITY=FLEX9
flex9ide.vhd: TOP_RAM=flex_ram_vhd
 
flex9cf8.vhd: flex9cf8.asm $(BASE_FLEX_FILES) f9-dkcf8.asm
flex9cf8.vhd: ADDRS=C000 C800 D000 D800
flex9cf8.vhd: ENTITY=FLEX9
flex9cf8.vhd: TOP_RAM=flex_ram_vhd
 
flex9ram.vhd: flex9ram.asm $(BASE_FLEX_FILES) f9-dkram.asm
flex9ram.vhd: ADDRS=C000 C800 D000 D800
flex9ram.vhd: ENTITY=FLEX9
flex9ram.vhd: TOP_RAM=flex_ram_vhd
 
flex9ads.vhd: flex9ads.asm $(BASE_FLEX_FILES) f9-dkfdc.asm
flex9ads.vhd: ADDRS=C000 C800 D000 D800
flex9ads.vhd: ENTITY=FLEX9
flex9ads.vhd: TOP_RAM=flex_ram_vhd
 
.PHONY: clean
clean:
-$(RM) *.S19
-$(RM) *.lst
-$(RM) *.vhd

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.