| ; error codes |
| EAPI_ERR_RAM = 1 |
| EAPI_ERR_ROML = 2 |
| EAPI_ERR_ROMH = 3 |
| EAPI_ERR_ROML_PROTECTED = 4 |
| EAPI_ERR_ROMH_PROTECTED = 5 |
|
|
| ; I/O address used to select the bank |
| EASYFLASH_IO_BANK = $de00 |
|
|
| ; I/O address used to read and to select the slot |
| EASYFLASH_IO_SLOT = $de01 |
|
|
| ; I/O address for enabling memory configuration, /GAME and /EXROM states |
| EASYFLASH_IO_CONTROL = $de02 |
|
|
| ; I/O address for enabling writes to ultimate ram |
| EASYFLASH_IO_WRITEKEY = $de09 |
|
|
| ; Bit for Expansion Port /GAME line (1 = low) |
| EASYFLASH_IO_BIT_GAME = $01 |
|
|
| ; Bit for Expansion Port /EXROM line (1 = low) |
| EASYFLASH_IO_BIT_EXROM = $02 |
|
|
| ; Bit for memory control (1 = enabled) |
| EASYFLASH_IO_BIT_MEMCTRL = $04 |
|
|
| EASYFLASH_IO_BIT_NO_VIC = $08 |
|
|
| ; Bit for status LED (1 = on) |
| EASYFLASH_IO_BIT_LED = $80 |
|
|
| EASYFLASH_IO_FLASH_SETUP = EASYFLASH_IO_BIT_MEMCTRL | EASYFLASH_IO_BIT_GAME | EASYFLASH_IO_BIT_NO_VIC | EASYFLASH_IO_BIT_LED |
| EASYFLASH_IO_16K_SETUP = EASYFLASH_IO_BIT_MEMCTRL | EASYFLASH_IO_BIT_GAME | EASYFLASH_IO_BIT_EXROM |
|
|
|
|
| UCI_CONTROL = $de1c |
| UCI_COMMAND = $de1d |
| UCI_STATUS = $de1f |
|
|
| EAPI_RAM_CODE = $df80 |
| EAPI_RAM_SIZE = 124 |
| EAPI_ZP_INIT_CODE_BASE = $4b |
| ZP_TEMP = $fb |
|
|
| * = $c000 |
| EAPICodeBase |
| .byte $65, $61, $70, $69 ; signature "EAPI" |
|
|
| .text "1541 U2(+) V0.6" |
| .byte 0 ; 16 bytes, must be 0-terminated |
|
|
| ; ============================================================================= |
| ; |
| ; EAPIInit: User API: To be called with JSR <load_address> + 20 |
| ; |
| ; Read Manufacturer ID and Device ID from the flash chip(s) and check if this |
| ; chip is supported by this driver. Prepare our private RAM for the other |
| ; functions of the driver. |
| ; When this function returns, EasyFlash will be configured to bank in the ROM |
| ; area at $8000..$bfff. |
| ; |
| ; This function calls SEI, it restores all Flags except C before it returns. |
| ; Do not call it with D-flag set. $01 must enable both ROM areas. |
| ; |
| ; parameters |
| ; - |
| ; return |
| ; C set: Flash chip not supported by this driver |
| ; clear: Flash chip supported by this driver |
| ; If C is clear |
| ; A Device ID |
| ; X Manufacturer ID |
| ; Y Number of physical banks (>= 64) or |
| ; number of slots (< 64) with 64 banks each |
| ; If C is set |
| ; A Error reason |
| ; changes |
| ; all registers are changed |
| ; |
| ; ============================================================================= |
| EAPIInit |
| php |
| sei |
| ; backup ZP space |
| lda EAPI_ZP_INIT_CODE_BASE |
| pha |
| lda EAPI_ZP_INIT_CODE_BASE + 1 |
| pha |
|
|
| ; find out our memory address |
| lda #$60 ; rts |
| sta EAPI_ZP_INIT_CODE_BASE |
| jsr EAPI_ZP_INIT_CODE_BASE |
| initCodeBase = * - 1 |
| tsx |
| lda $100, x |
| sta EAPI_ZP_INIT_CODE_BASE + 1 |
| dex |
| lda $100, x |
| sta EAPI_ZP_INIT_CODE_BASE |
| clc |
| bcc initContinue |
|
|
| RAMCode |
| ; This code will be copied to EasyFlash RAM at EAPI_RAM_CODE |
| .logical EAPI_RAM_CODE |
| RAMContentBegin |
| ; ============================================================================= |
| ; JUMP TABLE (will be updated to be correct) |
| ; ============================================================================= |
| jmpTable |
| jmp EAPIWriteFlash - initCodeBase ; 0 |
| jmp EAPIEraseSector - initCodeBase ; 3 |
| jmp EAPISetBank - initCodeBase ; 6 |
| jmp EAPIGetBank - initCodeBase ; 9 |
| jmp EAPISetPtr - initCodeBase ; 12 |
| jmp EAPISetLen - initCodeBase ; 15 |
| jmp EAPIReadFlashInc - initCodeBase ; 18 |
| jmp EAPIWriteFlashInc - initCodeBase ; 21 |
| jmp EAPISetSlot - initCodeBase ; 24 |
| jmp EAPIGetSlot - initCodeBase ; 27 |
|
|
| ; Some local functions, those that do NOT reside in RAM already |
| jmp rwIncAddr - initCodeBase ; 30 |
| jmp rwDecLen - initCodeBase ; 33 |
| jmp ultimateWait4idle - initCodeBase ; 36 |
| jmp ultimateWait4data - initCodeBase ; 39 |
| jmpTableEnd |
|
|
| JT_EAPIWriteFlash = jmpTable + 0 |
| JT_rwIncAddr = jmpTable + 30 |
| JT_rwDecLen = jmpTable + 33 |
| JT_ultimateWait4idle = jmpTable + 36 |
| JT_ultimateWait4data = jmpTable + 39 |
|
|
| ; ============================================================================= |
| ; |
| ; Read a byte from the inc-address |
| ; |
| ; ============================================================================= |
| readByteRamFunc |
| EAPI_RD_ADDR_LO = * + 1 |
| EAPI_RD_ADDR_HI = * + 2 |
| lda $ffff |
| rts |
|
|
| ; ============================================================================= |
| ; |
| ; Write a byte to the inc-address |
| ; |
| ; ============================================================================= |
| writeByteRamFunc |
| pha |
| lda #EASYFLASH_IO_FLASH_SETUP |
| sta EASYFLASH_IO_CONTROL |
| lda #$65 |
| sta EASYFLASH_IO_WRITEKEY |
| pla |
|
|
| EAPI_WR_ADDR_LO = * + 1 |
| EAPI_WR_ADDR_HI = * + 2 |
| sta $ffff |
| EAPI_CMP_ADDR_LO = * + 1 |
| EAPI_CMP_ADDR_HI = * + 2 |
| cmp $ffff |
| php |
| pha |
| lda #EASYFLASH_IO_16K_SETUP |
| sta EASYFLASH_IO_CONTROL |
| pla |
| plp |
| rts |
|
|
| ; ============================================================================= |
| ; |
| ; Internal function |
| ; |
| ; Fill a page with FF (to be used by erase sector) |
| ; |
| ; ============================================================================= |
| fillPageRamFunc |
| lda #EASYFLASH_IO_FLASH_SETUP |
| sta EASYFLASH_IO_CONTROL |
| lda #$65 |
| sta EASYFLASH_IO_WRITEKEY |
| lda #$ff |
| - sta (ZP_TEMP),y |
| iny |
| bne - |
| lda #EASYFLASH_IO_16K_SETUP |
| sta EASYFLASH_IO_CONTROL |
| rts |
|
|
| ; ============================================================================= |
| ; Variables |
| ; ============================================================================= |
|
|
| EAPI_TMP_VAL1 .byte 0 ; To store A |
| EAPI_TMP_VAL2 .byte 0 ; To store X |
| EAPI_TMP_VAL3 .byte 0 ; To store Y |
| EAPI_BANK .byte 0 ; Temporary bank value for erase sector |
| EAPI_ERASE_BASE .byte 0 ; Temporary high byte of address for erase sector |
| EAPI_SHADOW_BANK .byte 0 ; copy of current bank number set by the user |
| EAPI_INC_TYPE .byte 0 ; type used for EAPIReadFlashInc/EAPIWriteFlashInc |
| EAPI_INC_ADDR_LO .byte 0 ; Memory address for auto increment |
| EAPI_INC_ADDR_HI .byte 0 ; |
| EAPI_LENGTH_LO .byte 0 ; Length for read with increment |
| EAPI_LENGTH_MED .byte 0 |
| EAPI_LENGTH_HI .byte 0 |
| ; ============================================================================= |
|
|
| RAMContentEnd |
| .here |
| RAMCodeEnd |
|
|
| .if RAMContentEnd - RAMContentBegin > EAPI_RAM_SIZE |
| .error "Code too large" |
| .fi |
|
|
| .if * - initCodeBase > 256 |
| .error "RAMCode not addressable trough (initCodeBase),y" |
| .fi |
|
|
| initContinue |
| ; *** copy some code to EasyFlash private RAM *** |
| ; length of data to be copied |
| ldx #RAMCodeEnd - RAMCode - 1 |
| ; offset behind initCodeBase of last byte to be copied |
| ldy #RAMCodeEnd - initCodeBase - 1 |
| cidCopyCode |
| lda (EAPI_ZP_INIT_CODE_BASE),y |
| sta EAPI_RAM_CODE, x |
| cmp EAPI_RAM_CODE, x ; check if there's really RAM at this address |
| bne ciRamError |
| dey |
| dex |
| bpl cidCopyCode |
| |
| ; *** calculate jump table *** |
| ldx #0 |
| cidFillJMP |
| inx |
| clc |
| lda jmpTable, x |
| adc EAPI_ZP_INIT_CODE_BASE |
| sta jmpTable, x |
| inx |
| lda jmpTable, x |
| adc EAPI_ZP_INIT_CODE_BASE + 1 |
| sta jmpTable, x |
| inx |
| cpx #jmpTableEnd - jmpTable |
| bne cidFillJMP |
| clc |
| bcc ciNoRamError |
| ciRamError |
| lda #EAPI_ERR_RAM |
| sta EAPI_TMP_VAL1 |
| sec ; error |
| |
| ciNoRamError |
| ; restore the caller's ZP state |
| pla |
| sta EAPI_ZP_INIT_CODE_BASE + 1 |
| pla |
| sta EAPI_ZP_INIT_CODE_BASE |
|
|
| bcs returnOnly ; branch on error from above |
| ; everything okay |
| ; clc |
| resetAndReturn: ; C indicates error |
| lda #0 ; Protection test has changed the bank |
| sta EASYFLASH_IO_BANK ; restore it for compatibility to old versions |
| lda #$87 |
| sta EASYFLASH_IO_CONTROL |
|
|
| returnOnly: ; C indicates error |
| lda EAPI_TMP_VAL1 ; device or error code in A |
| bcs returnCSet |
| ldx #41 ; manufacturer in X |
| ldy #64 ; number of banks in Y |
|
|
| plp |
| clc ; do this after plp :) |
| rts |
| returnCSet |
| plp |
| sec ; do this after plp :) |
| rts |
|
|
| ; ============================================================================= |
| ; |
| ; EAPIWriteFlash: User API: To be called with JSR jmpTable + 0 = $df80 |
| ; |
| ; Write a byte to the given address. The address must be as seen in Ultimax |
| ; mode, i.e. do not use the base addresses $8000 or $a000 but $8000 or $e000. |
| ; |
| ; When writing to flash memory only bits containing a '1' can be changed to |
| ; contain a '0'. Trying to change memory bits from '0' to '1' will result in |
| ; an error. You must erase a memory block to get '1' bits. |
| ; |
| ; This function uses SEI, it restores all flags except C before it returns. |
| ; Do not call it with D-flag set. $01 must enable both ROM areas. |
| ; It can only be used after having called EAPIInit. |
| ; |
| ; parameters |
| ; A value |
| ; XY address (X = low), $8xxx/$9xxx or $Exxx/$Fxxx |
| ; |
| ; return |
| ; C set: Error |
| ; clear: Okay |
| ; changes |
| ; Z,N <- value |
| ; |
| ; ============================================================================= |
| EAPIWriteFlash |
| php |
| sei |
| |
| stx EAPI_WR_ADDR_LO |
| sty EAPI_WR_ADDR_HI |
| stx EAPI_CMP_ADDR_LO |
| sty EAPI_CMP_ADDR_HI |
| jsr writeByteRamFunc |
| bne writeError |
|
|
| writeOk |
| plp |
| cmp #0 ; to fix Z,N flags according to specification |
| clc |
| rts |
| writeError |
| plp |
| cmp #0 ; to fix Z,N flags according to specification |
| sec |
| rts |
|
|
| ; ============================================================================= |
| ; |
| ; EAPIEraseSector: User API: To be called with JSR jmpTable + 3 = $df83 |
| ; |
| ; Erase the sector at the given address. The bank number currently set and the |
| ; address together must point to the first byte of a 64 kByte sector. |
| ; |
| ; When erasing a sector, all bits of the 64 KiB area will be set to '1'. |
| ; This means that 8 banks with 8 KiB each will be erased, all of them either |
| ; in the LOROM chip when $8000 is used or in the HIROM chip when $e000 is |
| ; used. |
| ; |
| ; This function uses SEI, it restores all flags except C before it returns. |
| ; Do not call it with D-flag set. $01 must enable the affected ROM area. |
| ; It can only be used after having called EAPIInit. |
| ; |
| ; parameters |
| ; A bank |
| ; Y base address (high byte), $80 for LOROM, $a0 or $e0 for HIROM |
| ; |
| ; return |
| ; C set: Error |
| ; clear: Okay |
| ; |
| ; change |
| ; Z,N <- bank |
| ; |
| ; ============================================================================= |
| EAPIEraseSector |
| php |
| |
| sei |
| sta EAPI_TMP_VAL1 |
| stx EAPI_TMP_VAL2 |
| sty EAPI_TMP_VAL3 |
| |
| sty EAPI_ERASE_BASE |
| sta EAPI_BANK |
| |
| cpy #$80 |
| beq ++ |
| cpy #$a0 |
| beq ++ |
| cpy #$e0 |
| beq + |
| |
| _erase_param_error |
| cmp #0 ; fix flags according to specification |
| sec |
| rts |
| |
| ; fix to use the ultimax address |
| + lda EAPI_ERASE_BASE |
| ora #$40 |
| sta EAPI_ERASE_BASE |
| |
| + lda UCI_COMMAND |
| cmp #$C9 ; Test for UCI |
| bne EAPIEraseSectorClassic |
| |
| EAPIEraseSectorUCI |
| lda #$04 ; oder $0C ? |
| sta UCI_CONTROL |
| jsr JT_ultimateWait4idle |
| |
| lda #$04 |
| sta UCI_COMMAND |
| lda #$20 |
| sta UCI_COMMAND |
| lda #$00 |
| sta UCI_COMMAND |
| |
| lda EAPI_BANK |
| sta UCI_COMMAND |
| lda EAPI_ERASE_BASE |
| sta UCI_COMMAND |
| |
| lda #$01 |
| sta UCI_CONTROL |
| |
| jsr JT_ultimateWait4data |
| ; jsr JT_ultimateGetstatus ; Implicit fallthrough of previous |
| lda #$02 |
| sta UCI_CONTROL |
| jsr JT_ultimateWait4idle |
| ; Regardless of error, the UCI is now back in idle state |
| |
| cpx #$30 |
| bne EAPIEraseSectorClassic |
| cpy #$30 |
| beq erasedone |
| |
| EAPIEraseSectorClassic |
| ; banks should always go in multiples of 8, since an erase sector is 64K in size |
| lda EAPI_BANK |
| and #$F8 |
| sta EAPI_BANK |
| sta EASYFLASH_IO_BANK |
| |
| ; Create space on zeropage |
| lda ZP_TEMP |
| pha |
| lda ZP_TEMP+1 |
| pha |
| |
| ; Now, write FF to 8 banks of 8K, each bank consisting of $20 pages of 256 bytes |
| ldx #8 |
| erase1: |
| txa |
| pha |
| |
| ;; Clear 8K of memory |
| lda #0 |
| sta ZP_TEMP |
| lda EAPI_ERASE_BASE |
| sta ZP_TEMP+1 |
| |
| ldx #$20 |
| ldy #0 |
| - jsr fillPageRamFunc |
| inc ZP_TEMP+1 |
| dex |
| bne - |
| |
| ; increment bank |
| inc EAPI_BANK |
| lda EAPI_BANK |
| sta EASYFLASH_IO_BANK |
| pla |
| tax |
| dex |
| bne erase1 |
| |
| ; Restore zero page |
| pla |
| sta ZP_TEMP+1 |
| pla |
| sta ZP_TEMP |
|
|
| erasedone: |
| lda EAPI_SHADOW_BANK |
| sta EASYFLASH_IO_BANK |
| plp |
| clc |
| ldy EAPI_TMP_VAL3 |
| ldx EAPI_TMP_VAL2 |
| lda EAPI_TMP_VAL1 |
| rts |
|
|
| ; ============================================================================= |
| ; |
| ; EAPISetBank: User API: To be called with JSR jmpTable + 6 = $df86 |
| ; |
| ; Set the bank. This will take effect immediately for cartridge read access |
| ; and will be used for the next flash write or read command. |
| ; |
| ; This function can only be used after having called EAPIInit. |
| ; |
| ; parameters |
| ; A bank |
| ; |
| ; return |
| ; - |
| ; |
| ; changes |
| ; - |
| ; |
| ; ============================================================================= |
| EAPISetBank |
| sta EAPI_SHADOW_BANK |
| sta EASYFLASH_IO_BANK |
| rts |
|
|
| ; ============================================================================= |
| ; |
| ; EAPIGetBank: User API: To be called with JSR jmpTable + 9 = $df89 |
| ; |
| ; Get the selected bank which has been set with EAPISetBank. |
| ; Note that the current bank number can not be read back using the hardware |
| ; register $de00 directly, this function uses a mirror of that register in RAM. |
| ; |
| ; This function can only be used after having called EAPIInit. |
| ; |
| ; parameters |
| ; - |
| ; |
| ; return |
| ; A bank |
| ; |
| ; changes |
| ; Z,N <- bank |
| ; |
| ; ============================================================================= |
| EAPIGetBank |
| lda EAPI_SHADOW_BANK |
| rts |
|
|
| ; ============================================================================= |
| ; |
| ; EAPISetPtr: User API: To be called with JSR jmpTable + 12 = $df8c |
| ; |
| ; Set the pointer for EAPIReadFlashInc/EAPIWriteFlashInc. |
| ; |
| ; This function can only be used after having called EAPIInit. |
| ; |
| ; parameters |
| ; A bank mode, where to continue at the end of a bank |
| ; $D0: 00:0:1FFF=>00:1:0000, 00:1:1FFF=>01:0:1FFF (lhlh...) |
| ; $B0: 00:0:1FFF=>01:0:0000 (llll...) |
| ; $D4: 00:1:1FFF=>01:1:0000 (hhhh...) |
| ; XY address (X = low) address must be in range $8000-$bfff |
| ; |
| ; return |
| ; - |
| ; |
| ; changes |
| ; - |
| ; |
| ; ============================================================================= |
| EAPISetPtr |
| sta EAPI_INC_TYPE |
| stx EAPI_INC_ADDR_LO |
| sty EAPI_INC_ADDR_HI |
| rts |
|
|
| ; ============================================================================= |
| ; |
| ; EAPISetLen: User API: To be called with JSR jmpTable + 15 = $df8f |
| ; |
| ; Set the number of bytes to be read with EAPIReadFlashInc. |
| ; |
| ; This function can only be used after having called EAPIInit. |
| ; |
| ; parameters |
| ; XYA length, 24 bits (X = low, Y = med, A = high) |
| ; |
| ; return |
| ; - |
| ; |
| ; changes |
| ; - |
| ; |
| ; ============================================================================= |
| EAPISetLen |
| stx EAPI_LENGTH_LO |
| sty EAPI_LENGTH_MED |
| sta EAPI_LENGTH_HI |
| rts |
|
|
| ; ============================================================================= |
| ; |
| ; EAPIReadFlashInc: User API: To be called with JSR jmpTable + 18 = $df92 |
| ; |
| ; Read a byte from the current pointer from EasyFlash flash memory. |
| ; Increment the pointer according to the current bank wrap strategy. |
| ; Pointer and wrap strategy have been set by a call to EAPISetPtr. |
| ; |
| ; The number of bytes to be read may be set by calling EAPISetLen. |
| ; EOF will be set if the length is zero, otherwise it will be decremented. |
| ; Even when EOF is delivered a new byte has been read and the pointer |
| ; incremented. This means the use of EAPISetLen is optional. |
| ; |
| ; This function can only be used after having called EAPIInit. |
| ; |
| ; parameters |
| ; - |
| ; |
| ; return |
| ; A value |
| ; C set if EOF |
| ; |
| ; changes |
| ; Z,N <- value |
| ; |
| ; ============================================================================= |
| EAPIReadFlashInc |
| ; now we have to activate the right bank |
| lda EAPI_SHADOW_BANK |
| sta EASYFLASH_IO_BANK |
|
|
| lda EAPI_INC_ADDR_LO |
| sta EAPI_RD_ADDR_LO |
| lda EAPI_INC_ADDR_HI |
| sta EAPI_RD_ADDR_HI |
|
|
| ; call the read-routine |
| jsr readByteRamFunc |
|
|
| ; remember the result & x/y registers |
| sta EAPI_TMP_VAL1 |
| stx EAPI_TMP_VAL2 |
| sty EAPI_TMP_VAL3 |
|
|
| jsr JT_rwIncAddr |
| jsr JT_rwDecLen ; set C accordingly |
| |
| ldy EAPI_TMP_VAL3 |
| ldx EAPI_TMP_VAL2 |
| lda EAPI_TMP_VAL1 |
| rts |
| |
| ; ============================================================================= |
| ; |
| ; EAPIWriteFlashInc: User API: To be called with JSR jmpTable + 21 = $df95 |
| ; |
| ; Write a byte to the current pointer to EasyFlash flash memory. |
| ; Increment the pointer according to the current bank wrap strategy. |
| ; Pointer and wrap strategy have been set by a call to EAPISetPtr. |
| ; |
| ; In case of an error the position is not inc'ed. |
| ; |
| ; |
| ; This function can only be used after having called EAPIInit. |
| ; |
| ; parameters |
| ; A value |
| ; |
| ; return |
| ; C set: Error |
| ; clear: Okay |
| ; changes |
| ; Z,N <- value |
| ; |
| ; ============================================================================= |
| EAPIWriteFlashInc |
| sta EAPI_TMP_VAL1 |
| stx EAPI_TMP_VAL2 |
| sty EAPI_TMP_VAL3 |
| |
| ; activate the right bank |
| lda EAPI_SHADOW_BANK |
| sta EASYFLASH_IO_BANK |
| |
| ; load address to store to (Fix A000-BFFF => E000-FFFF) |
| ldx EAPI_INC_ADDR_LO |
| lda EAPI_INC_ADDR_HI |
| cmp #$a0 |
| bcc + |
| ora #$40 ; $a0 => $e0 |
| + tay |
| lda EAPI_TMP_VAL1 |
| |
| ; write to flash |
| jsr JT_EAPIWriteFlash |
| bcs writeInc_noIncrement |
| |
| ; We know that the carry was clear here |
| jsr JT_rwIncAddr |
| clc ; restore carry |
| |
| writeInc_noIncrement |
| ldy EAPI_TMP_VAL3 |
| ldx EAPI_TMP_VAL2 |
| lda EAPI_TMP_VAL1 |
| rts |
| |
| ; ============================================================================= |
| ; |
| ; Unimplemented Functions |
| ; |
| ; ============================================================================= |
| EAPIGetSlot |
| EAPISetSlot |
| rts |
| |
| ; ============================================================================= |
| ; |
| ; Internal function |
| ; |
| ; Increment R/W address, according to bank wrap strategy |
| ; |
| ; $D0: 00:0:1FFF=>00:1:0000, 00:1:1FFF=>01:0:1FFF (lhlh...) |
| ; $B0: 00:0:1FFF=>01:0:0000 (llll...) |
| ; $D4: 00:1:1FFF=>01:1:0000 (hhhh...) |
| ; |
| ; ============================================================================= |
| rwIncAddr |
| ; inc to next position |
| inc EAPI_INC_ADDR_LO |
| bne + |
| ; inc page |
| inc EAPI_INC_ADDR_HI |
| lda EAPI_INC_TYPE |
| and #$e0 |
| cmp EAPI_INC_ADDR_HI |
| bne + |
| ; inc bank |
| lda EAPI_INC_TYPE |
| asl |
| asl |
| asl |
| sta EAPI_INC_ADDR_HI |
| inc EAPI_SHADOW_BANK |
| + rts |
| |
| ; ============================================================================= |
| ; |
| ; Internal function |
| ; |
| ; Decrement Length, and set Carry if end has been reached |
| ; |
| ; ============================================================================= |
| rwDecLen |
| ; decrement length |
| lda EAPI_LENGTH_LO |
| bne readInc_nomed |
| lda EAPI_LENGTH_MED |
| bne readInc_nohi |
| lda EAPI_LENGTH_HI |
| beq readInc_eof |
| dec EAPI_LENGTH_HI |
| readInc_nohi |
| dec EAPI_LENGTH_MED |
| readInc_nomed |
| dec EAPI_LENGTH_LO |
| clc ; no EOF |
| rts |
| readInc_eof |
| sec ; EOF |
| rts |
| |
| ; ============================================================================= |
| ; |
| ; Internal functions for UCI handshaking |
| ; |
| ; ============================================================================= |
| ultimateWait4idle |
| lda UCI_CONTROL |
| and #$35 |
| bne ultimateWait4idle |
| rts |
| |
| ultimateWait4data |
| lda UCI_CONTROL |
| and #$20 |
| beq ultimateWait4data |
| ; rts |
| |
| ;ultimateGetstatus |
| |
| ldx #$39 |
| ldy #$39 |
| lda UCI_CONTROL |
| and #$40 |
| beq + |
| ldx UCI_STATUS |
| |
| lda UCI_CONTROL |
| and #$40 |
| beq + |
| ldy UCI_STATUS |
| + rts |
| |
| |
| ; ============================================================================= |
| ; We pad the file to the maximal driver size ($0300) to make sure nobody |
| ; has the idea to use the memory behind EAPI in a cartridge. EasyProg |
| ; replaces EAPI and would overwrite everything in this space. |
| .fill $0300 - (* - EAPICodeBase), $ff |
| |
