2451 lines
177 KiB
Plaintext
2451 lines
177 KiB
Plaintext
{{
|
|
┌─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
│ File Allocation Table Engine │
|
|
│ │
|
|
│ Author: Kwabena W. Agyeman │
|
|
│ Updated: 1/18/2009 │
|
|
│ Designed For: P8X32A │
|
|
│ │
|
|
│ Copyright (c) 2009 Kwabena W. Agyeman │
|
|
│ See end of file for terms of use. │
|
|
│ │
|
|
│ Driver Info: │
|
|
│ │
|
|
│ The FATEngine runs a SD/SDHC/MMC driver in the next free cog on the propeller chip when called. │
|
|
│ │
|
|
│ The driver, is only guaranteed and tested to work at an 80Mhz system clock or higher. The driver is designed for the P8X32A │
|
|
│ so port B will not be operational. │
|
|
│ │
|
|
│ Nyamekye, │
|
|
└─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
}}
|
|
|
|
{{
|
|
|
|
ANPASSUNGEN HIVE-PROJECT
|
|
|
|
Informationen : hive-project.de
|
|
Kontakt : drohne235@googlemail.com
|
|
System : TriOS
|
|
Name : Komponente von Administra-Flash
|
|
Chip : Administra
|
|
Version : 00
|
|
Subversion : 01
|
|
|
|
Hinweise :
|
|
|
|
Alle Änderungen am Originalquelltext sind mit der Marke "@hive" gekennzeichnet. Die unveränderte
|
|
Originalquelle wird nur auskommentiert.
|
|
|
|
Logbuch :
|
|
|
|
25-03-2010-dr235 - änderung der fehlerstrings in fehlernummern für eine bessere auswertung
|
|
27-03-2010-dr235 - listVolumeLabel eingefügt
|
|
28-03-2010-dr235 - änderung des openFile parameters "modus" von 0-term-string zu 8bit-parameter
|
|
12-04-2010-dr235 - getDirCluster & setDirCluster für dir-marker system zugefügt
|
|
09-06-2010-dr085 - frida hat den fehler gefunden, welcher eine korrekte funktion der fatengine
|
|
nach einem bootvorgang von administra verhinderte :)
|
|
14-06-2010-dr085 - löschen der semaphore vor dem bootvorgang
|
|
10-07-2010 - provisorische behebung eines fehlers in readData (siehe admsid)
|
|
02-02-2012-dr235 - fehler in setCharacterPosition: bei einem wechsel von einer position > 0
|
|
auf position = 0 wurde der erste sektor mit falschen daten überschrieben
|
|
|
|
Notizen :
|
|
|
|
|
|
}}
|
|
CON
|
|
''
|
|
Data_Out_Pin = 10 '' ─ Data Out - To SD Card DO Pin.
|
|
''
|
|
Clock_Pin = 11 '' ─ Clock - To SD Card CLK Pin.
|
|
''
|
|
Data_In_Pin = 12 '' ─ Data In - To SD Card DI Pin.
|
|
''
|
|
Chip_Select_Pin = 13 '' ─ Chip Select - To SD Card CS.
|
|
|
|
'frida HUB_Lock = 0 ' Hub Lock To use for multiple files open with multiple copies of this object at once.
|
|
|
|
' FEHLERNUMMERN '@hive
|
|
|
|
err_noError = 0
|
|
err_fsysUnmounted = 1
|
|
err_fsysCorrupted = 2
|
|
err_fsysUnsupported = 3
|
|
err_notFound = 4
|
|
err_fileNotFound = 5
|
|
err_dirNotFound = 6
|
|
err_fileReadOnly = 7
|
|
err_endOfFile = 8
|
|
err_endOfDirectory = 9
|
|
err_endOfRoot = 10
|
|
err_dirIsFull = 11
|
|
err_dirIsNotEmpty = 12
|
|
err_checksumError = 13
|
|
err_rebootError = 14
|
|
err_bpbCorrupt = 15
|
|
err_fsiCorrupt = 16
|
|
err_dirAlreadyExist = 17
|
|
err_fileAlreadyExist = 18
|
|
err_outOfDiskFreeSpace = 19
|
|
err_diskIOError = 20
|
|
|
|
|
|
OBJ
|
|
|
|
rtc : "adm-rtc.spin"
|
|
' debugx : "pterm" 'debug
|
|
|
|
VAR
|
|
|
|
byte dataBlock[512]
|
|
|
|
word cardTime
|
|
word cardDate
|
|
|
|
byte cardUniqueIDCopy[17]
|
|
byte partitionMountedFlag
|
|
|
|
byte fileOpenFlag
|
|
byte fileReadWriteFlag
|
|
|
|
long partitionStart
|
|
long partitionSize
|
|
|
|
byte sectorsPerCluster
|
|
byte numberOfFATs
|
|
word reservedSectorCount
|
|
|
|
long FATSectorSize
|
|
|
|
word rootDirectorySectors
|
|
word rootDirectorySectorNumber
|
|
|
|
long hiddenSectors
|
|
|
|
long firstDataSector
|
|
long countOfClusters
|
|
|
|
long FATType
|
|
long rootCluster
|
|
|
|
word fileSystemInfo
|
|
word backupBootSector
|
|
|
|
long freeClusterCount
|
|
long nextFreeCluster
|
|
|
|
long volumeIdentification
|
|
|
|
word externalFlags
|
|
byte mediaType
|
|
byte unformatedNameBuffer[13]
|
|
byte formatedNameBuffer[12]
|
|
|
|
byte directoryEntryName[12]
|
|
byte directoryEntry[32]
|
|
|
|
long currentDirectory
|
|
long currentFile
|
|
|
|
long currentCluster
|
|
long currentByte
|
|
|
|
' long previousDirectory
|
|
long currentSize
|
|
|
|
long previousCluster
|
|
long previousByte
|
|
|
|
byte sdvolumeLabel[12] 'frida
|
|
|
|
PUB readShort '' 28 Stack Longs
|
|
|
|
readData(@result, 2)
|
|
|
|
PUB readLong '' 28 Stack Longs
|
|
|
|
readData(@result, 4)
|
|
|
|
PUB writeShort(value) '' 29 Stack Longs
|
|
|
|
writeData(@value, 2)
|
|
|
|
PUB writeLong(value) '' 29 Stack Longs
|
|
|
|
writeData(@value, 4)
|
|
|
|
PUB readData(addressToPut, count) | index '' 25 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Reads data from the file that is currently open for reading and advances the position by that amount of data. │
|
|
'' │ │
|
|
'' │ Will do nothing if a file is not currently open or if the card is not mounted. This throws an error. │
|
|
'' │ │
|
|
'' │ If an error occurs this function will abort and return a pointer to a string describing that error. │
|
|
'' │ │
|
|
'' │ AddressToPut - A pointer to the start of a data buffer to read to from disk. │
|
|
'' │ Count - The amount of data to read from disk. The data buffer must be atleast this large. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
count #>= 0
|
|
|
|
'#####################################################################
|
|
' repeat while((count > 0) and readWriteCurrentCluster("R", "F"))
|
|
|
|
repeat while (count > 0) ' änderung um 4096-Fehler im dmp-player
|
|
if(readWriteCurrentCluster("R", "F")) ' zu beheben
|
|
|
|
'#####################################################################
|
|
|
|
index := (currentByte & $1FF)
|
|
result := (count <# (512 - index))
|
|
|
|
bytemove(addressToPut, @dataBlock[index], result)
|
|
|
|
count -= result
|
|
currentByte += result
|
|
addressToPut += result
|
|
currentByte <#= (currentSize - 1)
|
|
|
|
PUB writeData(addressToGet, count) | index '' 25 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Writes data to the file that is currently open for writing and advances the position by that amount of data. │
|
|
'' │ │
|
|
'' │ Will do nothing if a file is not currently open or if the card is not mounted. This throws an error. │
|
|
'' │ │
|
|
'' │ If an error occurs this function will abort and return a pointer to a string describing that error. │
|
|
'' │ │
|
|
'' │ This throws an error if the file is open for reading only. │
|
|
'' │ │
|
|
'' │ Max writable file size is 2,147,483,136 bytes. Exceeding this throws an error. │
|
|
'' │ │
|
|
'' │ AddressToGet - A pointer to the start of a data buffer to write to disk. │
|
|
'' │ Count - The amount of data to write to disk. The data buffer must be atleast this large. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
count #>= 0
|
|
repeat while((count > 0) and readWriteCurrentCluster("W", "F"))
|
|
|
|
index := (currentByte & $1FF)
|
|
result := (count <# (512 - index))
|
|
|
|
bytemove(@dataBlock[index], addressToGet, result)
|
|
flushCharacters
|
|
|
|
count -= result
|
|
currentByte += result
|
|
addressToGet += result
|
|
currentSize #>= currentByte
|
|
|
|
PUB readCharacter '' 22 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Reads a character from the file that is currently open for reading and advances the position by one. │
|
|
'' │ │
|
|
'' │ Will do nothing if a file is not currently open or if the card is not mounted. This throws an error. │
|
|
'' │ │
|
|
'' │ If an error occurs this function will abort and return a pointer to a string describing that error. │
|
|
'' │ │
|
|
'' │ Returns the next character to read from the file. At the end of file returns the last character in the file repeatedly. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
if(readWriteCurrentCluster("R", "F"))
|
|
|
|
result := blockToByte(currentByte++)
|
|
currentByte <#= (currentSize - 1)
|
|
|
|
PUB writeCharacter(character) '' 23 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Writes a character to the file that is currently open for writing and advances the position by one. │
|
|
'' │ │
|
|
'' │ Will do nothing if a file is not currently open or if the card is not mounted. This throws an error. │
|
|
'' │ │
|
|
'' │ If an error occurs this function will abort and return a pointer to a string describing that error. │
|
|
'' │ │
|
|
'' │ This throws an error if the file is open for reading only. │
|
|
'' │ │
|
|
'' │ Max writable file size is 2,147,483,136 bytes. Exceeding this throws an error. │
|
|
'' │ │
|
|
'' │ Character - A character to write to the file. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
if(readWriteCurrentCluster("W", "F"))
|
|
|
|
byteToBlock(currentByte++, character)
|
|
|
|
ifnot($1FF & currentByte--)
|
|
flushCharacters
|
|
|
|
currentSize #>= ++currentByte
|
|
|
|
PUB writeCharacters(characters) '' 27 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Writes a string of characters to the file that is currently open for writing and advances the position by string length. │
|
|
'' │ │
|
|
'' │ Will do nothing if a file is not currently open or if the card is not mounted. This throws an error. │
|
|
'' │ │
|
|
'' │ If an error occurs this function will abort and return a pointer to a string describing that error. │
|
|
'' │ │
|
|
'' │ This throws an error if the file is open for reading only. │
|
|
'' │ │
|
|
'' │ Max writable file size is 2,147,483,136 bytes. Exceeding this throws an error. │
|
|
'' │ │
|
|
'' │ Characters - A pointer to a string of characters to write to the file. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
repeat strsize(characters)
|
|
writeCharacter(byte[characters++])
|
|
|
|
PUB flushCharacters '' 12 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Writes buffered data to disk. All file writes are buffered and are not written to disk immediantly. │
|
|
'' │ │
|
|
'' │ If the partition is not mounted or an error occurs this function will abort and return a string describing that error. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
if(partitionMountedFlag and fileOpenFlag and fileReadWriteFlag)
|
|
readWriteCurrentSector("W")
|
|
|
|
PUB getEOF
|
|
|
|
result := currentByte => currentSize-1
|
|
|
|
PUB getCharacterPosition '' 3 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Gets the current character position within a file for reading and writing. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
return (currentByte & (partitionMountedFlag and fileOpenFlag))
|
|
|
|
PUB setCharacterPosition(position) | backUpPosition '' 17 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Sets the current character position within a file for reading and writing. │
|
|
'' │ │
|
|
'' │ If the partition is not mounted or an error occurs this function will abort and return a string describing that error. │
|
|
'' │ │
|
|
'' │ Position - A character position in the file. Set to false to go to the begining of the file and true to go to the end. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
if(partitionMountedFlag and fileOpenFlag)
|
|
|
|
position := ((position <# (currentSize - 1)) #> 0)
|
|
backUpPosition := position
|
|
|
|
if(position <> currentByte) '@hive: fehlerkorrektur vom originalcode
|
|
flushCharacters
|
|
|
|
currentByte >>= 9
|
|
position >>= 9
|
|
|
|
' if(position <> currentByte) 'dieser abschnitt muss nach oben verschoben werden
|
|
' flushCharacters 'da flashCharacter in sonderfällen auf currentByte zugreift!
|
|
|
|
currentByte /= sectorsPerCluster
|
|
position /= sectorsPerCluster
|
|
|
|
if(position <> currentByte)
|
|
if(position < currentByte)
|
|
currentByte := 0
|
|
currentCluster := currentFile
|
|
|
|
repeat until(position == currentByte++)
|
|
|
|
readWriteFATBlock(currentCluster, "R")
|
|
currentCluster := readFATEntry(currentCluster)
|
|
|
|
if((currentCluster =< 1) or (FATEndOfClusterValue =< currentCluster))
|
|
partitionMountedFlag := false
|
|
' abort @FSCorrupted '@hive
|
|
abort err_fsysCorrupted
|
|
|
|
result := true
|
|
|
|
currentByte := backUpPosition
|
|
|
|
if(result)
|
|
readWriteCurrentSector("R")
|
|
|
|
PUB closeFile '' 15 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Closes the currently open file in the current directory. Files opened for writing that are not closed will be corrupted. │
|
|
'' │ │
|
|
'' │ If the partition is not mounted or an error occurs this function will abort and return a string describing that error. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
flushCharacters
|
|
if(partitionMountedFlag and fileOpenFlag~)
|
|
|
|
currentByte := previousByte
|
|
currentCluster := previousCluster
|
|
|
|
readWriteCurrentSector("R")
|
|
|
|
wordToBlock((currentByte + 18), readClock)
|
|
|
|
if(fileReadWriteFlag)
|
|
|
|
wordToBlock((currentByte + 22), cardTime)
|
|
wordToBlock((currentByte + 24), cardDate)
|
|
longToBlock((currentByte + 28), currentSize)
|
|
|
|
dataBlock[(currentByte + 11) & $1FF] |= $20
|
|
|
|
readWriteCurrentSector("W")
|
|
|
|
PUB openFile(fileName, mode) '' 33 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Opens a file in the current directory for reading or writing. │
|
|
'' │ │
|
|
'' │ If the partition is not mounted or an error occurs this function will abort and return a string describing that error. │
|
|
'' │ │
|
|
'' │ The "." and ".." entries are ignored by this function. │
|
|
'' │ │
|
|
'' │ Returns a pointer to the name of the file. │
|
|
'' │ │
|
|
'' │ FileName - The name of the file to open for reading or writing. │
|
|
'' │ Mode - A string of characters containing the mode to open the file in. R-Read, W-Write, A-Append. Default read. │
|
|
'' │ │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
' result := unformatName(listFind(formatName(fileName), @fileNotFound))
|
|
result := unformatName(listFind(formatName(fileName), err_fileNotFound)) '@hive
|
|
|
|
if(listIsDirectory)
|
|
' abort @fileNotFound '@hive
|
|
abort err_fileNotFound
|
|
|
|
currentFile := listCluster
|
|
|
|
ifnot(currentFile)
|
|
currentFile := createClusterChain(0)
|
|
|
|
readWriteCurrentSector("R")
|
|
dataBlock[(currentByte + 11) & $1FF] |= $20
|
|
wordToBlock((currentByte + 18), readClock)
|
|
wordToBlock((currentByte + 26), (currentFile & $FFFF))
|
|
wordToBlock((currentByte + 20), (currentFile >> 16))
|
|
readWriteCurrentSector("W")
|
|
|
|
' fileReadWriteFlag := findCharacter(mode, "W") '@hive
|
|
fileReadWriteFlag := mode == "W"
|
|
|
|
if(listIsReadOnly and fileReadWriteFlag)
|
|
' abort string("File Read Only") '@hive
|
|
abort err_fileReadOnly
|
|
|
|
currentSize := listSize
|
|
previousByte := currentByte
|
|
previousCluster := currentCluster
|
|
' currentByte := ((findCharacter(mode, "A") and fileReadWriteFlag) & currentSize) '@hive
|
|
currentByte := (( (mode == "A") and fileReadWriteFlag) & currentSize)
|
|
currentCluster := currentFile
|
|
|
|
readWriteCurrentSector("R")
|
|
fileOpenFlag := true
|
|
|
|
PUB newFile(fileName) '' 40 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Creates a new file in the current directory. │
|
|
'' │ │
|
|
'' │ If the partition is not mounted or an error occurs this function will abort and return a string describing that error. │
|
|
'' │ │
|
|
'' │ Returns a pointer to the name of the file. List functions are not valid after calling this function. │
|
|
'' │ │
|
|
'' │ FileName - The name of the new file to create. Must be a new unique name in the current directory. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
' result := unformatName(listNew(formatName(fileName), $20, readClock, cardTime, 0, "F")) '@hive
|
|
unformatName(listNew(formatName(fileName), $20, readClock, cardTime, 0, "F")) '@hive
|
|
listReset
|
|
|
|
PUB newDirectory(directoryName) '' 40 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Creates a new directory in the current directory. │
|
|
'' │ │
|
|
'' │ If the partition is not mounted or an error occurs this function will abort and return a string describing that error. │
|
|
'' │ │
|
|
'' │ Returns a pointer to the name of the directory. List functions are not valid after calling this function. │
|
|
'' │ │
|
|
'' │ DirectoryName - The name of the new directory to create. Must be a new unique name in the current directory. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
' result := unformatName(listNew(formatName(directoryName), $30, readClock, cardTime, 0, "D")) '@hive
|
|
unformatName(listNew(formatName(directoryName), $30, readClock, cardTime, 0, "D"))
|
|
|
|
directoryName := currentDirectory
|
|
currentDirectory := currentFile
|
|
|
|
listNew(@dot, $10, cardDate, cardTime, currentDirectory, "F")
|
|
listNew(@dotdot, $10, cardDate, cardTime, directoryName, "F")
|
|
|
|
currentDirectory := directoryName
|
|
listReset
|
|
|
|
PUB deleteEntry(entryName) '' 32 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Deletes a file or directory in the current directory. │
|
|
'' │ │
|
|
'' │ If the partition is not mounted or an error occurs this function will abort and return a string describing that error. │
|
|
'' │ │
|
|
'' │ Cannot delete non empty directories. This throws and error. │
|
|
'' │ │
|
|
'' │ The "." and ".." entries are ignored by this function. │
|
|
'' │ │
|
|
'' │ Returns a pointer to the name of the file or directory. List functions are not valid after calling this function. │
|
|
'' │ │
|
|
'' │ EntryName - The name of the file or directory to delete. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
' result := unformatName(listFind(formatName(entryName), @fileOrDirectoryNotFound)) '@hive
|
|
result := unformatName(listFind(formatName(entryName), err_notFound))
|
|
|
|
if(listIsDirectory)
|
|
|
|
previousByte := currentByte~
|
|
previousCluster := currentCluster
|
|
currentCluster := listCluster
|
|
|
|
repeat
|
|
entryName := listDirectory("R")
|
|
|
|
ifnot(entryName)
|
|
quit
|
|
|
|
if(byte[entryName] <> ".")
|
|
' abort string("Directory Is Not Empty") '@hive
|
|
abort err_dirIsNotEmpty
|
|
|
|
currentByte := previousByte
|
|
currentCluster := previousCluster
|
|
|
|
readWriteCurrentSector("R")
|
|
|
|
byteToBlock(currentByte, $E5)
|
|
readWriteCurrentSector("W")
|
|
|
|
destroyClusterChain(listCluster)
|
|
listReset
|
|
|
|
PUB renameEntry(entryNameToChange, entryNameToChangeTo) '' 33 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Renames a file or directory in the current directory. The new name must be unique in the current directory. │
|
|
'' │ │
|
|
'' │ If the partition is not mounted or an error occurs this function will abort and return a string describing that error. │
|
|
'' │ │
|
|
'' │ The "." and ".." entries are ignored by this function. │
|
|
'' │ │
|
|
'' │ Returns a pointer to the name of the file or directory. List functions are not valid after calling this function. │
|
|
'' │ │
|
|
'' │ EntryNameToChange - The name of the file or directory to change. │
|
|
'' │ EntryNameToChangeTo - The name of the file or directory to change to. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
listDuplicate(formatName(entryNameToChangeTo))
|
|
' result := unformatName(listFind(formatName(entryNameToChange), @fileOrDirectoryNotFound)) '@hive
|
|
result := unformatName(listFind(formatName(entryNameToChange), err_notFound))
|
|
|
|
bytemove(@dataBlock[currentByte & $1FF], formatName(entryNameToChangeTo), 11)
|
|
|
|
wordToBlock((currentByte + 18), readClock)
|
|
wordToBlock((currentByte + 22), cardTime)
|
|
wordToBlock((currentByte + 24), cardDate)
|
|
dataBlock[(currentByte + 11) & $1FF] |= $20
|
|
|
|
readWriteCurrentSector("W")
|
|
listReset
|
|
|
|
PUB changeAttributes(entryName, newAttributes) '' 33 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Changes the attributes of a file or directory in the current directory. │
|
|
'' │ │
|
|
'' │ If the partition is not mounted or an error occurs this function will abort and return a string describing that error. │
|
|
'' │ │
|
|
'' │ The "." and ".." entries are ignored by this function. │
|
|
'' │ │
|
|
'' │ Returns a pointer to the name of the file or directory. List functions are not valid after calling this function. │
|
|
'' │ │
|
|
'' │ EntryName - The name of the file or directory to change the attributes of. │
|
|
'' │ NewAttributes - A string of characters containing the new set of attributes. A-Archive, S-System, H-Hidden, R-Read Only. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
' result := unformatName(listFind(formatName(entryName), @fileOrDirectoryNotFound)) '@hive
|
|
result := unformatName(listFind(formatName(entryName), err_notFound))
|
|
|
|
byteToBlock((currentByte + 11), (($20 & findCharacter(newAttributes, "A")) | (listIsDirectory & $10) | ($4 & findCharacter(newAttributes, "S")) | ($2 & findCharacter(newAttributes, "H")) | ($1 & findCharacter(newAttributes, "R"))))
|
|
wordToBlock((currentByte + 18), readClock)
|
|
wordToBlock((currentByte + 22), cardTime)
|
|
wordToBlock((currentByte + 24), cardDate)
|
|
|
|
readWriteCurrentSector("W")
|
|
' listReset '@hive
|
|
|
|
PUB changeDirectory(directoryName) '' 32 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Searches the current directory for the specified directory and enters that directory. │
|
|
'' │ │
|
|
'' │ If the partition is not mounted or an error occurs this function will abort and return a string describing that error. │
|
|
'' │ │
|
|
'' │ Returns a pointer to the name of the direcotry. List functions are not valid after calling this function. │
|
|
'' │ │
|
|
'' │ DirectoryName - The name of the directory to search for in the current directory and enter into. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
' result := unformatName(listFind(listCase(directoryName, formatName(directoryName)), @directoryNotFound)) '@hive
|
|
result := unformatName(listFind(listCase(directoryName, formatName(directoryName)), err_dirNotFound))
|
|
|
|
ifnot(listIsDirectory)
|
|
' abort @directoryNotFound '@hive
|
|
abort err_dirNotFound
|
|
|
|
currentDirectory := listCluster
|
|
listReset
|
|
|
|
PUB getDirCluster:cluster
|
|
|
|
result := currentDirectory
|
|
|
|
PUB setDirCluster(cluster)
|
|
|
|
currentDirectory := cluster
|
|
listReset
|
|
|
|
PUB listSearch(entryName) '' 32 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Returns a pointer to the name of the serached for file or direcotry in the current directory. │
|
|
'' │ │
|
|
'' │ Additionally this function validates the other listing functions to get information about the next file or directory. │
|
|
'' │ │
|
|
'' │ If the partition is not mounted or an error occurs this function will abort and return a string describing that error. │
|
|
'' │ │
|
|
'' │ EntryName - The name of the file or directory to search for in the current directory. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
' return unformatName(listFind(listCase(entryName, formatName(entryName)), @fileOrDirectoryNotFound)) '@hive
|
|
return unformatName(listFind(listCase(entryName, formatName(entryName)), err_notFound))
|
|
|
|
PUB listName '' 26 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Returns a pointer to the name of the next file or direcotry in the current directory. Returns zero on wrap arround. │
|
|
'' │ │
|
|
'' │ Additionally this function validates the other listing functions to get information about the next file or directory. │
|
|
'' │ │
|
|
'' │ If the partition is not mounted or an error occurs this function will abort and return a string describing that error. │
|
|
'' │ │
|
|
'' │ After listing the last file or directory "listReset" must be called to to list from the first file or direcotry again. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
return unformatName(listDirectory("R"))
|
|
|
|
PUB listReset '' 3 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Resets "listName" to list from the first file or directory in the current directory. │
|
|
'' │ │
|
|
'' │ List functions are not valid after calling this function. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
ifnot(fileOpenFlag)
|
|
|
|
currentByte := 0
|
|
currentCluster := currentDirectory
|
|
|
|
bytefill(@directoryEntry, 0, 32)
|
|
bytefill(@directoryEntryName, 0, 12)
|
|
|
|
PUB listSize '' 3 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Gets the size of current file or directory pointed to by "listName". Directories have no size. │
|
|
'' │ │
|
|
'' │ If a file is currently open this function will retrieve that files information. │
|
|
'' │ │
|
|
'' │ If "listName" did not succed or was not previously called the value returned is invalid. │
|
|
'' │ │
|
|
'' │ Returns the size of the file or directory in bytes. Maximum file size is 2,147,483,136 bytes. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
return (((directoryEntry[28] | (directoryEntry[29] << 8) | (directoryEntry[30] << 16) | (directoryEntry[31] << 24)) <# $7FFFFE00) #> 0)
|
|
|
|
PUB listCreationDay '' 3 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Gets the creation day of the current file or directory pointed to by "listName". │
|
|
'' │ │
|
|
'' │ If a file is currently open this function will retrieve that file's information. │
|
|
'' │ │
|
|
'' │ If "listName" did not succed or was not previously called the value returned is invalid. │
|
|
'' │ │
|
|
'' │ Returns the creation day of the file or directory. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
return (directoryEntry[16] & $1F)
|
|
|
|
PUB listCreationMonth '' 3 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Gets the creation month of the current file or directory pointed to by "listName". │
|
|
'' │ │
|
|
'' │ If a file is currently open this function will retrieve that file's information. │
|
|
'' │ │
|
|
'' │ If "listName" did not succed or was not previously called the value returned is invalid. │
|
|
'' │ │
|
|
'' │ Returns the creation month of the file or directory. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
return (((directoryEntry[17] & $1) << 3) | (directoryEntry[16] >> 5))
|
|
|
|
PUB listCreationYear '' 3 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Gets the creation year of the current file or directory pointed to by "listName". │
|
|
'' │ │
|
|
'' │ If a file is currently open this function will retrieve that file's information. │
|
|
'' │ │
|
|
'' │ If "listName" did not succed or was not previously called the value returned is invalid. │
|
|
'' │ │
|
|
'' │ Returns the creation year of the file or directory. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
return ((directoryEntry[17] >> 1) + 1980)
|
|
|
|
PUB listCreationSeconds '' 3 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Gets the creation second of the current file or directory pointed to by "listName". │
|
|
'' │ │
|
|
'' │ If a file is currently open this function will retrieve that file's information. │
|
|
'' │ │
|
|
'' │ If "listName" did not succed or was not previously called the value returned is invalid. │
|
|
'' │ │
|
|
'' │ Returns the creation second of the file or directory. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
return (((directoryEntry[14] & $1F) << 1) + (directoryEntry[13] / 100))
|
|
|
|
PUB listCreationMinutes '' 3 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Gets the creation minute of the current file or directory pointed to by "listName". │
|
|
'' │ │
|
|
'' │ If a file is currently open this function will retrieve that file's information. │
|
|
'' │ │
|
|
'' │ If "listName" did not succed or was not previously called the value returned is invalid. │
|
|
'' │ │
|
|
'' │ Returns the creation minute of the file or directory. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
return (((directoryEntry[15] & $7) << 3) | (directoryEntry[14] >> 5))
|
|
|
|
PUB listCreationHours '' 3 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Gets the creation hour of the current file or directory pointed to by "listName". │
|
|
'' │ │
|
|
'' │ If a file is currently open this function will retrieve that file's information. │
|
|
'' │ │
|
|
'' │ If "listName" did not succed or was not previously called the value returned is invalid. │
|
|
'' │ │
|
|
'' │ Returns the creation hour of the file or directory. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
return (directoryEntry[15] >> 3)
|
|
|
|
PUB listAccessDay '' 3 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Gets the last day of access of the current file or directory pointed to by "listName". │
|
|
'' │ │
|
|
'' │ If a file is currently open this function will retrieve that file's information. │
|
|
'' │ │
|
|
'' │ If "listName" did not succed or was not previously called the value returned is invalid. │
|
|
'' │ │
|
|
'' │ Returns the last acess day of the file or directory. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
return (directoryEntry[18] & $1F)
|
|
|
|
PUB listAccessMonth '' 3 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Gets the last month of access of the current file or directory pointed to by "listName". │
|
|
'' │ │
|
|
'' │ If a file is currently open this function will retrieve that file's information. │
|
|
'' │ │
|
|
'' │ If "listName" did not succed or was not previously called the value returned is invalid. │
|
|
'' │ │
|
|
'' │ Returns the last acess month of the file or directory. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
return (((directoryEntry[19] & $1) << 3) | (directoryEntry[18] >> 5))
|
|
|
|
PUB listAccessYear '' 3 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Gets the last year of access of the current file or directory pointed to by "listName". │
|
|
'' │ │
|
|
'' │ If a file is currently open this function will retrieve that file's information. │
|
|
'' │ │
|
|
'' │ If "listName" did not succed or was not previously called the value returned is invalid. │
|
|
'' │ │
|
|
'' │ Returns the last acess year of the file or directory. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
return ((directoryEntry[19] >> 1) + 1980)
|
|
|
|
PUB listModificationDay '' 3 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Gets the last day of modification of the current file or directory pointed to by "listName". │
|
|
'' │ │
|
|
'' │ If a file is currently open this function will retrieve that file's information. │
|
|
'' │ │
|
|
'' │ If "listName" did not succed or was not previously called the value returned is invalid. │
|
|
'' │ │
|
|
'' │ Returns the modification day of the file or directory. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
return (directoryEntry[24] & $1F)
|
|
|
|
PUB listModificationMonth '' 3 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Gets the last month of modification of the current file or directory pointed to by "listName". │
|
|
'' │ │
|
|
'' │ If a file is currently open this function will retrieve that file's information. │
|
|
'' │ │
|
|
'' │ If "listName" did not succed or was not previously called the value returned is invalid. │
|
|
'' │ │
|
|
'' │ Returns the modification month of the file or directory. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
return (((directoryEntry[25] & $1) << 3) | (directoryEntry[24] >> 5))
|
|
|
|
PUB listModificationYear '' 3 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Gets the last year of modification of the current file or directory pointed to by "listName". │
|
|
'' │ │
|
|
'' │ If a file is currently open this function will retrieve that file's information. │
|
|
'' │ │
|
|
'' │ If "listName" did not succed or was not previously called the value returned is invalid. │
|
|
'' │ │
|
|
'' │ Returns the modification year of the file or directory. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
return ((directoryEntry[25] >> 1) + 1980)
|
|
|
|
PUB listModificationSeconds '' 3 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Gets the last second of modification of the current file or directory pointed to by "listName". │
|
|
'' │ │
|
|
'' │ If a file is currently open this function will retrieve that file's information. │
|
|
'' │ │
|
|
'' │ If "listName" did not succed or was not previously called the value returned is invalid. │
|
|
'' │ │
|
|
'' │ Returns the modification second of the file or directory. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
return ((directoryEntry[22] & $1F) << 1)
|
|
|
|
PUB listModificationMinutes '' 3 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Gets the last minute of modification of the current file or directory pointed to by "listName". │
|
|
'' │ │
|
|
'' │ If a file is currently open this function will retrieve that file's information. │
|
|
'' │ │
|
|
'' │ If "listName" did not succed or was not previously called the value returned is invalid. │
|
|
'' │ │
|
|
'' │ Returns the modification minute of the file or directory. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
return (((directoryEntry[23] & $7) << 3) | (directoryEntry[22] >> 5))
|
|
|
|
PUB listModificationHours '' 3 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Gets the last hour of modification of the current file or directory pointed to by "listName". │
|
|
'' │ │
|
|
'' │ If a file is currently open this function will retrieve that file's information. │
|
|
'' │ │
|
|
'' │ If "listName" did not succed or was not previously called the value returned is invalid. │
|
|
'' │ │
|
|
'' │ Returns the modification hour of the file or directory. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
return (directoryEntry[23] >> 3)
|
|
|
|
PUB listIsReadOnly '' 3 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Returns whether or not the current file or directory pointed to by "listName" is read only. │
|
|
'' │ │
|
|
'' │ If a file is currently open this function will retrieve that file's information. │
|
|
'' │ │
|
|
'' │ If "listName" did not succed or was not previously called the value returned is invalid. │
|
|
'' │ │
|
|
'' │ Returns true or false. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
result or= (directoryEntry[11] & $1)
|
|
|
|
PUB listIsHidden '' 3 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Returns whether or not the current file or directory pointed to by "listName" is hidden. │
|
|
'' │ │
|
|
'' │ If a file is currently open this function will retrieve that file's information. │
|
|
'' │ │
|
|
'' │ If "listName" did not succed or was not previously called the value returned is invalid. │
|
|
'' │ │
|
|
'' │ Returns true or false. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
result or= (directoryEntry[11] & $2)
|
|
|
|
PUB listIsSystem '' 3 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Returns whether or not the current file or directory pointed to by "listName" is a system file. │
|
|
'' │ │
|
|
'' │ If a file is currently open this function will retrieve that file's information. │
|
|
'' │ │
|
|
'' │ If "listName" did not succed or was not previously called the value returned is invalid. │
|
|
'' │ │
|
|
'' │ Returns true or false. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
result or= (directoryEntry[11] & $4)
|
|
|
|
PUB listIsDirectory '' 3 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Returns whether or not the current file or directory pointed to by "listName" is a directory. │
|
|
'' │ │
|
|
'' │ If a file is currently open this function will retrieve that file's information. │
|
|
'' │ │
|
|
'' │ If "listName" did not succed or was not previously called the value returned is invalid. │
|
|
'' │ │
|
|
'' │ Returns true or false. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
result or= (directoryEntry[11] & $10)
|
|
|
|
PUB listIsArchive '' 3 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Returns whether or not the current file or directory pointed to by "listName" has been modified since the last backup. │
|
|
'' │ │
|
|
'' │ If a file is currently open this function will retrieve that file's information. │
|
|
'' │ │
|
|
'' │ If "listName" did not succed or was not previously called the value returned is invalid. │
|
|
'' │ │
|
|
'' │ Returns true or false. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
result or= (directoryEntry[11] & $20)
|
|
|
|
PUB listVolumeLabel
|
|
'' return: zeiger auf string mit volume-label
|
|
|
|
'return unformatName(listDirectory("V")) 'frida
|
|
if(partitionMountedFlag) 'frida
|
|
return @sdvolumeLabel 'frida
|
|
|
|
|
|
PUB checkPartitionMounted '' 3 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Returns true if the file system is still currently mounted and false if not. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
result or= partitionMountedFlag
|
|
|
|
PUB checkFileOpen '' 3 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Returns true if a file is still currently open and false if not. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
result or= fileOpenFlag
|
|
|
|
PUB checkUsedSectorCount(mode) '' 18 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Returns the current used sector count on this partition. │
|
|
'' │ │
|
|
'' │ Will do nothing if a file is currently open or if the card is not mounted. This throws an error. │
|
|
'' │ │
|
|
'' │ If an error occurs this function will abort and return a pointer to a string describing that error. │
|
|
'' │ │
|
|
'' │ In fast mode this function will return the last valid used sector count if avialable. This is an estimate value. │
|
|
'' │ │
|
|
'' │ In slow mode this function will compute the used sector count by scanning the entire FAT. This can take a long time. │
|
|
'' │ │
|
|
'' │ One sector is equal to 512 bytes. Multiply the used sector count by 512 to determine the number of used bytes. │
|
|
'' │ │
|
|
'' │ This function also finds the next free cluster for creating new files and directories. │
|
|
'' │ │
|
|
'' │ Call this function when running out of disk space to find the next free cluster if available. │
|
|
'' │ │
|
|
'' │ If the last valid used sector count is not avialable when using fast mode this function will enter slow mode, │
|
|
'' │ │
|
|
'' │ Mode - A character specifing the mode to use. F-Fast, S-Slow. Default slow. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
if(partitionMountedFlag)
|
|
return ((countOfClusters * sectorsPerCluster) - checkFreeSectorCount(mode))
|
|
|
|
PUB checkFreeSectorCount(mode) '' 14 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Returns the current free sector count on this partition. │
|
|
'' │ │
|
|
'' │ Will do nothing if a file is currently open or if the card is not mounted. This throws an error. │
|
|
'' │ │
|
|
'' │ If an error occurs this function will abort and return a pointer to a string describing that error. │
|
|
'' │ │
|
|
'' │ In fast mode this function will return the last valid free sector count if avialable. This is an estimate value. │
|
|
'' │ │
|
|
'' │ In slow mode this function will compute the free sector count by scanning the entire FAT. This can take a long time. │
|
|
'' │ │
|
|
'' │ One sector is equal to 512 bytes. Multiply the free sector count by 512 to determine the number of free bytes. │
|
|
'' │ │
|
|
'' │ This function also finds the next free cluster for creating new files and directories. │
|
|
'' │ │
|
|
'' │ Call this function when running out of disk space to find the next free cluster if available. │
|
|
'' │ │
|
|
'' │ If the last valid free sector count is not avialable when using fast mode this function will enter slow mode, │
|
|
'' │ │
|
|
'' │ Mode - A character specifing the mode to use. F-Fast, S-Slow. Default slow. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
if(partitionMountedFlag)
|
|
flushCharacters
|
|
|
|
if(findByte(mode, "f", "F") and (freeClusterCount <> $FFFFFFFF))
|
|
result := freeClusterCount
|
|
|
|
else
|
|
repeat mode from 0 to (countOfClusters + 1)
|
|
|
|
ifnot(FATEntryNumber(mode))
|
|
readWriteFATBlock(mode, "R")
|
|
|
|
result -= (not(readFATEntry(mode)))
|
|
|
|
ifnot(result)
|
|
nextFreeCluster := ((mode + 1) <# (countOfClusters + 1))
|
|
|
|
freeClusterCount := result
|
|
readWriteCurrentSector("R")
|
|
|
|
result *= sectorsPerCluster
|
|
|
|
PUB bootPartition(fileName, checkDisk) | bootSectors[64] '' 102 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Reboots the propeller chip to run the selected file from memory. The file should be a valid spin BIN or EEPROM file. │
|
|
'' │ │
|
|
'' │ Will do nothing if the card is not mounted. This throws an error. │
|
|
'' │ │
|
|
'' │ If an error occurs this function will abort and return a pointer to a string describing that error. │
|
|
'' │ │
|
|
'' │ FileName - The name of the file to reboot from. │
|
|
'' │ CheckDisk - Unmounts the partition before booting if "C". │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
longfill(@bootSectors, 0, 64)
|
|
openFile(fileName~, string("R"))
|
|
|
|
repeat (listSize <# 32768)
|
|
result += readCharacter
|
|
|
|
ifnot($1FF & fileName++)
|
|
bootSectors[fileName >> 9] := (partitionStart + FATFirstSectorInCluster(currentCluster) + FATWorkingSectorInCluster)
|
|
|
|
result &= $FF
|
|
setCharacterPosition(6)
|
|
fileName := readShort
|
|
closeFile
|
|
|
|
if((result and (result <> $14)) or (fileName <> $10))
|
|
' abort string("Checksum Error") '@hive
|
|
abort err_checksumError
|
|
|
|
if(findByte(checkDisk, "c", "C"))
|
|
unmountPartition
|
|
|
|
readWriteBlock(@bootSectors, "B")
|
|
' abort string("Reboot Error") '@hive
|
|
abort err_rebootError
|
|
|
|
PUB formatPartition(partition, volumeLabel, checkDisk) '' 34 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Permanetly deletes all information on the loaded FAT16/32 file system. Unloads the loaded FAT16/32 file system. │
|
|
'' │ │
|
|
'' │ Will do nothing if the card is not mounted. This throws an error. │
|
|
'' │ │
|
|
'' │ If an error occurs this function will abort and return a pointer to a string describing that error. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
mountPartition(partition, checkdisk)
|
|
|
|
repeat while(readWriteCurrentCluster("R", "D"))
|
|
bytefill(@dataBlock, 0, 512)
|
|
readWriteCurrentSector("W")
|
|
currentByte += 512
|
|
|
|
' result := unformatName(listNew(formatName(volumeLabel), $8, readClock, cardTime, 0, 0)) '@hive
|
|
unformatName(listNew(formatName(volumeLabel), $8, readClock, cardTime, 0, 0)) '@hive
|
|
|
|
bytefill(@dataBlock, 0, 512)
|
|
repeat volumeLabel from reservedSectorCount to (rootDirectorySectorNumber - 1)
|
|
readWriteBlock(volumeLabel, "W")
|
|
|
|
readWriteFATBlock(0, "R")
|
|
writeFATEntry(0, ($0FFFFF00 | mediaType))
|
|
writeFATEntry(1, $0FFFFFFF)
|
|
readWriteFATBlock(0, "W")
|
|
|
|
listReset
|
|
|
|
PUB mountPartition(partition, checkDisk) '' 28 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Loads a FAT16/32 file system with up to 1,099,511,627,776 bytes for use. │
|
|
'' │ │
|
|
'' │ If an error occurs this function will abort and return a pointer to a string describing that error. │
|
|
'' │ │
|
|
'' │ File sizes up to 2,147,483,136 bytes are supported. │
|
|
'' │ │
|
|
'' │ Directory sizes up to 65,536 entries are supported. │
|
|
'' │ │
|
|
'' │ Additionally check disk flags can be setup so that check disk is called on any improperly unmounted partition. │
|
|
'' │ │
|
|
'' │ Returns a pointer to the volume label. │
|
|
'' │ │
|
|
'' │ Parition - Partition number to mount (between 0 and 3). The default partition number is 0. │
|
|
'' │ CheckDisk - Raises the check disk flag upon mounting. C-Raise Flag │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
'' @hive:
|
|
'' return: fehlernummer
|
|
|
|
unmountPartition
|
|
|
|
partitionStart := 0
|
|
readWriteBlock(0, "M")
|
|
|
|
bytemove(@cardUniqueIDCopy, @cardUniqueID, 17)
|
|
readWriteBlock(0, "R")
|
|
|
|
if(blockToWord(510) <> $AA55)
|
|
' abort @FSCorrupted '@hive
|
|
abort err_fsysCorrupted
|
|
|
|
partition := (((partition <# 3) #> 0) << 4)
|
|
if((blockToByte(0) <> $EB) and (blockToByte(0) <> $E9))
|
|
|
|
'case(blockToByte(450 + partition) & $F)
|
|
' $0 .. $3, $5, $7 .. $A, $D, $F: abort @FSUnsupported
|
|
|
|
'volumeIdentification := blockToLong(440)
|
|
'partitionSize := blockToLong(458 + partition)
|
|
|
|
partitionStart := blockToLong(454 + partition)
|
|
readWriteBlock(0, "R")
|
|
|
|
if(blockToWord(510) <> $AA55)
|
|
' abort string("BPB Corrupt") '@hive
|
|
abort err_bpbCorrupt
|
|
|
|
|
|
|
|
if(blockToWord(11) <> 512)
|
|
' abort @FSUnsupported '@hive
|
|
abort err_fsysUnsupported
|
|
|
|
sectorsPerCluster := blockToByte(13)
|
|
reservedSectorCount := blockToWord(14)
|
|
numberOfFATs := blockToByte(16)
|
|
externalFlags := 0
|
|
|
|
partitionSize := blockToWord(19)
|
|
ifnot(partitionSize)
|
|
partitionSize := blockToLong(32)
|
|
|
|
FATSectorSize := blockToWord(22)
|
|
ifnot(FATSectorSize)
|
|
FATSectorSize := blockToLong(36)
|
|
|
|
mediaType := blockToByte(21)
|
|
hiddenSectors := blockToLong(28)
|
|
|
|
rootDirectorySectors := (blockToWord(17) >> 4)
|
|
rootDirectorySectorNumber := (reservedSectorCount + (numberOfFATs * FATSectorSize))
|
|
|
|
firstDataSector := (rootDirectorySectorNumber + rootDirectorySectors)
|
|
countOfClusters := ((partitionSize - firstDataSector) / sectorsPerCluster)
|
|
|
|
nextFreeCluster := 2
|
|
freeClusterCount := $FFFFFFFF
|
|
|
|
if(countOfClusters < 4085)
|
|
' abort @FSUnsupported '@hive
|
|
abort err_fsysUnsupported
|
|
|
|
FATType := false
|
|
if(countOfClusters => 65525)
|
|
FATType := true
|
|
|
|
volumeIdentification := blockToLong(39 + (28 & FATType))
|
|
dataBlock[37 + (28 & FATType)] |= ($3 & findByte(checkDisk, "c", "C"))
|
|
readWriteBlock(0, "W")
|
|
|
|
if(FATType)
|
|
if(blockToWord(40) & $80)
|
|
numberOfFATs := 1
|
|
externalFlags := (blockToWord(40) & $F)
|
|
|
|
if(blockToWord(42))
|
|
' abort @FSUnsupported '@hive
|
|
abort err_fsysUnsupported
|
|
|
|
rootCluster := blockToLong(44)
|
|
fileSystemInfo := blockToWord(48)
|
|
backupBootSector := blockToWord(50)
|
|
|
|
readWriteBlock(fileSystemInfo, "R")
|
|
|
|
if(blockToWord(510) <> $AA55)
|
|
' abort string("FSI Corrupt") '@hive
|
|
abort err_fsiCorrupt
|
|
|
|
freeClusterCount := blockToLong(488)
|
|
nextFreeCluster := blockToLong(492)
|
|
|
|
if(nextFreeCluster == $FFFFFFFF)
|
|
nextFreeCluster := 2
|
|
|
|
partitionMountedFlag := true
|
|
|
|
currentDirectory := 0
|
|
listReset
|
|
|
|
' return unformatName(listDirectory("V")) '@hive
|
|
result := listDirectory("V") 'frida
|
|
bytemove(@sdvolumeLabel, result, 12) 'frida
|
|
return 0
|
|
|
|
PUB unmountPartition '' 18 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Unloads the loaded FAT16/32 file system. Closes the currently open file in the current directory. │
|
|
'' │ │
|
|
'' │ If an error occurs this function will abort and return a pointer to a string describing that error. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
closeFile
|
|
if(partitionMountedFlag~)
|
|
|
|
currentDirectory := 0
|
|
listReset
|
|
|
|
readWriteBlock(0, "R")
|
|
dataBlock[37 + (28 & FATType)] &= $FC
|
|
readWriteBlock(0, "W")
|
|
|
|
if(FATType)
|
|
readWriteBlock(fileSystemInfo, "R")
|
|
longToBlock(freeClusterCount, 488)
|
|
longToBlock(nextFreeCluster, 492)
|
|
readWriteBlock(fileSystemInfo, "W")
|
|
|
|
PUB FATEngine '' 3 Stack Longs
|
|
|
|
'' ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
'' │ Initializes the file system driver to run on a new cog. │
|
|
'' │ │
|
|
'' │ Returns the new cog's ID on sucess or -1 on failure. │
|
|
'' └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
|
|
cardLockID := locknew 'frida
|
|
|
|
'debugverbindung
|
|
'debugx.start(115200) ' Start des Debug-Terminals
|
|
|
|
slowTiming := ((constant(250_000 << 12) / clkfreq) << 20)
|
|
fastTiming := ((constant(2_500_000 << 8) / clkfreq) << 24)
|
|
|
|
CCFAddress := @cardCommandFlag
|
|
CEFAddress := @cardErrorFlag
|
|
|
|
CDBAddress := @cardDataBlockAddress
|
|
CSAAddress := @cardSectorAddress
|
|
|
|
CUIDAddress := @cardUniqueID
|
|
return cognew(@initialization, @cardSectorCount)
|
|
|
|
PRI listDuplicate(entryName) ' 27 Stack Longs
|
|
|
|
closeFile
|
|
listReset
|
|
|
|
repeat
|
|
|
|
result := listDirectory("R")
|
|
|
|
if(strcomp(result, entryName))
|
|
|
|
if(listIsDirectory)
|
|
' abort string("Directory Already Exist") '@hive
|
|
abort err_dirAlreadyExist
|
|
|
|
' abort string("File Already Exist") '@hive
|
|
abort err_fileAlreadyExist
|
|
|
|
while(result)
|
|
|
|
{
|
|
PRI listFind(entryName, errorMessage) ' 28 Stack Longs '@hive
|
|
|
|
closeFile
|
|
listReset
|
|
|
|
repeat
|
|
|
|
result := listDirectory("R")
|
|
|
|
ifnot(result)
|
|
abort errorMessage
|
|
|
|
until(strcomp(entryName, result))
|
|
|
|
currentByte -= 32
|
|
}
|
|
|
|
PRI listFind(entryName, errorMessage) | strptr ' 28 Stack Longs
|
|
|
|
closeFile
|
|
listReset
|
|
|
|
repeat
|
|
result := err_noError
|
|
strptr := listDirectory("R")
|
|
|
|
ifnot(strptr)
|
|
abort errorMessage
|
|
|
|
until(strcomp(entryName, strptr))
|
|
|
|
currentByte -= 32
|
|
|
|
PRI listNew(entryName, entryAttributes, entryDate, entryTime, entryCluster, entryType) ' 36 Stack Longs
|
|
|
|
listDuplicate(entryName)
|
|
listReset
|
|
|
|
repeat while(readWriteCurrentCluster("W", "D"))
|
|
|
|
if((blockToByte(currentByte) <> $E5) and blockToByte(currentByte))
|
|
currentByte += 32
|
|
|
|
else
|
|
|
|
if(entryType == "D")
|
|
entryCluster := createClusterChain(0)
|
|
currentFile := entryCluster
|
|
readWriteCurrentSector("R")
|
|
|
|
bytefill(@dataBlock[currentByte & $1FF], 0, 32)
|
|
bytemove(@dataBlock[currentByte & $1FF], entryName, 11)
|
|
|
|
byteToBlock((currentByte + 11), entryAttributes)
|
|
|
|
wordToBlock((currentByte + 14), entryTime)
|
|
wordToBlock((currentByte + 16), entryDate)
|
|
wordToBlock((currentByte + 18), entryDate)
|
|
wordToBlock((currentByte + 22), entryTime)
|
|
wordToBlock((currentByte + 24), entryDate)
|
|
|
|
wordToBlock((currentByte + 26), (entryCluster & $FFFF))
|
|
wordToBlock((currentByte + 20), (entryCluster >> 16))
|
|
|
|
readWriteCurrentSector("W")
|
|
return entryName
|
|
|
|
' abort string("Directory Is Full") '@hive
|
|
abort err_dirIsFull
|
|
|
|
PRI listDirectory(volumeIDAttribute) ' 23 Stack Longs
|
|
|
|
if(fileOpenFlag)
|
|
closeFile
|
|
'listReset 'frida
|
|
|
|
repeat while(readWriteCurrentCluster("R", "D") and blockToByte(currentByte))
|
|
|
|
if((blockToByte(currentByte) == $E5) or (((volumeIDAttribute == "V") ^ blockToByte(currentByte + 11)) & $8))
|
|
currentByte += 32
|
|
|
|
else
|
|
|
|
bytemove(@directoryEntry, @dataBlock[currentByte & $1FF], 32)
|
|
bytemove(@directoryEntryName, @directoryEntry, 11)
|
|
|
|
if(directoryEntryName == $5)
|
|
directoryEntryName := $E5
|
|
|
|
currentByte += 32
|
|
return @directoryEntryName
|
|
|
|
listReset
|
|
|
|
PRI listCluster ' 3 Stack Longs
|
|
|
|
result := directoryEntry[26]
|
|
result.byte[1] := directoryEntry[27]
|
|
result.byte[2] := directoryEntry[20]
|
|
result.byte[3] := directoryEntry[21]
|
|
|
|
if((result == 1) or (FATEndOfClusterValue =< result))
|
|
' abort @FSCorrupted '@hive
|
|
abort err_fsysCorrupted
|
|
|
|
PRI listCase(unformatedName, formatedName) ' 5 Stack Longs
|
|
|
|
if(byte[unformatedName++] == ".")
|
|
result := @dot
|
|
|
|
if(byte[unformatedName++] == ".")
|
|
result := @dotdot
|
|
|
|
repeat strsize(unformatedName)
|
|
case byte[unformatedName++]
|
|
9 .. 10, 13, 32:
|
|
other:
|
|
result := formatedName
|
|
quit
|
|
|
|
PRI readWriteCurrentCluster(readWrite, fileOrDirectory) ' 19 Stack Longs
|
|
|
|
ifnot((fileOrDirectory <> "D") or partitionMountedFlag)
|
|
' abort @FSUnmounted '@hive
|
|
abort err_fsysUnmounted
|
|
|
|
'Needs to return true if it got the data and false if it didn't.
|
|
|
|
ifnot(currentByte & $1FF)
|
|
|
|
if(fileOpenFlag and (currentByte => $7FFFFE00))
|
|
return false 'abort string("End of File")
|
|
|
|
ifnot(fileOpenFlag or (currentByte < constant(65536 * 32)))
|
|
return false 'abort string("End of Directory")
|
|
|
|
ifnot(currentcluster or FATType or ((currentByte >> 9) < rootDirectorySectors))
|
|
return false 'abort string("End of Root")
|
|
|
|
if(currentByte and (not(FATWorkingSectorInCluster)) and (FATType or currentcluster))
|
|
|
|
result := currentCluster
|
|
ifnot(result)
|
|
result := rootCluster
|
|
|
|
readWriteFATBlock(result, "R")
|
|
fileOrDirectory := readFATEntry(result)
|
|
|
|
if(fileOrDirectory =< 1)
|
|
partitionMountedFlag := false
|
|
' abort @FSCorrupted '@hive
|
|
abort err_fsysCorrupted
|
|
|
|
if(fileOrDirectory => FATEndOfClusterValue)
|
|
'if(fileOpenFlag and (currentByte < (currentSize - 1)))
|
|
' partitionMountedFlag := false
|
|
' abort @FSCorrupted
|
|
|
|
if(readWrite == "R")
|
|
ifnot(fileOpenFlag)
|
|
ifnot(currentCluster)
|
|
' abort string("End of Root") '@hive
|
|
abort err_endOfRoot
|
|
|
|
' abort string("End of Directory") '@hive
|
|
abort err_endOfDirectory
|
|
|
|
else
|
|
' abort string("End of File") '@hive
|
|
abort err_endOfFile
|
|
|
|
fileOrDirectory := createClusterChain(result)
|
|
currentCluster := fileOrDirectory
|
|
readWriteCurrentSector("R")
|
|
|
|
return true
|
|
|
|
PRI readWriteCurrentSector(readWrite) ' 9 Stack Longs
|
|
|
|
result := FATFirstSectorInCluster(currentCluster) + FATWorkingSectorInCluster
|
|
|
|
ifnot(currentCluster)
|
|
result := rootDirectorySectorNumber + (currentByte >> 9)
|
|
|
|
if(FATType)
|
|
result := FATFirstSectorInCluster(rootCluster) + FATWorkingSectorInCluster
|
|
|
|
readWriteBlock(result, readWrite)
|
|
|
|
PRI findByte(byteToCompare, thisByte, thatByte) ' 6 Stack Longs
|
|
|
|
if((byteToCompare == thisByte) or (byteToCompare == thatByte))
|
|
return true
|
|
|
|
PRI findCharacter(charactersToSearch, characterToFind) | convertedCharacter ' 6 Stack Longs
|
|
|
|
repeat strsize(charactersToSearch)
|
|
|
|
convertedCharacter := byte[charactersToSearch++]
|
|
case convertedCharacter
|
|
"a" .. "z": convertedCharacter -= 32
|
|
|
|
if(convertedCharacter == characterToFind)
|
|
return true
|
|
|
|
PRI unformatName(name) ' 4 Stack Longs
|
|
|
|
if(name)
|
|
|
|
unformatedNameBuffer[12] := 0
|
|
|
|
bytefill(@unformatedNameBuffer, " ", 12)
|
|
bytemove(@unformatedNameBuffer, name, 8)
|
|
|
|
repeat while(unformatedNameBuffer[++result] <> " ")
|
|
unformatedNameBuffer[result++] := "."
|
|
|
|
bytemove(@unformatedNameBuffer[result], @byte[name][8], 3)
|
|
|
|
if(unformatedNameBuffer[result] == " ")
|
|
unformatedNameBuffer[--result] := " "
|
|
|
|
return @unformatedNameBuffer
|
|
|
|
PRI formatName(name) ' 4 Stack Longs
|
|
|
|
formatedNameBuffer[11] := 0
|
|
|
|
bytefill(@formatedNameBuffer, " ", 11)
|
|
|
|
repeat strsize(name--)
|
|
|
|
if(byte[++name] == ".")
|
|
result := 0
|
|
|
|
repeat strsize(++name)
|
|
|
|
if((result < 3) and (byte[name] > 31))
|
|
formatedNameBuffer[8 + result++] := byte[name++]
|
|
|
|
quit
|
|
|
|
if((result < 8) and (byte[name] > 31))
|
|
formatedNameBuffer[result++] := byte[name]
|
|
|
|
repeat result from 0 to 10
|
|
|
|
case formatedNameBuffer[result]
|
|
"a" .. "z": formatedNameBuffer[result] -= 32
|
|
$22, "*" .. ",", "." .. "/", ":" .. "?", "[" .. "]", "|", $7F: formatedNameBuffer[result] := "_"
|
|
|
|
if(formatedNameBuffer == " ")
|
|
formatedNameBuffer := "_"
|
|
|
|
if(formatedNameBuffer == $E5)
|
|
formatedNameBuffer := $5
|
|
|
|
return @formatedNameBuffer
|
|
|
|
PRI createClusterChain(clusterToLink) ' 14 Stack Longs
|
|
|
|
readWriteFATBlock(nextFreeCluster, "R")
|
|
repeat result from nextFreeCluster to (countOfClusters + 1)
|
|
|
|
ifnot(FATEntryNumber(result))
|
|
readWriteFATBlock(result, "R")
|
|
|
|
ifnot(readFATEntry(result))
|
|
|
|
writeFATEntry(result, true)
|
|
readWriteFATBlock(result, "W")
|
|
|
|
nextFreeCluster := ((result + 1) <# (countOfClusters + 1))
|
|
|
|
if(clusterToLink)
|
|
|
|
readWriteFATBlock(clusterToLink, "R")
|
|
writeFATEntry(clusterToLink, result)
|
|
readWriteFATBlock(clusterToLink, "W")
|
|
|
|
bytefill(@dataBlock, 0, 512)
|
|
|
|
repeat clusterToLink from 0 to (sectorsPerCluster - 1)
|
|
readWriteBlock((FATFirstSectorInCluster(result) + clusterToLink), "W")
|
|
|
|
quit
|
|
|
|
if(result => (countOfClusters + 1))
|
|
' abort string("Out Of Disk Free Space") '@hive
|
|
abort err_outOfDiskFreeSpace
|
|
|
|
PRI destroyClusterChain(clusterToDestroy) ' 14 Stack Longs
|
|
|
|
repeat while((1 < clusterToDestroy) and (clusterToDestroy < FATEndOfClusterValue))
|
|
|
|
ifnot(result and (FATBlockNumber(result) == FATBlockNumber(clusterToDestroy)))
|
|
readWriteFATBlock(clusterToDestroy, "R")
|
|
|
|
result := clusterToDestroy
|
|
clusterToDestroy := readFATEntry(clusterToDestroy)
|
|
writeFATEntry(result, false)
|
|
|
|
if(FATBlockNumber(result) <> FATBlockNumber(clusterToDestroy))
|
|
readWriteFATBlock(result, "W")
|
|
|
|
if(result)
|
|
readWriteFATBlock(result, "W")
|
|
|
|
PRI readFATEntry(cluster) ' 8 Stack Longs
|
|
|
|
cluster := FATEntryNumber(cluster)
|
|
|
|
ifnot(FATType)
|
|
return blockToWord(cluster)
|
|
|
|
return (blockTolong(cluster) & $0FFFFFFF)
|
|
|
|
PRI writeFATEntry(cluster, value) ' 10 Stack Longs
|
|
|
|
cluster := FATEntryNumber(cluster)
|
|
|
|
ifnot(FATType)
|
|
wordToBlock(cluster, value)
|
|
else
|
|
longToBlock(cluster, ((value & $0FFFFFFF) | (blockTolong(cluster) & $F0000000)))
|
|
|
|
PRI readWriteFATBlock(cluster, readWrite) ' 10 Stack Longs
|
|
|
|
cluster := FATBlockNumber(cluster)
|
|
result := externalFlags
|
|
|
|
repeat ((numberOfFATs & (readWrite == "W")) | (-(readWrite == "R")))
|
|
readWriteBlock((reservedSectorCount + cluster + (FATSectorSize * result++)), readWrite)
|
|
|
|
PRI FATBlockNumber(cluster) ' 4 Stack Longs
|
|
|
|
return (cluster >> (8 + FATType))
|
|
|
|
PRI FATEntryNumber(cluster) ' 4 Stack Longs
|
|
|
|
return ((cluster & ($FF >> (-FATType))) << (1 - FATType))
|
|
|
|
PRI FATEndOfClusterValue ' 3 Stack Longs
|
|
|
|
return ($FFF0 | (FATType & $0FFFFFF0))
|
|
|
|
PRI FATWorkingSectorInCluster ' 3 Stack Longs
|
|
|
|
return ((currentByte >> 9) // sectorsPerCluster)
|
|
|
|
PRI FATFirstSectorInCluster(cluster) ' 4 Stack Longs
|
|
|
|
return (((cluster - 2) * sectorsPerCluster) + firstDataSector)
|
|
|
|
PRI blockToLong(index) ' 4 Stack Longs
|
|
|
|
bytemove(@result, @dataBlock[index & $1FF], 4)
|
|
|
|
PRI blockToWord(index) ' 4 Stack Longs
|
|
|
|
bytemove(@result, @dataBlock[index & $1FF], 2)
|
|
|
|
PRI blockToByte(index) ' 4 Stack Longs
|
|
|
|
return dataBlock[index & $1FF]
|
|
|
|
PRI longToBlock(index, value) ' 5 Stack Longs
|
|
|
|
bytemove(@dataBlock[index & $1FF], @value, 4)
|
|
|
|
PRI wordToBlock(index, value) ' 5 Stack Longs
|
|
|
|
bytemove(@dataBlock[index & $1FF], @value, 2)
|
|
|
|
PRI byteToBlock(index, value) ' 5 Stack Longs
|
|
|
|
dataBlock[index & $1FF] := value
|
|
|
|
PRI readClock ' 3 + 11 Stack Longs
|
|
|
|
repeat while(lockset(cardLockID))
|
|
cardTime := ((rtc.getSeconds >> 1) | (rtc.getMinutes << 5) | (rtc.getHours << 11))
|
|
cardDate := (rtc.getDate | (rtc.getMonth << 5) | ((rtc.getYear - 1980) << 9))
|
|
|
|
lockclr(cardLockID)
|
|
return cardDate
|
|
|
|
PRI readWriteBlock(address, command) ' 5 Stack Longs
|
|
|
|
if(strcomp(@cardUniqueID, @cardUniqueIDCopy) or (command == "M"))
|
|
repeat while(lockset(cardLockID))
|
|
|
|
if command == "B" 'frida
|
|
lockclr(cardLockID) 'frida
|
|
lockret(cardLockID) 'frida
|
|
|
|
cardSectorAddress := (address + (partitionStart & (command <> "B")))
|
|
cardDataBlockAddress := (@dataBlock & (command <> "B"))
|
|
cardCommandFlag := command
|
|
repeat while(cardCommandFlag)
|
|
|
|
command := cardErrorFlag~
|
|
lockclr(cardLockID)
|
|
|
|
if(command)
|
|
partitionMountedFlag := false
|
|
' abort string("Disk I/O Error") '@hive
|
|
abort err_diskIOError
|
|
|
|
DAT 'ASM-Code
|
|
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
' SD/SDHC/MMC Driver
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
org
|
|
|
|
' //////////////////////Initialization/////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
initialization neg phsa, #1 ' Setup clock counter.
|
|
movs ctra, #((Clock_Pin <# 31) #> 0) '
|
|
movi ctra, #%0_00100_000 '
|
|
|
|
mov outa, chipSelectPin ' Setup I/O Pins.
|
|
or outa, dataInPin '
|
|
mov dira, chipSelectPin '
|
|
or dira, dataInPin '
|
|
or dira, clockPin '
|
|
|
|
mov cardCounter, fiveHundredAndTwelve ' Skip to instruction handle.
|
|
jmp #instructionWait '
|
|
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
' Command Center
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
instructionRetry cmp cardBuffer, #"M" wc, wz ' Try at most 8 more times to mount the card.
|
|
if_c cmp cardBuffer, #"F" wc, wz '
|
|
if_nc_or_z djnz cardBuffer, #mountCard '
|
|
|
|
cmp cardBuffer, #"R" wz ' Try at most twice to read the specified block.
|
|
if_z djnz cardBuffer, #readBlock '
|
|
|
|
cmp cardBuffer, #"W" wz ' Try at most twice to write the specified block.
|
|
if_z djnz cardBuffer, #writeBlock '
|
|
|
|
cmp cardBuffer, #"B" wz ' Reboot the chip if booting failure.
|
|
if_z mov buffer, #$80 '
|
|
if_z clkset buffer '
|
|
|
|
instructionError wrbyte maxPositiveInteger, CEFAddress ' Assert Error Flag and unmount card.
|
|
instructionUnmount mov cardMounted, #0 '
|
|
|
|
' //////////////////////Instruction Handle/////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
instructionLoop wrbyte fiveHundredAndTwelve, CCFAddress ' Wait for a command to come.
|
|
instructionWait rdbyte cardBuffer, CCFAddress '
|
|
test cardMounted, maxPositiveInteger wc '
|
|
|
|
cmp cardBuffer, #"B" wz ' If rebooting was requested do it.
|
|
if_z_and_nc jmp #instructionError '
|
|
if_z_and_c jmp #rebootChip '
|
|
|
|
cmp cardBuffer, #"R" wz ' If read block was requested do it.
|
|
if_z_and_nc jmp #instructionError '
|
|
if_z_and_c jmp #readBlock '
|
|
|
|
cmp cardBuffer, #"W" wz ' If write block was requested do it.
|
|
if_z_and_nc jmp #instructionError '
|
|
if_z_and_c jmp #writeBlock '
|
|
|
|
djnz cardCounter, #instructionSkip ' Poll the card every so often.
|
|
mov cardCounter, fiveHundredAndTwelve '
|
|
if_nc jmp #instructionSkip '
|
|
call #cardStatus '
|
|
|
|
instructionSkip cmp cardBuffer, #"M" wz ' If mounting was requested do it.
|
|
if_nz jmp #instructionWait '
|
|
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
' Mount Card
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
mountCard mov SPITiming, slowTiming ' Setup SPI parameters.
|
|
|
|
mov counter, #80 ' Send out for more than 1 millisecond.
|
|
seventyFourClocks call #readSPI '
|
|
djnz counter, #seventyFourClocks '
|
|
|
|
' //////////////////////Go Idle State//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
mov counter, #80 ' Setup counter to try a few times.
|
|
|
|
enterIdleStateLoop mov SPICommandOut, #($40 | 0) ' Send out command 0.
|
|
mov SPIParameterOut, #0 '
|
|
movs commandSPICRC, #$95 '
|
|
call #commandSPI '
|
|
call #shutdownSPI '
|
|
|
|
cmp SPIResponceIn, #1 wz ' Try a few times.
|
|
if_nz djnz counter, #enterIdleStateLoop '
|
|
tjz counter, #instructionRetry '
|
|
|
|
' //////////////////////Send Interface Condition///////////////////////////////////////////////////////////////////////////////
|
|
|
|
mov SPICommandOut, #($40 | 8) ' Send out command 8.
|
|
mov SPIParameterOut, #$1AA '
|
|
movs commandSPICRC, #$87 '
|
|
call #commandSPI '
|
|
call #longSPI '
|
|
call #shutdownSPI '
|
|
|
|
test SPIResponceIn, #$7E wz ' If failure goto SD 1.X initialization.
|
|
if_nz jmp #exitIdleState_SD '
|
|
|
|
and SPILongIn, #$1FF ' SD 2.0 initialization.
|
|
cmp SPILongIn, #$1AA wz '
|
|
if_nz jmp #instructionRetry '
|
|
|
|
' //////////////////////Send Operating Condition///////////////////////////////////////////////////////////////////////////////
|
|
|
|
exitIdleState_SD mov cardType, #0 ' Card type is MMC.
|
|
|
|
mov counter, #80 ' Setup counter to try a few times.
|
|
|
|
exitIdleStateLoop_SD mov SPICommandOut, #($40 | 55) ' Send out command 55.
|
|
mov SPIParameterOut, #0 '
|
|
call #commandSPI '
|
|
call #shutdownSPI '
|
|
|
|
test SPIResponceIn, #$7E wz ' If failure goto MMC initialization. '
|
|
if_nz jmp #exitIdleState_MMC '
|
|
|
|
mov SPICommandOut, #($40 | 41) ' Send out command 41 with HCS bit set.
|
|
mov SPIParameterOut, HCSBitMask '
|
|
call #commandSPI '
|
|
call #shutdownSPI '
|
|
|
|
cmp SPIResponceIn, #0 wz ' Try a few times.
|
|
if_nz djnz counter, #exitIdleStateLoop_SD '
|
|
tjz counter, #instructionRetry '
|
|
|
|
djnz cardType, #readOCR ' Card type is SD and skip MMC initialization.
|
|
|
|
' //////////////////////Send Operating Condition///////////////////////////////////////////////////////////////////////////////
|
|
|
|
exitIdleState_MMC mov counter, #80 ' Setup counter to try a few times.
|
|
|
|
exitIdleStateLoop_MMC mov SPICommandOut, #($40 | 1) ' Send out command 1.
|
|
mov SPIParameterOut, #0 '
|
|
call #commandSPI '
|
|
call #shutdownSPI '
|
|
|
|
cmp SPIResponceIn, #0 wz ' Try a few times.
|
|
if_nz djnz counter, #exitIdleStateLoop_MMC '
|
|
tjz counter, #instructionRetry '
|
|
|
|
' //////////////////////Read OCR Register//////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
readOCR mov SPICommandOut, #($40 | 58) ' Ask the card for its OCR register.
|
|
mov SPIParameterOut, #0 '
|
|
call #commandSPI '
|
|
call #longSPI '
|
|
call #shutdownSPI '
|
|
|
|
tjnz SPIResponceIn, #instructionRetry ' If failure abort.
|
|
|
|
test SPILongIn, OCRCheckMask wz ' If voltage not supported abort.
|
|
shl SPILongIn, #1 wc '
|
|
if_z_or_nc jmp #instructionRetry '
|
|
|
|
shl SPILongIn, #1 wc ' SDHC supported or not.
|
|
if_c mov SPIShift, #0 '
|
|
if_nc mov SPIShift, #9 '
|
|
|
|
' //////////////////////Set Block Length///////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
mov SPICommandOut, #($40 | 16) ' Send out command 16.
|
|
mov SPIParameterOut, fiveHundredAndTwelve '
|
|
call #commandSPI '
|
|
call #shutdownSPI '
|
|
|
|
tjnz SPIResponceIn, #instructionRetry ' If failure abort.
|
|
|
|
' //////////////////////Read CSD Register//////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
mov SPICommandOut, #($40 | 9) ' Ask the card for its CSD register.
|
|
mov SPIParameterOut, #0 '
|
|
call #commandSPI '
|
|
|
|
tjnz SPIResponceIn, #instructionRetry ' If failure abort.
|
|
call #repsonceSPI '
|
|
cmp SPIResponceIn, #$FE wz '
|
|
if_nz jmp #instructionRetry '
|
|
|
|
mov counter, #16 ' Setup to read the CSD register.
|
|
movd readCSDModify, #CSDRegister '
|
|
|
|
readCSDLoop call #readSPI ' Read the CSD register in.
|
|
readCSDModify mov 0, SPIDataIn '
|
|
add readCSDModify, fiveHundredAndTwelve '
|
|
djnz counter, #readCSDLoop '
|
|
|
|
call #wordSPI ' Shutdown SPI clock.
|
|
call #shutdownSPI '
|
|
|
|
' //////////////////////Read CID Register//////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
mov SPICommandOut, #($40 | 10) ' Ask the card for its CID register.
|
|
mov SPIParameterOut, #0 '
|
|
call #commandSPI '
|
|
|
|
tjnz SPIResponceIn, #instructionRetry ' If failure abort.
|
|
call #repsonceSPI '
|
|
cmp SPIResponceIn, #$FE wz '
|
|
if_nz jmp #instructionRetry '
|
|
|
|
mov counter, #16 ' Setup to read the CID register.
|
|
mov buffer, CUIDAddress '
|
|
|
|
readCIDLoop call #readSPI ' Read the CID register in.
|
|
wrbyte SPIDataIn, buffer '
|
|
add buffer, #1 '
|
|
djnz counter, #readCIDLoop '
|
|
|
|
wrbyte fiveHundredAndTwelve, buffer ' Clear the last byte for string compare.
|
|
|
|
call #wordSPI ' Shutdown SPI clock.
|
|
call #shutdownSPI '
|
|
|
|
' //////////////////////Setup Card Variables///////////////////////////////////////////////////////////////////////////////////
|
|
|
|
mov SPITiming, fastTiming ' Setup SPI parameters.
|
|
|
|
testn cardType, #0 wz, wc ' Determine CSD structure version.
|
|
if_nz test CSDRegister, #$40 wc '
|
|
if_nz test CSDRegister, #$80 wz '
|
|
|
|
if_nc_and_z mov counter, (CSDRegister + 6) ' Extract card size.
|
|
if_nc_and_z and counter, #$3 '
|
|
if_nc_and_z shl counter, #10 '
|
|
if_nc_and_z mov buffer, (CSDRegister + 7) '
|
|
if_nc_and_z shl buffer, #2 '
|
|
if_nc_and_z mov cardSize, (CSDRegister + 8) '
|
|
if_nc_and_z shr cardSize, #6 '
|
|
if_nc_and_z or cardSize, counter '
|
|
if_nc_and_z or cardSize, buffer '
|
|
|
|
if_c_and_z mov counter, (CSDRegister + 7) ' Extract card size.
|
|
if_c_and_z and counter, #$3F '
|
|
if_c_and_z shl counter, #16 '
|
|
if_c_and_z mov buffer, (CSDRegister + 8) '
|
|
if_c_and_z shl buffer, #8 '
|
|
if_c_and_z mov cardSize, (CSDRegister + 9) '
|
|
if_c_and_z or cardSize, counter '
|
|
if_c_and_z or cardSize, buffer '
|
|
|
|
if_nc_and_z mov buffer, (CSDRegister + 9) ' Extract card size multiplier.
|
|
if_nc_and_z and buffer, #$3 '
|
|
if_nc_and_z shl buffer, #1 '
|
|
if_nc_and_z mov cardSizeMultiplier, (CSDRegister + 10) '
|
|
if_nc_and_z shr cardSizeMultiplier, #7 '
|
|
if_nc_and_z or cardSizeMultiplier, buffer '
|
|
|
|
if_nc_and_z mov cardReadBlockLength, (CSDRegister + 5) ' Extract read block length.
|
|
if_nc_and_z and cardReadBlockLength, #$F '
|
|
|
|
if_nc_and_z sub cardReadBlockLength, #9 ' Compute card sector count for version 1.0 CSD.
|
|
if_nc_and_z add cardSizeMultiplier, #2 '
|
|
if_z add cardSize, #1 '
|
|
if_nc_and_z shl cardSize, cardReadBlockLength '
|
|
if_nc_and_z shl cardSize, cardSizeMultiplier '
|
|
|
|
if_c_and_z shl cardSize, #10 ' Compute card sector count for version 2.0 CSD.
|
|
|
|
max cardSize, maxPositiveInteger ' Limit maximum partition size.
|
|
|
|
if_nz neg cardSize, #1 ' Unknown CSD structure. Card size to -1.
|
|
|
|
wrlong cardSize, par ' Update Card Size.
|
|
|
|
mov cardSizeMinusOne, cardSize ' Compute maximum allowed addressable sector.
|
|
sub cardSizeMinusOne, #1 '
|
|
|
|
neg cardMounted, #1 ' Return.
|
|
jmp #instructionLoop '
|
|
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
' Read Block
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
readBlock rdlong SPIParameterOut, CSAAddress ' Read a block.
|
|
max SPIParameterOut, cardSizeMinusOne '
|
|
shl SPIParameterOut, SPIShift '
|
|
mov SPICommandOut, #($40 | 17) '
|
|
call #commandSPI '
|
|
|
|
tjnz SPIResponceIn, #instructionRetry ' If failure abort.
|
|
call #repsonceSPI '
|
|
cmp SPIResponceIn, #$FE wz '
|
|
if_nz jmp #instructionRetry '
|
|
|
|
mov counter, fiveHundredAndTwelve ' Setup loop.
|
|
readBlockModify rdlong buffer, CDBAddress '
|
|
|
|
readBlockLoop call #readSPI ' Read data into memory.
|
|
wrbyte SPIDataIn, buffer '
|
|
add buffer, #1 '
|
|
djnz counter, #readBlockLoop '
|
|
|
|
call #wordSPI ' Shutdown SPI clock.
|
|
call #shutdownSPI '
|
|
|
|
readBlock_ret jmp #instructionLoop ' Return. Become RET instruction when rebooting.
|
|
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
' Write Block
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
writeBlock rdlong SPIParameterOut, CSAAddress ' Write a block.
|
|
max SPIParameterOut, cardSizeMinusOne '
|
|
shl SPIParameterOut, SPIShift '
|
|
mov SPICommandOut, #($40 | 24) '
|
|
call #commandSPI '
|
|
|
|
tjnz SPIResponceIn, #instructionRetry ' If failure abort.
|
|
|
|
mov SPIDataOut, #$FE ' Send start of data token.
|
|
call #writeSPI '
|
|
|
|
mov counter, fiveHundredAndTwelve ' Setup loop.
|
|
rdlong buffer, CDBAddress '
|
|
|
|
writeBlockLoop rdbyte SPIDataOut, buffer ' Write data out from memory.
|
|
add buffer, #1 '
|
|
call #writeSPI '
|
|
djnz counter, #writeBlockLoop '
|
|
|
|
call #wordSPI ' Write out the 16 bit CRC.
|
|
|
|
call #repsonceSPI ' If failure abort.
|
|
and SPIDataIn, #$1F '
|
|
cmp SPIDataIn, #$5 wz '
|
|
if_nz jmp #instructionRetry '
|
|
|
|
call #cardBusy ' Shutdown SPI clock.
|
|
call #shutdownSPI '
|
|
|
|
jmp #instructionLoop ' Return.
|
|
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
' Reboot Chip
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
rebootChip rdlong buffer, CDBAddress ' Check to make sure a reboot was requested.
|
|
tjnz buffer, #instructionError '
|
|
|
|
' //////////////////////Shutdown Cogs//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
mov counter, #8 ' Setup cog stop loop.
|
|
cogid buffer '
|
|
|
|
rebootCogLoop sub counter, #1 ' Stop all cogs but this one.
|
|
cmp counter, buffer wz '
|
|
if_nz cogstop counter '
|
|
tjnz counter, #rebootCogLoop '
|
|
|
|
' //////////////////////Setup Memory///////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
mov counter, #64 ' Setup to grab all sector addresses.
|
|
rdlong buffer, CSAAddress '
|
|
|
|
rebootSectorLoadLoop rdlong cardRebootSectors, buffer ' Get all addresses of the 64 sectors of new code into memory.
|
|
add buffer, #4 '
|
|
add rebootSectorLoadLoop, fiveHundredAndTwelve '
|
|
djnz counter, #rebootSectorLoadLoop '
|
|
|
|
' //////////////////////Clear Memory///////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
mov counter, fiveHundredAndTwelve ' Clear all memory. Leave buffer the pointer at 0.
|
|
shl counter, #6 '
|
|
mov buffer, #0 '
|
|
rebootCodeClearLoop sub counter, #4 '
|
|
wrlong buffer, counter '
|
|
tjnz counter, #rebootCodeClearLoop '
|
|
|
|
' //////////////////////Fill Memory////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
mov readBlock, #0 ' Fill these two commands with NOPs.
|
|
mov readBlockModify, #0 '
|
|
|
|
mov cardCounter, #64 ' Ready to fill all memory. Pointer already at 0.
|
|
|
|
rebootCodeFillLoop mov SPIParameterOut, cardRebootSectors ' Reuse read block code. Finish if next sector is 0.
|
|
tjz SPIParameterOut, #rebootReady '
|
|
add rebootCodeFillLoop, #1 '
|
|
call #readBlock '
|
|
djnz cardCounter, #rebootCodeFillLoop '
|
|
|
|
' //////////////////////Boot Interpreter///////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
rebootReady rdword buffer, #$A ' Setup the stack markers.
|
|
sub buffer, #4 '
|
|
wrlong rebootStackMark, buffer '
|
|
sub buffer, #4 '
|
|
wrlong rebootStackMark, buffer '
|
|
|
|
rdbyte buffer, #$4 ' Switch to new clock mode.
|
|
clkset buffer '
|
|
|
|
coginit rebootInterpreter ' Restart running new code.
|
|
|
|
cogid buffer ' Shutdown.
|
|
cogstop buffer '
|
|
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
' Card Status
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
cardStatus mov SPICommandOut, #($40 | 13) ' Send out command 13.
|
|
mov SPIParameterOut, #0 '
|
|
call #commandSPI '
|
|
call #byteSPI '
|
|
call #shutdownSPI '
|
|
|
|
tjnz SPIResponceIn, #instructionUnmount ' If failure abort.
|
|
tjnz SPILongIn, #instructionUnmount '
|
|
|
|
cardStatus_ret ret ' Return.
|
|
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
' Card Busy
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
cardBusy mov counter, writeTimeout ' Setup loop.
|
|
|
|
cardBusyLoop call #readSPI ' Wait until card is not busy.
|
|
cmp SPIDataIn, #0 wz '
|
|
if_z djnz counter, #cardBusyLoop '
|
|
tjz counter, #instructionRetry '
|
|
|
|
cardBusy_ret ret ' Return.
|
|
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
' Command SPI
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
commandSPI andn outa, chipSelectPin ' Activate the SPI bus.
|
|
call #readSPI '
|
|
|
|
mov SPIDataOut, SPICommandOut ' Send out command.
|
|
call #writeSPI '
|
|
|
|
movs writeSPI, #32 ' Send out parameter.
|
|
mov SPIDataOut, SPIParameterOut '
|
|
call #writeSPI '
|
|
movs writeSPI, #8 '
|
|
|
|
commandSPICRC mov SPIDataOut, #0 ' Send out CRC token.
|
|
call #writeSPI '
|
|
|
|
call #repsonceSPI ' Read in responce.
|
|
|
|
commandSPI_ret ret ' Return.
|
|
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
' Responce SPI
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
repsonceSPI mov SPIResponceIn, readTimeout ' Setup responce poll counter.
|
|
|
|
repsonceSPILoop call #readSPI ' Poll for responce.
|
|
cmp SPIDataIn, #$FF wz '
|
|
if_z djnz SPIResponceIn, #repsonceSPILoop '
|
|
|
|
mov SPIResponceIn, SPIDataIn ' Move responce into return value.
|
|
|
|
repsonceSPI_ret ret ' Return.
|
|
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
' Long SPI
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
longSPI add readSPI, #16 ' Read in 32, 16, or 8 bits.
|
|
wordSPI add readSPI, #8 '
|
|
byteSPI call #readSPI '
|
|
movs readSPI, #8 '
|
|
|
|
mov SPILongIn, SPIDataIn ' Move long into return value.
|
|
|
|
byteSPI_ret ' Return.
|
|
wordSPI_ret '
|
|
longSPI_ret ret '
|
|
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
' Shutdown SPI
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
shutdownSPI call #readSPI ' Shutdown SPI bus.
|
|
or outa, chipSelectPin '
|
|
call #readSPI '
|
|
|
|
shutdownSPI_ret ret ' Return.
|
|
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
' Read SPI
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
readSPI mov SPICounter, #8 ' Setup counter to read in 1 - 32 bits. Default 8.
|
|
mov SPIDataIn, #0 wc '
|
|
|
|
mov phsa, #0 ' Start clock low.
|
|
mov frqa, SPITiming '
|
|
|
|
readSPILoop waitpne clockPin, clockPin ' Get bit.
|
|
rcl SPIDataIn, #1 '
|
|
waitpeq clockPin, clockPin '
|
|
test dataOutPin, ina wc '
|
|
|
|
djnz SPICounter, #readSPILoop ' Loop
|
|
|
|
mov frqa, #0 ' Stop clock high.
|
|
rcl SPIDataIn, #1 '
|
|
|
|
readSPI_ret ret ' Return.
|
|
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
' Write SPI
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
writeSPI mov SPICounter, #8 ' Setup counter to write out 1 - 32 bits. Default 8.
|
|
ror SPIDataOut, SPICounter '
|
|
|
|
mov phsa, #0 ' Start clock low.
|
|
mov frqa, SPITiming '
|
|
|
|
writeSPILoop shl SPIDataOut, #1 wc ' Set bit.
|
|
waitpne clockPin, clockPin '
|
|
muxc outa, dataInPin '
|
|
waitpeq clockPin, clockPin '
|
|
|
|
djnz SPICounter, #writeSPILoop ' Loop.
|
|
|
|
mov frqa, #0 ' Stop clock high.
|
|
or outa, dataInPin '
|
|
|
|
writeSPI_ret ret ' Return.
|
|
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
' CRC7 Augmentation
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
CRC7 mov CRCCounter, #7 ' Get variables ready.
|
|
|
|
CRC7Loop shl CRCBuffer, #1 ' Do the CRC7 calculation.
|
|
test CRCBuffer, #$80 wc '
|
|
if_c xor CRCBuffer, #$9 '
|
|
djnz CRCCounter, #CRC7Loop '
|
|
|
|
CRC7_ret ret ' Return.
|
|
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
' CRC16 Augmentation
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
CRC16 mov CRCCounter, #16 ' Get variables ready.
|
|
|
|
CRC16Loop shl CRCBuffer, #1 ' Do the CRC16 calculation.
|
|
test CRCBuffer, CRC16TestBit wc '
|
|
if_c xor CRCBuffer, CRC16Polynomial '
|
|
djnz CRCCounter, #CRC16Loop '
|
|
|
|
CRC16_ret ret ' Return.
|
|
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
' Data
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
cardMounted long 0
|
|
|
|
' //////////////////////Constants//////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
fiveHundredAndTwelve long $200 ' Constant 512.
|
|
maxPositiveInteger long $7FFFFFFF ' Constant 2,147,483,647.
|
|
|
|
CRC16TestBit long $10000 ' The CRC16 test bit mask.
|
|
CRC16Polynomial long $1021 ' The CRC16 polynomial bit mask.
|
|
|
|
OCRCheckMask long %00_000000_00110000_00000000_00000000 ' Parameter check mask for OCR bits.
|
|
HCSBitMask long %01_000000_00000000_00000000_00000000 ' Parameter bit mask for HCS bit.
|
|
|
|
rebootInterpreter long ($0001 << 18) | ($3C01 << 4) ' Spin interpreter boot information.
|
|
rebootStackMark long $FFF9FFFF ' Stack mark used for spin code.
|
|
|
|
' //////////////////////Configuration Settings/////////////////////////////////////////////////////////////////////////////////
|
|
|
|
slowTiming long 0 ' 250KHz Clock speed.
|
|
fastTiming long 0 ' 2.5MHz Clock speed.
|
|
|
|
readTimeout long 250_000 ' Read timeout of 100 milliseconds at 2.5Mhz clock.
|
|
writeTimeout long 625_000 ' Write timeout of 250 milliseconds at 2.5Mhz clock.
|
|
|
|
' //////////////////////Pin Masks//////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
dataOutPin long (|<((Data_Out_Pin <# 31) #> 0))
|
|
clockPin long (|<((Clock_Pin <# 31) #> 0))
|
|
dataInPin long (|<((Data_In_Pin <# 31) #> 0))
|
|
chipSelectPin long (|<((Chip_Select_Pin <# 31) #> 0))
|
|
dataOutOff long 0
|
|
|
|
' //////////////////////Addresses//////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
CCFAddress long 0
|
|
CEFAddress long 0
|
|
|
|
CUIDAddress long 0
|
|
|
|
CDBAddress long 0
|
|
CSAAddress long 0
|
|
|
|
|
|
DAT 'Variable Array
|
|
|
|
' //////////////////////Variable Array/////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
cardCommandFlag byte 0
|
|
cardErrorFlag byte 0
|
|
|
|
cardLockID byte 0 'frida ((HUB_Lock <# 7) #> 0)
|
|
cardUniqueID byte 0[17]
|
|
|
|
cardDataBlockAddress long 0
|
|
cardSectorAddress long 0
|
|
cardSectorCount long 0
|
|
|
|
DAT 'String Array
|
|
|
|
' //////////////////////String Array///////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
dot byte ". ", 0
|
|
dotdot byte ".. ", 0
|
|
|
|
{ '@hive
|
|
FSUnmounted byte "File System Unmounted", 0
|
|
FSCorrupted byte "File System Corrupted", 0
|
|
FSUnsupported byte "File System Unsupported", 0
|
|
|
|
fileOrDirectoryNotFound byte "File Or Directory Not Found", 0
|
|
fileNotFound byte "File Not Found", 0
|
|
directoryNotFound byte "Directory Not Found", 0
|
|
}
|
|
|
|
' //////////////////////Run Time Variables/////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
buffer res 1
|
|
counter res 1
|
|
|
|
' //////////////////////Card Variables/////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
cardBuffer res 1
|
|
cardCounter res 1
|
|
|
|
cardType res 1
|
|
cardSize res 1
|
|
|
|
cardSizeMultiplier res 1
|
|
cardSizeMinusOne res 1
|
|
|
|
cardReadBlockLength res 1
|
|
cardWriteBlockLength res 1
|
|
|
|
CSDRegister res 16
|
|
CIDRegister res 16
|
|
|
|
cardRebootSectors res 64
|
|
|
|
' //////////////////////SPI Variables//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
SPICommandOut res 1
|
|
SPIParameterOut res 1
|
|
SPIResponceIn res 1
|
|
SPILongIn res 1
|
|
|
|
SPIShift res 1
|
|
SPITiming res 1
|
|
|
|
SPIDataIn res 1
|
|
SPIDataOut res 1
|
|
|
|
SPIBuffer res 1
|
|
SPICounter res 1
|
|
|
|
' //////////////////////CRC Variables//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
CRCBuffer res 1
|
|
CRCCounter res 1
|
|
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
fit 496
|
|
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
{{
|
|
|
|
┌─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
|
|
│ TERMS OF USE: MIT License │
|
|
├─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
|
|
│Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation │
|
|
│files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, │
|
|
│modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the │
|
|
│Software is furnished to do so, subject to the following conditions: │
|
|
│ │
|
|
│The above copyright notice and this permission notice shall be included in all copies or substantial portions of the │
|
|
│Software. │
|
|
│ │
|
|
│THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE │
|
|
│WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR │
|
|
│COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, │
|
|
│ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. │
|
|
└─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
|
|
}}
|