mirror of https://github.com/wwarthen/RomWBW.git
wwarthen
12 years ago
24 changed files with 1794 additions and 56 deletions
@ -1,7 +1,7 @@ |
|||||
#DEFINE RMJ 2 |
#DEFINE RMJ 2 |
||||
#DEFINE RMN 5 |
#DEFINE RMN 5 |
||||
#DEFINE RUP 3 |
|
||||
#DEFINE RTP 19 |
|
||||
#DEFINE BIOSVER "2.5.3" |
|
||||
#DEFINE BIOSBLD "Build 19" |
|
||||
|
#DEFINE RUP 4 |
||||
|
#DEFINE RTP 20 |
||||
|
#DEFINE BIOSVER "2.5.4" |
||||
|
#DEFINE BIOSBLD "Build 20" |
||||
#DEFINE REVISION 500 |
#DEFINE REVISION 500 |
||||
|
|||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
@ -0,0 +1 @@ |
|||||
|
{{
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// E555 Speaker Engine
//
// Author: Kwabena W. Agyeman
// Updated: 7/27/2010
// Designed For: P8X32A
// Version: 1.1
//
// Copyright (c) 2010 Kwabena W. Agyeman
// See end of file for terms of use.
//
// Update History:
//
// v1.0 - Original release - 8/26/2009.
// v1.1 - Added support for variable pin assignments - 7/27/2010.
//
// For each included copy of this object only one spin interpreter should access it at a time.
//
// Nyamekye,
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Speaker Circuit:
//
// SpeakerPinNumber --- Speaker Driver (Active High).
//
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}}
PUB speakerFrequency(newFrequency, speakerPinNumber) '' 10 Stack Longs
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
'' // Changes the speaker frequency using the SPIN interpreter's counter modules.
'' //
'' // NewFrequency - The new frequency. Between 0 Hz and 80MHz @ 80MHz. -1 to reset the pin and counter modules.
'' // SpeakerPinNumber - Pin to use to drive the speaker circuit. Between 0 and 31.
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
speakerSetup((newFrequency <> -1), speakerPinNumber)
newFrequency := ((newFrequency <# clkfreq) #> 0)
result := 1
repeat 32
newFrequency <<= 1
result <-= 1
if(newFrequency => clkfreq)
newFrequency -= clkfreq
result += 1
frqa := result~
phsb := 0
PUB speakerVolume(newVolume, speakerPinNumber) '' 10 Stack Longs
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
'' // Changes the speaker volume using the SPIN interpreter's counter modules.
'' //
'' // NewVolume - The new volume. Between 0% and 100%. -1 to reset the pin and counter modules.
'' // SpeakerPinNumber - Pin to use to drive the speaker circuit. Between 0 and 31.
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
speakerSetup((newVolume <> -1), speakerPinNumber)
frqb := (((100 - ((newVolume <# 100) #> 0)) * constant(posx / 50)) | $7)
PRI speakerSetup(activeOrInactive, speakerPinNumber) ' 5 Stack Longs
speakerPinNumber := ((speakerPinNumber <# 31) #> 0)
dira[speakerPinNumber] := activeOrInactive
outa[speakerPinNumber] := false
ctra := ((constant(%0_0100 << 26) + speakerPinNumber) & activeOrInactive)
ctrb := ((constant(%0_0110 << 26) + speakerPinNumber) & activeOrInactive)
{{
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 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.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}} |
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
@ -0,0 +1,704 @@ |
|||||
|
'' VGA_1024.spin |
||||
|
'' |
||||
|
'' MODIFIED BY VINCE BRIEL FOR POCKETERM FEATURES |
||||
|
'' MODIIFED BY JEFF LEDGER / AKA OLDBITCOLLECTOR |
||||
|
'' |
||||
|
|
||||
|
CON |
||||
|
cols = 80 '128 ' number of screen columns |
||||
|
lcols = cols / 4 ' number of long in columns |
||||
|
rows = 40 '64 ' number of screen rows |
||||
|
chars = rows*cols ' number of screen characters |
||||
|
esc = $CB ' keyboard esc char |
||||
|
rowsnow = 36 ' adjusted for split screen effect |
||||
|
maxChars = rowsnow*cols ' adjusted value for split screen effect |
||||
|
lastChar = maxChars / 4 ' last screen position in longs adjusted for split |
||||
|
lastLine = (rowsnow - 1) * cols ' character position of last row |
||||
|
cols1 = 81 ' adjusted value for 80th character |
||||
|
TURQUOISE = $29 |
||||
|
|
||||
|
OBJ |
||||
|
vga : "vga_Hires_Text" |
||||
|
|
||||
|
VAR |
||||
|
byte screen[chars] ' screen character buffer |
||||
|
byte tmpl[cols] ' temporary line buffer |
||||
|
word colors[rows] ' color specs for each screen row (see ColorPtr description above) |
||||
|
byte cursor[6] ' cursor info array (see CursorPtr description above) |
||||
|
long sync, loc, xloc, yloc ' sync used by VGA routine, others are local screen pointers |
||||
|
long kbdreq ' global val of kbdflag |
||||
|
long BR[8] |
||||
|
long Brate |
||||
|
byte inverse |
||||
|
byte invs |
||||
|
byte state ' Current state of state machine |
||||
|
word pos ' Current Position on the screen |
||||
|
word oldpos ' Previous location of cursor before update |
||||
|
word regionTop, regionBot ' Scroll region top/bottom |
||||
|
long arg0 ' First argument of escape sequence |
||||
|
long arg1 ' Second argument of escape sequence |
||||
|
byte lastc ' Last displayed char |
||||
|
word statpos |
||||
|
long vgabasepin |
||||
|
|
||||
|
PUB start(BasePin) | i, char |
||||
|
vgabasepin := BasePin |
||||
|
|
||||
|
''init screen colors to gold on blue |
||||
|
repeat i from 0 to rows - 1 |
||||
|
colors[i] := $08F0 '$2804 (if you want cyan on blue) |
||||
|
|
||||
|
''init cursor attributes |
||||
|
cursor[2] := %110 ' init cursor to underscore with slow blink |
||||
|
BR[0]:=300 |
||||
|
BR[1]:=1200 |
||||
|
BR[2]:=2400 |
||||
|
BR[3]:=4800 |
||||
|
BR[4]:=9600 |
||||
|
BR[5]:=19200 |
||||
|
BR[6]:=38400 |
||||
|
BR[7]:=57600 |
||||
|
BR[8]:=115200 |
||||
|
xloc := cursor[0] := 0 |
||||
|
yloc := cursor[1] := 0 |
||||
|
loc := xloc + yloc*cols |
||||
|
|
||||
|
pos := 0 |
||||
|
regionTop := 0 |
||||
|
regionBot := 35 * cols |
||||
|
state := 0 |
||||
|
statpos := 37 * cols |
||||
|
|
||||
|
PUB vidon |
||||
|
if (!vga.start(vgabasepin, @screen, @colors, @cursor, @sync)) |
||||
|
return false |
||||
|
|
||||
|
waitcnt(clkfreq * 1 + cnt) 'wait 1 second for cogs to start |
||||
|
|
||||
|
|
||||
|
PUB vidoff |
||||
|
vga.stop |
||||
|
|
||||
|
|
||||
|
PUB inv(c) |
||||
|
inverse:=c |
||||
|
|
||||
|
PUB color(colorVal) | i |
||||
|
repeat i from 0 to rows - 1 |
||||
|
colors[i] := $0000 | colorVal |
||||
|
|
||||
|
PUB cursorset(c) | i |
||||
|
i:=%000 |
||||
|
if c == 1 |
||||
|
i:= %001 |
||||
|
if c == 2 |
||||
|
i:= %010 |
||||
|
if c == 3 |
||||
|
i:= %011 |
||||
|
if c == 4 |
||||
|
i:= %101 |
||||
|
if c == 5 |
||||
|
i:= %110 |
||||
|
if c == 6 |
||||
|
i:= %111 |
||||
|
if c == 7 |
||||
|
i:= %000 |
||||
|
cursor[2] := i |
||||
|
|
||||
|
PUB bin(value, digits) |
||||
|
|
||||
|
'' Print a binary number, specify number of digits |
||||
|
|
||||
|
repeat while digits > 32 |
||||
|
outc("0") |
||||
|
digits-- |
||||
|
|
||||
|
value <<= 32 - digits |
||||
|
|
||||
|
repeat digits |
||||
|
outc((value <-= 1) & 1 + "0") |
||||
|
|
||||
|
|
||||
|
PUB clrbtm(ColorVal) | i |
||||
|
repeat i from 36 to rows - 1 'was 35 |
||||
|
colors[i] := $0000 + ColorVal |
||||
|
|
||||
|
PUB cls1(c,screencolor,pcport,ascii,CR) | i,x,y |
||||
|
|
||||
|
longfill(@screen[0], $20202020, chars / 4) |
||||
|
|
||||
|
clrbtm(TURQUOISE) |
||||
|
|
||||
|
inverse := 1 |
||||
|
|
||||
|
statprint(36,0, string(" N8VEM PropIO V2 | RomWBW v0.94")) |
||||
|
inverse := 0 |
||||
|
statprint(37,0, string(" ")) |
||||
|
statprint(38,0, string(" ")) |
||||
|
statprint(39,0, string(" ")) |
||||
|
|
||||
|
|
||||
|
{{ |
||||
|
x :=xloc |
||||
|
y := yloc |
||||
|
invs := inverse |
||||
|
''clrbtm(TURQUOISE) |
||||
|
longfill(@screen, $20202020, chars/4) |
||||
|
xloc := 0 |
||||
|
yloc :=0 |
||||
|
loc := xloc + yloc*cols |
||||
|
repeat 80 |
||||
|
outc(32) |
||||
|
xloc := 0 |
||||
|
yloc :=36 |
||||
|
loc := xloc + yloc*cols |
||||
|
inverse := 1 |
||||
|
str(string(" propIO V 0.91 ")) |
||||
|
inverse := 0 |
||||
|
str(string("Baud Rate: ")) |
||||
|
i:= BR[6] |
||||
|
dec(i) |
||||
|
str(string(" ")) |
||||
|
xloc := 18 |
||||
|
loc := xloc + yloc*cols |
||||
|
str(string("Color ")) |
||||
|
str(string("PC Port: ")) |
||||
|
if pcport == 1 |
||||
|
str(string("OFF ")) |
||||
|
if pcport == 0 |
||||
|
str(string("ON ")) |
||||
|
str(string(" Force 7 bit: ")) |
||||
|
if ascii == 0 |
||||
|
str(string("NO ")) |
||||
|
if ascii == 1 |
||||
|
str(string("YES ")) |
||||
|
str(string(" Cursor CR W/LF: ")) |
||||
|
if CR == 1 |
||||
|
str(string("YES")) |
||||
|
if CR == 0 |
||||
|
str(string("NO ")) |
||||
|
outc(13) |
||||
|
outc(10) |
||||
|
|
||||
|
inverse:=1 |
||||
|
xloc := 6 |
||||
|
loc := xloc + yloc*cols |
||||
|
str(string("F1")) |
||||
|
xloc := 19 |
||||
|
loc := xloc + yloc*cols |
||||
|
str(string("F2")) |
||||
|
xloc := 30 |
||||
|
loc := xloc + yloc*cols |
||||
|
str(string("F3")) |
||||
|
xloc := 46 |
||||
|
loc := xloc + yloc*cols |
||||
|
str(string("F4")) |
||||
|
xloc := 58 |
||||
|
loc := xloc + yloc*cols |
||||
|
str(string("F5")) |
||||
|
xloc := 70 |
||||
|
loc := xloc + yloc*cols |
||||
|
str(string("F6")) |
||||
|
inverse := invs |
||||
|
xloc := cursor[0] := x 'right & left was 0 |
||||
|
yloc := cursor[1] := y 'from top was 1 |
||||
|
loc := xloc + yloc*cols |
||||
|
}} |
||||
|
|
||||
|
PUB clsupdate(c,screencolor,PCPORT,ascii,CR) | i,x,y,locold |
||||
|
|
||||
|
invs := inverse |
||||
|
locold := loc |
||||
|
x := xloc |
||||
|
y := yloc |
||||
|
''(TURQUOISE) |
||||
|
xloc := 0 |
||||
|
yloc :=36 |
||||
|
loc := xloc + yloc*cols |
||||
|
inverse := 1 |
||||
|
str(string(" propIO V 0.81 ")) |
||||
|
inverse := 0 |
||||
|
xloc := 0 |
||||
|
yloc :=37 |
||||
|
loc := xloc + yloc*cols |
||||
|
str(string("Baud Rate: ")) |
||||
|
i:= BR[6] |
||||
|
dec(i) |
||||
|
str(string(" ")) |
||||
|
xloc := 18 |
||||
|
loc := xloc + yloc*cols |
||||
|
|
||||
|
str(string("Color ")) |
||||
|
str(string("PC Port: ")) |
||||
|
if pcport == 1 |
||||
|
str(string("OFF ")) |
||||
|
if pcport == 0 |
||||
|
str(string("ON ")) |
||||
|
str(string(" Force 7 bit: ")) |
||||
|
if ascii == 0 |
||||
|
str(string("NO ")) |
||||
|
if ascii == 1 |
||||
|
str(string("YES ")) |
||||
|
str(string(" Cursor CR W/LF: ")) |
||||
|
if CR == 1 |
||||
|
str(string("YES")) |
||||
|
if CR == 0 |
||||
|
str(string("NO ")) |
||||
|
xloc := 0 |
||||
|
yloc :=38 |
||||
|
loc := xloc + yloc*cols |
||||
|
inverse:=1 |
||||
|
xloc := 6 |
||||
|
loc := xloc + yloc*cols |
||||
|
str(string("F1")) |
||||
|
xloc := 19 |
||||
|
loc := xloc + yloc*cols |
||||
|
str(string("F2")) |
||||
|
xloc := 30 |
||||
|
loc := xloc + yloc*cols |
||||
|
str(string("F3")) |
||||
|
xloc := 46 |
||||
|
loc := xloc + yloc*cols |
||||
|
str(string("F4")) |
||||
|
xloc := 58 |
||||
|
loc := xloc + yloc*cols |
||||
|
str(string("F5")) |
||||
|
xloc := 70 |
||||
|
loc := xloc + yloc*cols |
||||
|
str(string("F6")) |
||||
|
inverse := invs |
||||
|
xloc := cursor[0] := x |
||||
|
yloc := cursor[1] := y |
||||
|
' loc := xloc + yloc*cols |
||||
|
loc := locold |
||||
|
|
||||
|
PUB dec(value) | i |
||||
|
|
||||
|
'' Print a decimal number |
||||
|
|
||||
|
if value < 0 |
||||
|
-value |
||||
|
outc("-") |
||||
|
|
||||
|
i := 1_000_000_000 |
||||
|
|
||||
|
repeat 10 |
||||
|
if value => i |
||||
|
outc(value/i + "0") |
||||
|
value //= i |
||||
|
result~~ |
||||
|
elseif result or i == 1 |
||||
|
outc("0") |
||||
|
i /= 10 |
||||
|
|
||||
|
PUB hex(value, digits) |
||||
|
|
||||
|
'' Print a hexadecimal number, specify number of digits |
||||
|
|
||||
|
repeat while digits > 8 |
||||
|
outc("0") |
||||
|
digits-- |
||||
|
|
||||
|
value <<= (8 - digits) << 2 |
||||
|
|
||||
|
repeat digits |
||||
|
outc(lookupz((value <-= 4) & $f : "0".."9", "A".."F")) |
||||
|
|
||||
|
|
||||
|
PUB str(string_ptr) |
||||
|
|
||||
|
'' Print a zero terminated string |
||||
|
|
||||
|
repeat strsize(string_ptr) |
||||
|
process_char(byte[string_ptr++]) |
||||
|
|
||||
|
PUB statprint(r, c, str1) | x, ptr |
||||
|
|
||||
|
ptr := r * cols + c |
||||
|
repeat x from 0 to STRSIZE(str1) - 1 |
||||
|
putc(ptr++, BYTE[str1 + x]) |
||||
|
|
||||
|
PUB statnum(r, c, num1) | i, ptr |
||||
|
|
||||
|
ptr := r * cols + c |
||||
|
|
||||
|
if num1 < 0 |
||||
|
-num1 |
||||
|
putc(ptr++,"-") |
||||
|
|
||||
|
i := 1_000_000_000 |
||||
|
|
||||
|
repeat 10 |
||||
|
if num1 => i |
||||
|
putc(ptr++, (num1/i +"0")) |
||||
|
num1 //= i |
||||
|
result~~ |
||||
|
elseif result or i == 1 |
||||
|
putc(ptr++, "0") |
||||
|
i /= 10 |
||||
|
|
||||
|
PUB putc(position, c) |
||||
|
if inverse |
||||
|
c |= $80 |
||||
|
screen[position] := c |
||||
|
|
||||
|
PUB cls |
||||
|
longfill (@screen, $20202020, lastChar) |
||||
|
|
||||
|
PUB fullcls |
||||
|
longfill(@screen, $20202020, 800) |
||||
|
|
||||
|
PUB setInverse(val) |
||||
|
inverse := val |
||||
|
|
||||
|
PUB setInv(c) |
||||
|
if c == 7 |
||||
|
setInverse(1) |
||||
|
else |
||||
|
setInverse(0) |
||||
|
|
||||
|
PUB clEOL(position) | count |
||||
|
count := cols - (position // cols) |
||||
|
bytefill(@screen + position, $20, count) |
||||
|
|
||||
|
PUB clBOL(position) | count |
||||
|
count := position // cols |
||||
|
bytefill(@screen + position - count, $20, count) |
||||
|
|
||||
|
PUB delLine(position) | src, count |
||||
|
position -= position // cols |
||||
|
|
||||
|
src := position + cols |
||||
|
|
||||
|
count := (maxChars - src) / 4 |
||||
|
|
||||
|
if count > 0 |
||||
|
longmove(@screen + position, @screen + src, count) |
||||
|
|
||||
|
longfill(@screen + lastLine, $20202020, lcols) |
||||
|
|
||||
|
PUB clEOS(position) |
||||
|
cleol(position) |
||||
|
position += cols - (position // cols) |
||||
|
repeat while position < maxChars |
||||
|
longfill(@screen + position, $20202020, lcols) |
||||
|
pos += cols |
||||
|
|
||||
|
PUB setCursorPos(position) |
||||
|
cursor[0] := position // cols |
||||
|
cursor[1] := position / cols |
||||
|
|
||||
|
PUB insLine(position) | base, nxt |
||||
|
base := position - (position // cols) |
||||
|
position := lastLine |
||||
|
repeat while position > base |
||||
|
nxt := position - cols |
||||
|
longmove(@screen + position, @screen + nxt, lcols) |
||||
|
position := nxt |
||||
|
clEOL(base) |
||||
|
|
||||
|
PUB insChar(position) | count |
||||
|
count := (cols - (position // cols)) - 1 |
||||
|
bytemove(@tmpl, @screen + position, count) |
||||
|
screen[position] := " " |
||||
|
bytemove(@screen + position + 1, @tmpl, count) |
||||
|
|
||||
|
PUB delChar(position) | count |
||||
|
count := (cols - (position // cols)) - 1 |
||||
|
bytemove(@screen + position, @screen + position + 1, count) |
||||
|
screen[position + count] := " " |
||||
|
|
||||
|
PRI inRegion : answer |
||||
|
answer := (pos => regionTop) AND (pos < regionBot) |
||||
|
|
||||
|
PRI scrollUp |
||||
|
delLine(regionTop) |
||||
|
if regionBot < maxChars |
||||
|
insLine(regionBot) |
||||
|
|
||||
|
PRI scrollDown |
||||
|
if regionBot < maxChars |
||||
|
delLine(regionBot) |
||||
|
insLine(regionTop) |
||||
|
|
||||
|
PRI ansi(c) | x, defVal |
||||
|
|
||||
|
state := 0 |
||||
|
|
||||
|
if (c <> "r") AND (c <> "J") AND (c <> "m") AND (c <> "K") |
||||
|
if arg0 == -1 |
||||
|
arg0 := 1 |
||||
|
if arg1 == -1 |
||||
|
arg1 := 1 |
||||
|
|
||||
|
case c |
||||
|
"@": |
||||
|
repeat while arg0-- > 0 |
||||
|
insChar(pos) |
||||
|
|
||||
|
"b": |
||||
|
repeat while arg0-- > 0 |
||||
|
outc(lastc) |
||||
|
|
||||
|
"d": |
||||
|
if (arg0 < 1) OR (arg0 > rows) |
||||
|
arg0 := rows |
||||
|
pos := ((arg0 - 1) * cols) + (pos // cols) |
||||
|
|
||||
|
"m": |
||||
|
setInv(arg0) |
||||
|
if arg1 <> -1 |
||||
|
setInv(arg1) |
||||
|
|
||||
|
"r": |
||||
|
if arg0 < 1 |
||||
|
arg0 := 1 |
||||
|
elseif arg0 > cols |
||||
|
arg0 := cols |
||||
|
if arg1 < 1 |
||||
|
arg1 := 1 |
||||
|
elseif arg1 > cols |
||||
|
arg1 := cols |
||||
|
if arg1 < arg0 |
||||
|
arg1 := arg0 |
||||
|
|
||||
|
regionTop := (arg0 - 1) * cols |
||||
|
regionBot := arg1 * cols |
||||
|
pos := 0 |
||||
|
|
||||
|
"A": |
||||
|
repeat while arg0-- > 0 |
||||
|
pos -= cols |
||||
|
if pos < 0 |
||||
|
pos += cols |
||||
|
return |
||||
|
|
||||
|
"B": |
||||
|
repeat while arg0-- > 0 |
||||
|
pos += cols |
||||
|
if pos => maxChars |
||||
|
pos -= cols |
||||
|
return |
||||
|
|
||||
|
"C": |
||||
|
repeat while arg0-- > 0 |
||||
|
pos += 1 |
||||
|
if pos => maxChars |
||||
|
pos -= 1 |
||||
|
return |
||||
|
|
||||
|
"D": |
||||
|
repeat while arg0-- > 0 |
||||
|
pos -= 1 |
||||
|
if pos < 0 |
||||
|
pos := 0 |
||||
|
return |
||||
|
|
||||
|
"G": |
||||
|
if (arg0 < 1) OR (arg0 > cols) |
||||
|
arg0 := cols |
||||
|
pos := (pos - (pos // cols)) + (arg0 - 1) |
||||
|
|
||||
|
"H", "f": |
||||
|
if arg0 =< 0 |
||||
|
arg0 := 1 |
||||
|
if arg1 =< 0 |
||||
|
arg1 := 1 |
||||
|
pos := (cols * (arg0 - 1)) + (arg1 - 1) |
||||
|
if pos < 0 |
||||
|
pos := 0 |
||||
|
if pos => maxChars |
||||
|
pos := maxChars - 1 |
||||
|
|
||||
|
"J": |
||||
|
if arg0 == 1 |
||||
|
clBOL(pos) |
||||
|
x := pos - cols |
||||
|
x -= x // cols |
||||
|
repeat while x => 0 |
||||
|
clEOL(x) |
||||
|
x -= cols |
||||
|
return |
||||
|
|
||||
|
if arg0 == 2 |
||||
|
pos := 0 |
||||
|
|
||||
|
clEOL(pos) |
||||
|
x := pos + cols |
||||
|
x -= (x // cols) |
||||
|
repeat while x < maxChars |
||||
|
clEOL(x) |
||||
|
x += cols |
||||
|
|
||||
|
"K": |
||||
|
if arg0 == -1 |
||||
|
clEOL(pos) |
||||
|
elseif arg0 == 1 |
||||
|
clBOL(pos) |
||||
|
else |
||||
|
clEOL(pos - (pos // cols)) |
||||
|
|
||||
|
"L": |
||||
|
if inRegion |
||||
|
repeat while arg0-- > 0 |
||||
|
if regionBot < maxChars |
||||
|
delLine(regionBot) |
||||
|
insLine(pos) |
||||
|
|
||||
|
"M": |
||||
|
if inRegion |
||||
|
repeat while arg0-- > 0 |
||||
|
delLine(pos) |
||||
|
if regionBot < maxChars |
||||
|
insLine(regionBot) |
||||
|
|
||||
|
"P": |
||||
|
repeat while arg0-- |
||||
|
delChar(pos) |
||||
|
|
||||
|
PRI outc(c) |
||||
|
|
||||
|
putc(pos++, lastc := c) |
||||
|
if pos == regionBot |
||||
|
scrollUp |
||||
|
pos -= cols |
||||
|
elseif pos == maxChars |
||||
|
pos := lastLine |
||||
|
|
||||
|
PUB process_char(c) |
||||
|
|
||||
|
case state |
||||
|
|
||||
|
0: |
||||
|
if c > 127 |
||||
|
c := $20 |
||||
|
|
||||
|
if c => $20 |
||||
|
outc(c) |
||||
|
setCursorPos(pos) |
||||
|
return |
||||
|
|
||||
|
if c == $1B |
||||
|
state := 1 |
||||
|
return |
||||
|
|
||||
|
if c == $0D |
||||
|
pos := pos - (pos // cols) |
||||
|
setCursorPos(pos) |
||||
|
return |
||||
|
|
||||
|
if c == $0A |
||||
|
if inRegion |
||||
|
pos += cols |
||||
|
if pos => regionBot |
||||
|
scrollUp |
||||
|
pos -= cols |
||||
|
else |
||||
|
pos += cols |
||||
|
if pos => maxChars |
||||
|
pos -= cols |
||||
|
setCursorPos(pos) |
||||
|
return |
||||
|
|
||||
|
if c == 9 |
||||
|
pos += (8 - (pos // 8)) |
||||
|
|
||||
|
if pos => maxChars |
||||
|
pos := lastLine |
||||
|
delLine(0) |
||||
|
|
||||
|
setCursorPos(pos) |
||||
|
return |
||||
|
|
||||
|
if c == 8 |
||||
|
if pos > 0 |
||||
|
pos -= 1 |
||||
|
setCursorPos(pos) |
||||
|
return |
||||
|
|
||||
|
1: |
||||
|
case c |
||||
|
"[": |
||||
|
arg0 := arg1 := -1 |
||||
|
state := 2 |
||||
|
return |
||||
|
|
||||
|
"P": |
||||
|
pos += cols |
||||
|
if pos => maxChars |
||||
|
pos -= cols |
||||
|
|
||||
|
"K": |
||||
|
if pos > 0 |
||||
|
pos -= 1 |
||||
|
|
||||
|
"H": |
||||
|
pos -= cols |
||||
|
if pos < 0 |
||||
|
pos += cols |
||||
|
|
||||
|
"D": |
||||
|
if inRegion |
||||
|
scrollUp |
||||
|
|
||||
|
"M": |
||||
|
if inRegion |
||||
|
scrollDown |
||||
|
|
||||
|
"G": |
||||
|
pos := 0 |
||||
|
|
||||
|
"(": |
||||
|
state := 5 |
||||
|
return |
||||
|
|
||||
|
state := 0 |
||||
|
return |
||||
|
|
||||
|
2: |
||||
|
if (c => "0") AND (c =< "9") |
||||
|
if arg0 == -1 |
||||
|
arg0 := c - "0" |
||||
|
else |
||||
|
arg0 := (arg0 * 10) + (c - "0") |
||||
|
return |
||||
|
|
||||
|
if c == ";" |
||||
|
state := 3 |
||||
|
return |
||||
|
|
||||
|
ansi(c) |
||||
|
setCursorPos(pos) |
||||
|
return |
||||
|
|
||||
|
3: |
||||
|
if (c => "0") AND (c =< "9") |
||||
|
if arg1 == -1 |
||||
|
arg1 := c - "0" |
||||
|
else |
||||
|
arg1 := (arg1 * 10) + (c - "0") |
||||
|
return |
||||
|
|
||||
|
if c == ";" |
||||
|
state := 4 |
||||
|
return |
||||
|
|
||||
|
ansi(c) |
||||
|
setCursorPos(pos) |
||||
|
return |
||||
|
|
||||
|
4: |
||||
|
if (c => "0") AND (c =< "9") |
||||
|
return |
||||
|
|
||||
|
if c == ";" |
||||
|
return |
||||
|
ansi(c) |
||||
|
setCursorPos(pos) |
||||
|
return |
||||
|
|
||||
|
5: |
||||
|
state := 0 |
||||
|
return |
||||
|
|
||||
|
return |
||||
Binary file not shown.
@ -0,0 +1,920 @@ |
|||||
|
{{ |
||||
|
SPI interface routines for SD & SDHC & MMC cards |
||||
|
|
||||
|
Jonathan "lonesock" Dummer |
||||
|
version 0.3.0 2009 July 19 |
||||
|
|
||||
|
Using multiblock SPI mode exclusively. |
||||
|
|
||||
|
This is the "SAFE" version...uses |
||||
|
* 1 instruction per bit writes |
||||
|
* 2 instructions per bit reads |
||||
|
|
||||
|
For the fsrw project: |
||||
|
fsrw.sf.net |
||||
|
}} |
||||
|
|
||||
|
CON |
||||
|
' possible card types |
||||
|
type_MMC = 1 |
||||
|
type_SD = 2 |
||||
|
type_SDHC = 3 |
||||
|
|
||||
|
' Error codes |
||||
|
ERR_CARD_NOT_RESET = -1 |
||||
|
ERR_3v3_NOT_SUPPORTED = -2 |
||||
|
ERR_OCR_FAILED = -3 |
||||
|
ERR_BLOCK_NOT_LONG_ALIGNED = -4 |
||||
|
'... |
||||
|
' These errors are for the assembly engine...they are negated inside, and need to be <= 511 |
||||
|
ERR_ASM_NO_READ_TOKEN = 100 |
||||
|
ERR_ASM_BLOCK_NOT_WRITTEN = 101 |
||||
|
' NOTE: errors -128 to -255 are reserved for reporting R1 response errors |
||||
|
'... |
||||
|
ERR_SPI_ENGINE_NOT_RUNNING = -999 |
||||
|
ERR_CARD_BUSY_TIMEOUT = -1000 |
||||
|
|
||||
|
' SDHC/SD/MMC command set for SPI |
||||
|
CMD0 = $40+0 ' GO_IDLE_STATE |
||||
|
CMD1 = $40+1 ' SEND_OP_COND (MMC) |
||||
|
ACMD41 = $C0+41 ' SEND_OP_COND (SDC) |
||||
|
CMD8 = $40+8 ' SEND_IF_COND |
||||
|
CMD9 = $40+9 ' SEND_CSD |
||||
|
CMD10 = $40+10 ' SEND_CID |
||||
|
CMD12 = $40+12 ' STOP_TRANSMISSION |
||||
|
CMD13 = $40+13 ' SEND_STATUS |
||||
|
ACMD13 = $C0+13 ' SD_STATUS (SDC) |
||||
|
CMD16 = $40+16 ' SET_BLOCKLEN |
||||
|
CMD17 = $40+17 ' READ_SINGLE_BLOCK |
||||
|
CMD18 = $40+18 ' READ_MULTIPLE_BLOCK |
||||
|
CMD23 = $40+23 ' SET_BLOCK_COUNT (MMC) |
||||
|
ACMD23 = $C0+23 ' SET_WR_BLK_ERASE_COUNT (SDC) |
||||
|
CMD24 = $40+24 ' WRITE_BLOCK |
||||
|
CMD25 = $40+25 ' WRITE_MULTIPLE_BLOCK |
||||
|
CMD55 = $40+55 ' APP_CMD |
||||
|
CMD58 = $40+58 ' READ_OCR |
||||
|
CMD59 = $40+59 ' CRC_ON_OFF |
||||
|
|
||||
|
' buffer size for my debug cmd log |
||||
|
'LOG_SIZE = 256<<1 |
||||
|
|
||||
|
{ |
||||
|
VAR |
||||
|
long SPI_engine_cog |
||||
|
' these are used for interfacing with the assembly engine | temporary initialization usage |
||||
|
long SPI_command ' "t", "r", "w", 0 =>done, <0 => error | pin mask |
||||
|
long SPI_block_index ' which 512-byte block to read/write | cnt at init |
||||
|
long SPI_buffer_address ' where to get/put the data in Hub RAM | unused |
||||
|
'} |
||||
|
DAT |
||||
|
'' I'm placing these variables in a DAT section to make this driver a singleton. |
||||
|
'' If for some reason you really need more than one driver (e.g. if you have more |
||||
|
'' than a single SD socket), move these back into VAR. |
||||
|
SPI_engine_cog long 0 |
||||
|
' these are used for interfacing with the assembly engine | temporary initialization usage |
||||
|
SPI_command long 0 ' "t", "r", "w", 0 =>done, <0 => error | unused |
||||
|
SPI_block_index long 0 ' which 512-byte block to read/write | cnt at init |
||||
|
SPI_buffer_address long 0 ' where to get/put the data in Hub RAM | unused |
||||
|
|
||||
|
{ |
||||
|
VAR |
||||
|
' for debug ONLY |
||||
|
byte log_cmd_resp[LOG_SIZE+1] |
||||
|
PUB get_log_pointer |
||||
|
return @log_cmd_resp |
||||
|
'} |
||||
|
|
||||
|
PUB start( basepin ) |
||||
|
{{ |
||||
|
This is a compatibility wrapper, and requires that the pins be |
||||
|
both consecutive, and in the order DO CLK DI CS. |
||||
|
}} |
||||
|
return start_explicit( basepin, basepin+1, basepin+2, basepin+3 ) |
||||
|
|
||||
|
PUB readblock( block_index, buffer_address ) |
||||
|
if SPI_engine_cog == 0 |
||||
|
abort ERR_SPI_ENGINE_NOT_RUNNING |
||||
|
if (buffer_address & 3) |
||||
|
abort ERR_BLOCK_NOT_LONG_ALIGNED |
||||
|
SPI_block_index := block_index |
||||
|
SPI_buffer_address := buffer_address |
||||
|
SPI_command := "r" |
||||
|
repeat while SPI_command == "r" |
||||
|
if SPI_command < 0 |
||||
|
abort SPI_command |
||||
|
|
||||
|
PUB writeblock( block_index, buffer_address ) |
||||
|
if SPI_engine_cog == 0 |
||||
|
abort ERR_SPI_ENGINE_NOT_RUNNING |
||||
|
if (buffer_address & 3) |
||||
|
abort ERR_BLOCK_NOT_LONG_ALIGNED |
||||
|
SPI_block_index := block_index |
||||
|
SPI_buffer_address := buffer_address |
||||
|
SPI_command := "w" |
||||
|
repeat while SPI_command == "w" |
||||
|
if SPI_command < 0 |
||||
|
abort SPI_command |
||||
|
|
||||
|
PUB get_seconds |
||||
|
if SPI_engine_cog == 0 |
||||
|
abort ERR_SPI_ENGINE_NOT_RUNNING |
||||
|
SPI_command := "t" |
||||
|
repeat while SPI_command == "t" |
||||
|
' secods are in SPI_block_index, remainder is in SPI_buffer_address |
||||
|
return SPI_block_index |
||||
|
|
||||
|
PUB get_milliseconds : ms |
||||
|
if SPI_engine_cog == 0 |
||||
|
abort ERR_SPI_ENGINE_NOT_RUNNING |
||||
|
SPI_command := "t" |
||||
|
repeat while SPI_command == "t" |
||||
|
' secods are in SPI_block_index, remainder is in SPI_buffer_address |
||||
|
ms := SPI_block_index * 1000 |
||||
|
ms += SPI_buffer_address * 1000 / clkfreq |
||||
|
|
||||
|
PUB start_explicit( DO, CLK, DI, CS ) : card_type | tmp, i |
||||
|
{{ |
||||
|
Do all of the card initialization in SPIN, then hand off the pin |
||||
|
information to the assembly cog for hot SPI block R/W action! |
||||
|
}} |
||||
|
' Start from scratch |
||||
|
stop |
||||
|
' clear my log buffer |
||||
|
{ |
||||
|
bytefill( @log_cmd_resp, 0, LOG_SIZE+1 ) |
||||
|
dbg_ptr := @log_cmd_resp |
||||
|
dbg_end := dbg_ptr + LOG_SIZE |
||||
|
'} |
||||
|
' wait ~4 milliseconds |
||||
|
waitcnt( 500 + (clkfreq>>8) + cnt ) |
||||
|
' (start with cog variables, _BEFORE_ loading the cog) |
||||
|
pinDO := DO |
||||
|
maskDO := |< DO |
||||
|
pinCLK := CLK |
||||
|
pinDI := DI |
||||
|
maskDI := |< DI |
||||
|
maskCS := |< CS |
||||
|
adrShift := 9 ' block = 512 * index, and 512 = 1<<9 |
||||
|
' pass the output pin mask via the command register |
||||
|
maskAll := maskCS | (|<pinCLK) | maskDI |
||||
|
dira |= maskAll |
||||
|
' get the card in a ready state: set DI and CS high, send => 74 clocks |
||||
|
outa |= maskAll |
||||
|
repeat 4096 |
||||
|
outa[CLK]~~ |
||||
|
outa[CLK]~ |
||||
|
' time-hack |
||||
|
SPI_block_index := cnt |
||||
|
' reset the card |
||||
|
tmp~ |
||||
|
repeat i from 0 to 9 |
||||
|
if tmp <> 1 |
||||
|
tmp := send_cmd_slow( CMD0, 0, $95 ) |
||||
|
if (tmp & 4) |
||||
|
' the card said CMD0 ("go idle") was invalid, so we're possibly stuck in read or write mode |
||||
|
if i & 1 |
||||
|
' exit multiblock read mode |
||||
|
repeat 4 |
||||
|
read_32_slow ' these extra clocks are required for some MMC cards |
||||
|
send_slow( $FD, 8 ) ' stop token |
||||
|
read_32_slow |
||||
|
repeat while read_slow <> $FF |
||||
|
else |
||||
|
' exit multiblock read mode |
||||
|
send_cmd_slow( CMD12, 0, $61 ) |
||||
|
if tmp <> 1 |
||||
|
' the reset command failed! |
||||
|
crash( ERR_CARD_NOT_RESET ) |
||||
|
' Is this a SD type 2 card? |
||||
|
if send_cmd_slow( CMD8, $1AA, $87 ) == 1 |
||||
|
' Type2 SD, check to see if it's a SDHC card |
||||
|
tmp := read_32_slow |
||||
|
' check the supported voltage |
||||
|
if (tmp & $1FF) <> $1AA |
||||
|
crash( ERR_3v3_NOT_SUPPORTED ) |
||||
|
' try to initialize the type 2 card with the High Capacity bit |
||||
|
repeat while send_cmd_slow( ACMD41, |<30, $77 ) |
||||
|
' the card is initialized, let's read back the High Capacity bit |
||||
|
if send_cmd_slow( CMD58, 0, $FD ) <> 0 |
||||
|
crash( ERR_OCR_FAILED ) |
||||
|
' get back the data |
||||
|
tmp := read_32_slow |
||||
|
' check the bit |
||||
|
if tmp & |<30 |
||||
|
card_type := type_SDHC |
||||
|
adrShift := 0 |
||||
|
else |
||||
|
card_type := type_SD |
||||
|
else |
||||
|
' Either a type 1 SD card, or it's MMC, try SD 1st |
||||
|
if send_cmd_slow( ACMD41, 0, $E5 ) < 2 |
||||
|
' this is a type 1 SD card (1 means busy, 0 means done initializing) |
||||
|
card_type := type_SD |
||||
|
repeat while send_cmd_slow( ACMD41, 0, $E5 ) |
||||
|
else |
||||
|
' mark that it's MMC, and try to initialize |
||||
|
card_type := type_MMC |
||||
|
repeat while send_cmd_slow( CMD1, 0, $F9 ) |
||||
|
' some SD or MMC cards may have the wrong block size, set it here |
||||
|
send_cmd_slow( CMD16, 512, $15 ) |
||||
|
' card is mounted, make sure the CRC is turned off |
||||
|
send_cmd_slow( CMD59, 0, $91 ) |
||||
|
' check the status |
||||
|
'send_cmd_slow( CMD13, 0, $0D ) |
||||
|
' done with the SPI bus for now |
||||
|
outa |= maskCS |
||||
|
' set my counter modes for super fast SPI operation |
||||
|
' writing: NCO single-ended mode, output on DI |
||||
|
writeMode := (%00100 << 26) | (DI << 0) |
||||
|
' reading |
||||
|
'readMode := (%11000 << 26) | (DO << 0) | (CLK << 9) |
||||
|
' clock |
||||
|
'clockLineMode := (%00110 << 26) | (CLK << 0) ' DUTY, 25% duty cycle |
||||
|
' clock |
||||
|
clockLineMode := (%00100 << 26) | (CLK << 0) ' NCO, 50% duty cycle |
||||
|
' how many bytes (8 clocks, >>3) fit into 1/2 of a second (>>1), 4 clocks per instruction (>>2)? |
||||
|
N_in8_500ms := clkfreq >> constant(1+2+3) |
||||
|
' how long should we wait before auto-exiting any multiblock mode? |
||||
|
idle_limit := 125 ' ms, NEVER make this > 1000 |
||||
|
idle_limit := clkfreq / (1000 / idle_limit) ' convert to counts |
||||
|
' Hand off control to the assembly engine's cog |
||||
|
bufAdr := @SPI_buffer_address |
||||
|
sdAdr := @SPI_block_index |
||||
|
SPI_command := 0 ' just make sure it's not 1 |
||||
|
' start my driver cog and wait till I hear back that it's done |
||||
|
SPI_engine_cog := cognew( @SPI_engine_entry, @SPI_command ) + 1 |
||||
|
if( SPI_engine_cog == 0 ) |
||||
|
crash( ERR_SPI_ENGINE_NOT_RUNNING ) |
||||
|
repeat while SPI_command <> -1 |
||||
|
' and we no longer need to control any pins from here |
||||
|
dira &= !maskAll |
||||
|
' the return variable is card_type |
||||
|
|
||||
|
PUB release |
||||
|
{{ |
||||
|
I do not want to abort if the cog is not |
||||
|
running, as this is called from stop, which |
||||
|
is called from start/ [8^) |
||||
|
}} |
||||
|
if SPI_engine_cog |
||||
|
SPI_command := "z" |
||||
|
repeat while SPI_command == "z" |
||||
|
|
||||
|
PUB stop |
||||
|
{{ |
||||
|
kill the assembly driver cog. |
||||
|
}} |
||||
|
release |
||||
|
if SPI_engine_cog |
||||
|
cogstop( SPI_engine_cog~ - 1 ) |
||||
|
|
||||
|
PRI crash( abort_code ) |
||||
|
{{ |
||||
|
In case of Bad Things(TM) happening, |
||||
|
exit as gracefully as possible. |
||||
|
}} |
||||
|
' and we no longer need to control any pins from here |
||||
|
dira &= !maskAll |
||||
|
' and report our error |
||||
|
abort abort_code |
||||
|
|
||||
|
PRI send_cmd_slow( cmd, val, crc ) : reply | time_stamp |
||||
|
{{ |
||||
|
Send down a command and return the reply. |
||||
|
Note: slow is an understatement! |
||||
|
Note: this uses the assembly DAT variables for pin IDs, |
||||
|
which means that if you run this multiple times (say for |
||||
|
multiple SD cards), these values will change for each one. |
||||
|
But this is OK as all of these functions will be called |
||||
|
during the initialization only, before the PASM engine is |
||||
|
running. |
||||
|
}} |
||||
|
' if this is an application specific command, handle it |
||||
|
if (cmd & $80) |
||||
|
' ACMD<n> is the command sequense of CMD55-CMD<n> |
||||
|
cmd &= $7F |
||||
|
reply := send_cmd_slow( CMD55, 0, $65 ) |
||||
|
if (reply > 1) |
||||
|
return reply |
||||
|
' the CS line needs to go low during this operation |
||||
|
outa |= maskCS |
||||
|
outa &= !maskCS |
||||
|
' give the card a few cocks to finish whatever it was doing |
||||
|
read_32_slow |
||||
|
' send the command byte |
||||
|
send_slow( cmd, 8 ) |
||||
|
' send the value long |
||||
|
send_slow( val, 32 ) |
||||
|
' send the CRC byte |
||||
|
send_slow( crc, 8 ) |
||||
|
' is this a CMD12?, if so, stuff byte |
||||
|
if cmd == CMD12 |
||||
|
read_slow |
||||
|
' read back the response (spec declares 1-8 reads max for SD, MMC is 0-8) |
||||
|
time_stamp := 9 |
||||
|
repeat |
||||
|
reply := read_slow |
||||
|
while( reply & $80 ) and ( time_stamp-- ) |
||||
|
' done, and 'reply' is already pre-loaded |
||||
|
{ |
||||
|
if dbg_ptr < (dbg_end-1) |
||||
|
byte[dbg_ptr++] := cmd |
||||
|
byte[dbg_ptr++] := reply |
||||
|
if (cmd&63) == 13 |
||||
|
' get the second byte |
||||
|
byte[dbg_ptr++] := cmd |
||||
|
byte[dbg_ptr++] := read_slow |
||||
|
'} |
||||
|
|
||||
|
PRI send_slow( value, bits_to_send ) |
||||
|
value ><= bits_to_send |
||||
|
repeat bits_to_send |
||||
|
outa[pinCLK]~ |
||||
|
outa[pinDI] := value |
||||
|
value >>= 1 |
||||
|
outa[pinCLK]~~ |
||||
|
|
||||
|
PRI read_32_slow : r |
||||
|
repeat 4 |
||||
|
r <<= 8 |
||||
|
r |= read_slow |
||||
|
|
||||
|
PRI read_slow : r |
||||
|
{{ |
||||
|
Read back 8 bits from the card |
||||
|
}} |
||||
|
' we need the DI line high so a read can occur |
||||
|
outa[pinDI]~~ |
||||
|
' get 8 bits (remember, r is initialized to 0 by SPIN) |
||||
|
repeat 8 |
||||
|
outa[pinCLK]~ |
||||
|
outa[pinCLK]~~ |
||||
|
r += r + ina[pinDO] |
||||
|
' error check |
||||
|
if( (cnt - SPI_block_index) > (clkfreq << 2) ) |
||||
|
crash( ERR_CARD_BUSY_TIMEOUT ) |
||||
|
|
||||
|
DAT |
||||
|
{{ |
||||
|
This is the assembly engine for doing fast block |
||||
|
reads and writes. This is *ALL* it does! |
||||
|
}} |
||||
|
ORG 0 |
||||
|
SPI_engine_entry |
||||
|
' Counter A drives data out |
||||
|
mov ctra,writeMode |
||||
|
' Counter B will always drive my clock line |
||||
|
mov ctrb,clockLineMode |
||||
|
' set our output pins to match the pin mask |
||||
|
mov dira,maskAll |
||||
|
' handshake that we now control the pins |
||||
|
neg user_request,#1 |
||||
|
wrlong user_request,par |
||||
|
' start my seconds' counter here |
||||
|
mov last_time,cnt |
||||
|
|
||||
|
waiting_for_command |
||||
|
' update my seconds counter, but also track the idle |
||||
|
' time so we can to release the card after timeout. |
||||
|
call #handle_time |
||||
|
' read the command, and make sure it's from the user (> 0) |
||||
|
rdlong user_request,par |
||||
|
cmps user_request,#0 wz,wc |
||||
|
if_be jmp #waiting_for_command |
||||
|
' handle our card based commands |
||||
|
cmp user_request,#"r" wz |
||||
|
if_z jmp #read_ahead |
||||
|
cmp user_request,#"w" wz |
||||
|
if_z jmp #write_behind |
||||
|
cmp user_request,#"z" wz |
||||
|
if_z jmp #release_card |
||||
|
' time requests are handled differently |
||||
|
cmp user_request,#"t" wz ' time |
||||
|
if_z wrlong seconds,sdAdr ' seconds goes into the SD index register |
||||
|
if_z wrlong dtime,bufAdr ' the remainder goes into the buffer address register |
||||
|
' in all other cases, clear the user's request |
||||
|
mov user_request,#0 |
||||
|
wrlong user_request,par |
||||
|
jmp #waiting_for_command |
||||
|
|
||||
|
|
||||
|
release_card |
||||
|
mov user_cmd,#"z" ' request a release |
||||
|
neg lastIndexPlus,#1 ' reset the last block index |
||||
|
neg user_idx,#1 ' and make this match it |
||||
|
call #handle_command |
||||
|
mov user_request,user_cmd |
||||
|
wrlong user_request,par |
||||
|
jmp #waiting_for_command |
||||
|
|
||||
|
read_ahead |
||||
|
rdlong user_idx,sdAdr |
||||
|
' if the correct block is not already loaded, load it |
||||
|
mov tmp1,user_idx |
||||
|
add tmp1,#1 |
||||
|
cmp tmp1,lastIndexPlus wz |
||||
|
if_z cmp lastCommand,#"r" wz |
||||
|
if_z jmp #:get_on_with_it |
||||
|
mov user_cmd,#"r" |
||||
|
call #handle_command |
||||
|
:get_on_with_it |
||||
|
' copy the data up into Hub RAM |
||||
|
movi transfer_long,#%000010_000 'set to wrlong |
||||
|
call #hub_cog_transfer |
||||
|
' signify that the data is ready, Spin can continue |
||||
|
mov user_request,user_cmd |
||||
|
wrlong user_request,par |
||||
|
' request the next block |
||||
|
mov user_cmd,#"r" |
||||
|
add user_idx,#1 |
||||
|
call #handle_command |
||||
|
' done |
||||
|
jmp #waiting_for_command |
||||
|
|
||||
|
write_behind |
||||
|
rdlong user_idx,sdAdr |
||||
|
' copy data in from Hub RAM |
||||
|
movi transfer_long,#%000010_001 'set to rdlong |
||||
|
call #hub_cog_transfer |
||||
|
' signify that we have the data, Spin can continue |
||||
|
mov user_request,user_cmd |
||||
|
wrlong user_request,par |
||||
|
' write out the block |
||||
|
mov user_cmd,#"w" |
||||
|
call #handle_command |
||||
|
' done |
||||
|
jmp #waiting_for_command |
||||
|
|
||||
|
{{ |
||||
|
Set user_cmd and user_idx before calling this |
||||
|
}} |
||||
|
handle_command |
||||
|
' Can we stay in the old mode? (address = old_address+1) && (old mode == new_mode) |
||||
|
cmp lastIndexPlus,user_idx wz |
||||
|
if_z cmp user_cmd,lastCommand wz |
||||
|
if_z jmp #:execute_block_command |
||||
|
' we fell through, must exit the old mode! (except if the old mode was "release") |
||||
|
cmp lastCommand,#"w" wz |
||||
|
if_z call #stop_mb_write |
||||
|
cmp lastCommand,#"r" wz |
||||
|
if_z call #stop_mb_read |
||||
|
' and start up the new mode! |
||||
|
cmp user_cmd,#"w" wz |
||||
|
if_z call #start_mb_write |
||||
|
cmp user_cmd,#"r" wz |
||||
|
if_z call #start_mb_read |
||||
|
cmp user_cmd,#"z" wz |
||||
|
if_z call #release_DO |
||||
|
:execute_block_command |
||||
|
' track the (new) last index and command |
||||
|
mov lastIndexPlus,user_idx |
||||
|
add lastIndexPlus,#1 |
||||
|
mov lastCommand,user_cmd |
||||
|
' do the block read or write or terminate! |
||||
|
cmp user_cmd,#"w" wz |
||||
|
if_z call #write_single_block |
||||
|
cmp user_cmd,#"r" wz |
||||
|
if_z call #read_single_block |
||||
|
cmp user_cmd,#"z" wz |
||||
|
if_z mov user_cmd,#0 |
||||
|
' done |
||||
|
handle_command_ret |
||||
|
ret |
||||
|
|
||||
|
{=== these PASM functions get me in and out of multiblock mode ===} |
||||
|
release_DO |
||||
|
' we're already out of multiblock mode, so |
||||
|
' deselect the card and send out some clocks |
||||
|
or outa,maskCS |
||||
|
call #in8 |
||||
|
call #in8 |
||||
|
' if you are using pull-up resistors, and need all |
||||
|
' lines tristated, then uncomment the following line. |
||||
|
' for Cluso99 |
||||
|
'mov dira,#0 |
||||
|
release_DO_ret |
||||
|
ret |
||||
|
|
||||
|
start_mb_read |
||||
|
movi block_cmd,#CMD18<<1 |
||||
|
call #send_SPI_command_fast |
||||
|
start_mb_read_ret |
||||
|
ret |
||||
|
|
||||
|
stop_mb_read |
||||
|
movi block_cmd,#CMD12<<1 |
||||
|
call #send_SPI_command_fast |
||||
|
call #busy_fast |
||||
|
stop_mb_read_ret |
||||
|
ret |
||||
|
|
||||
|
start_mb_write |
||||
|
movi block_cmd,#CMD25<<1 |
||||
|
call #send_SPI_command_fast |
||||
|
start_mb_write_ret |
||||
|
ret |
||||
|
|
||||
|
stop_mb_write |
||||
|
call #busy_fast |
||||
|
' only some cards need these extra clocks |
||||
|
mov tmp1,#16 |
||||
|
:loopity |
||||
|
call #in8 |
||||
|
djnz tmp1,#:loopity |
||||
|
' done with hack |
||||
|
movi phsa,#$FD<<1 |
||||
|
call #out8 |
||||
|
call #in8 ' stuff byte |
||||
|
call #busy_fast |
||||
|
stop_mb_write_ret |
||||
|
ret |
||||
|
|
||||
|
send_SPI_command_fast |
||||
|
' make sure we have control of the output lines |
||||
|
mov dira,maskAll |
||||
|
' make sure the CS line transitions low |
||||
|
or outa,maskCS |
||||
|
andn outa,maskCS |
||||
|
' 8 clocks |
||||
|
call #in8 |
||||
|
' send the data |
||||
|
mov phsa,block_cmd ' do which ever block command this is (already in the top 8 bits) |
||||
|
call #out8 ' write the byte |
||||
|
mov phsa,user_idx ' read in the desired block index |
||||
|
shl phsa,adrShift ' this will multiply by 512 (bytes/sector) for MMC and SD |
||||
|
call #out8 ' move out the 1st MSB ' |
||||
|
rol phsa,#1 |
||||
|
call #out8 ' move out the 1st MSB ' |
||||
|
rol phsa,#1 |
||||
|
call #out8 ' move out the 1st MSB ' |
||||
|
rol phsa,#1 |
||||
|
call #out8 ' move out the 1st MSB ' |
||||
|
' bogus CRC value |
||||
|
call #in8 ' in8 looks like out8 with $FF |
||||
|
' CMD12 requires a stuff byte |
||||
|
shr block_cmd,#24 |
||||
|
cmp block_cmd,#CMD12 wz |
||||
|
if_z call #in8 ' 8 clocks |
||||
|
' get the response |
||||
|
mov tmp1,#9 |
||||
|
:cmd_response |
||||
|
call #in8 |
||||
|
test readback,#$80 wc,wz |
||||
|
if_c djnz tmp1,#:cmd_response |
||||
|
if_nz neg user_cmd,readback |
||||
|
' done |
||||
|
send_SPI_command_fast_ret |
||||
|
ret |
||||
|
|
||||
|
|
||||
|
busy_fast |
||||
|
mov tmp1,N_in8_500ms |
||||
|
:still_busy |
||||
|
call #in8 |
||||
|
cmp readback,#$FF wz |
||||
|
if_nz djnz tmp1,#:still_busy |
||||
|
busy_fast_ret |
||||
|
ret |
||||
|
|
||||
|
|
||||
|
out8 |
||||
|
andn outa,maskDI |
||||
|
'movi phsb,#%11_0000000 |
||||
|
mov phsb,#0 |
||||
|
movi frqb,#%01_0000000 |
||||
|
rol phsa,#1 |
||||
|
rol phsa,#1 |
||||
|
rol phsa,#1 |
||||
|
rol phsa,#1 |
||||
|
rol phsa,#1 |
||||
|
rol phsa,#1 |
||||
|
rol phsa,#1 |
||||
|
mov frqb,#0 |
||||
|
' don't shift out the final bit...already sent, but be aware |
||||
|
' of this when sending consecutive bytes (send_cmd, for e.g.) |
||||
|
out8_ret |
||||
|
ret |
||||
|
|
||||
|
{ |
||||
|
in8 |
||||
|
or outa,maskDI |
||||
|
mov ctra,readMode |
||||
|
' Start my clock |
||||
|
mov frqa,#1<<7 |
||||
|
mov phsa,#0 |
||||
|
movi phsb,#%11_0000000 |
||||
|
movi frqb,#%01_0000000 |
||||
|
' keep reading in my value, one bit at a time! (Kuneko - "Wh) |
||||
|
shr frqa,#1 |
||||
|
shr frqa,#1 |
||||
|
shr frqa,#1 |
||||
|
shr frqa,#1 |
||||
|
shr frqa,#1 |
||||
|
shr frqa,#1 |
||||
|
shr frqa,#1 |
||||
|
mov frqb,#0 ' stop the clock |
||||
|
mov readback,phsa |
||||
|
mov frqa,#0 |
||||
|
mov ctra,writeMode |
||||
|
in8_ret |
||||
|
ret |
||||
|
} |
||||
|
in8 |
||||
|
neg phsa,#1' DI high |
||||
|
mov readback,#0 |
||||
|
' set up my clock, and start it |
||||
|
movi phsb,#%011_000000 |
||||
|
movi frqb,#%001_000000 |
||||
|
' keep reading in my value |
||||
|
test maskDO,ina wc |
||||
|
rcl readback,#1 |
||||
|
test maskDO,ina wc |
||||
|
rcl readback,#1 |
||||
|
test maskDO,ina wc |
||||
|
rcl readback,#1 |
||||
|
test maskDO,ina wc |
||||
|
rcl readback,#1 |
||||
|
test maskDO,ina wc |
||||
|
rcl readback,#1 |
||||
|
test maskDO,ina wc |
||||
|
rcl readback,#1 |
||||
|
test maskDO,ina wc |
||||
|
rcl readback,#1 |
||||
|
test maskDO,ina wc |
||||
|
mov frqb,#0 ' stop the clock |
||||
|
rcl readback,#1 |
||||
|
mov phsa,#0 'DI low |
||||
|
in8_ret |
||||
|
ret |
||||
|
|
||||
|
|
||||
|
' this is called more frequently than 1 Hz, and |
||||
|
' is only called when the user command is 0. |
||||
|
handle_time |
||||
|
mov tmp1,cnt ' get the current timestamp |
||||
|
add idle_time,tmp1 ' add the current time to my idle time counter |
||||
|
sub idle_time,last_time ' subtract the last time from my idle counter (hence delta) |
||||
|
add dtime,tmp1 ' add to my accumulator, |
||||
|
sub dtime,last_time ' and subtract the old (adding delta) |
||||
|
mov last_time,tmp1 ' update my "last timestamp" |
||||
|
rdlong tmp1,#0 ' what is the clock frequency? |
||||
|
cmpsub dtime,tmp1 wc ' if I have more than a second in my accumulator |
||||
|
addx seconds,#0 ' then add it to "seconds" |
||||
|
' this part is to auto-release the card after a timeout |
||||
|
cmp idle_time,idle_limit wz,wc |
||||
|
if_b jmp #handle_time_ret ' don't clear if we haven't hit the limit |
||||
|
mov user_cmd,#"z" ' we can't overdo it, the command handler makes sure |
||||
|
neg lastIndexPlus,#1 ' reset the last block index |
||||
|
neg user_idx,#1 ' and make this match it |
||||
|
call #handle_command ' release the card, but don't mess with the user's request register |
||||
|
handle_time_ret |
||||
|
ret |
||||
|
|
||||
|
hub_cog_transfer |
||||
|
' setup for all 4 passes |
||||
|
mov ctrb,clockXferMode |
||||
|
mov frqb,#1 |
||||
|
rdlong buf_ptr,bufAdr |
||||
|
mov ops_left,#4 |
||||
|
movd transfer_long,#speed_buf |
||||
|
four_transfer_passes |
||||
|
' sync to the Hub RAM access |
||||
|
rdlong tmp1,tmp1 |
||||
|
' how many long to move on this pass? (512 bytes / 4)longs / 4 passes |
||||
|
mov tmp1,#(512 / 4 / 4) |
||||
|
' get my starting address right (phsb is incremented 1 per clock, so 16 each Hub access) |
||||
|
mov phsb,buf_ptr |
||||
|
' write the longs, stride 4...low 2 bits of phsb are ignored |
||||
|
transfer_long |
||||
|
rdlong 0-0,phsb |
||||
|
add transfer_long,incDest4 |
||||
|
djnz tmp1,#transfer_long |
||||
|
' go back to where I started, but advanced 1 long |
||||
|
sub transfer_long,decDestNminus1 |
||||
|
' offset my Hub pointer by one long per pass |
||||
|
add buf_ptr,#4 |
||||
|
' do all 4 passes |
||||
|
djnz ops_left,#four_transfer_passes |
||||
|
' restore the counter mode |
||||
|
mov frqb,#0 |
||||
|
mov phsb,#0 |
||||
|
mov ctrb,clockLineMode |
||||
|
hub_cog_transfer_ret |
||||
|
ret |
||||
|
|
||||
|
|
||||
|
read_single_block |
||||
|
' where am I sending the data? |
||||
|
movd :store_read_long,#speed_buf |
||||
|
mov ops_left,#128 |
||||
|
' wait until the card is ready |
||||
|
mov tmp1,N_in8_500ms |
||||
|
:get_resp |
||||
|
call #in8 |
||||
|
cmp readback,#$FE wz |
||||
|
if_nz djnz tmp1,#:get_resp |
||||
|
if_nz neg user_cmd,#ERR_ASM_NO_READ_TOKEN |
||||
|
if_nz jmp #read_single_block_ret |
||||
|
' set DI high |
||||
|
neg phsa,#1 |
||||
|
' read the data |
||||
|
mov ops_left,#128 |
||||
|
:read_loop |
||||
|
mov tmp1,#4 |
||||
|
movi phsb,#%011_000000 |
||||
|
:in_byte |
||||
|
' Start my clock |
||||
|
movi frqb,#%001_000000 |
||||
|
' keep reading in my value, BACKWARDS! (Brilliant idea by Tom Rokicki!) |
||||
|
test maskDO,ina wc |
||||
|
rcl readback,#8 |
||||
|
test maskDO,ina wc |
||||
|
muxc readback,#2 |
||||
|
test maskDO,ina wc |
||||
|
muxc readback,#4 |
||||
|
test maskDO,ina wc |
||||
|
muxc readback,#8 |
||||
|
test maskDO,ina wc |
||||
|
muxc readback,#16 |
||||
|
test maskDO,ina wc |
||||
|
muxc readback,#32 |
||||
|
test maskDO,ina wc |
||||
|
muxc readback,#64 |
||||
|
test maskDO,ina wc |
||||
|
mov frqb,#0 ' stop the clock |
||||
|
muxc readback,#128 |
||||
|
' go back for more |
||||
|
djnz tmp1,#:in_byte |
||||
|
' make it...NOT backwards [8^) |
||||
|
rev readback,#0 |
||||
|
:store_read_long |
||||
|
mov 0-0,readback ' due to some counter weirdness, we need this mov |
||||
|
add :store_read_long,const512 |
||||
|
djnz ops_left,#:read_loop |
||||
|
|
||||
|
' set DI low |
||||
|
mov phsa,#0 |
||||
|
|
||||
|
' now read 2 trailing bytes (CRC) |
||||
|
call #in8 ' out8 is 2x faster than in8 |
||||
|
call #in8 ' and I'm not using the CRC anyway |
||||
|
' give an extra 8 clocks in case we pause for a long time |
||||
|
call #in8 ' in8 looks like out8($FF) |
||||
|
|
||||
|
' all done successfully |
||||
|
mov idle_time,#0 |
||||
|
mov user_cmd,#0 |
||||
|
read_single_block_ret |
||||
|
ret |
||||
|
|
||||
|
write_single_block |
||||
|
' where am I getting the data? (all 512 bytes / 128 longs of it?) |
||||
|
movs :write_loop,#speed_buf |
||||
|
' read in 512 bytes (128 longs) from Hub RAM and write it to the card |
||||
|
mov ops_left,#128 |
||||
|
' just hold your horses |
||||
|
call #busy_fast |
||||
|
' $FC for multiblock, $FE for single block |
||||
|
movi phsa,#$FC<<1 |
||||
|
call #out8 |
||||
|
mov phsb,#0 ' make sure my clock accumulator is right |
||||
|
'movi phsb,#%11_0000000 |
||||
|
:write_loop |
||||
|
' read 4 bytes |
||||
|
mov phsa,speed_buf |
||||
|
add :write_loop,#1 |
||||
|
' a long in LE order is DCBA |
||||
|
rol phsa,#24 ' move A7 into position, so I can do the swizzled version |
||||
|
movi frqb,#%010000000 ' start the clock (remember A7 is already in place) |
||||
|
rol phsa,#1 ' A7 is going out, at the end of this instr, A6 is in place |
||||
|
rol phsa,#1 ' A5 |
||||
|
rol phsa,#1 ' A4 |
||||
|
rol phsa,#1 ' A3 |
||||
|
rol phsa,#1 ' A2 |
||||
|
rol phsa,#1 ' A1 |
||||
|
rol phsa,#1 ' A0 |
||||
|
rol phsa,#17 ' B7 |
||||
|
rol phsa,#1 ' B6 |
||||
|
rol phsa,#1 ' B5 |
||||
|
rol phsa,#1 ' B4 |
||||
|
rol phsa,#1 ' B3 |
||||
|
rol phsa,#1 ' B2 |
||||
|
rol phsa,#1 ' B1 |
||||
|
rol phsa,#1 ' B0 |
||||
|
rol phsa,#17 ' C7 |
||||
|
rol phsa,#1 ' C6 |
||||
|
rol phsa,#1 ' C5 |
||||
|
rol phsa,#1 ' C4 |
||||
|
rol phsa,#1 ' C3 |
||||
|
rol phsa,#1 ' C2 |
||||
|
rol phsa,#1 ' C1 |
||||
|
rol phsa,#1 ' C0 |
||||
|
rol phsa,#17 ' D7 |
||||
|
rol phsa,#1 ' D6 |
||||
|
rol phsa,#1 ' D5 |
||||
|
rol phsa,#1 ' D4 |
||||
|
rol phsa,#1 ' D3 |
||||
|
rol phsa,#1 ' D2 |
||||
|
rol phsa,#1 ' D1 |
||||
|
rol phsa,#1 ' D0 will be in place _after_ this instruction |
||||
|
mov frqb,#0 ' shuts the clock off, _after_ this instruction |
||||
|
djnz ops_left,#:write_loop |
||||
|
' write out my two (bogus, using $FF) CRC bytes |
||||
|
call #in8 |
||||
|
call #in8 |
||||
|
' now read response (I need this response, so can't spoof using out8) |
||||
|
call #in8 |
||||
|
and readback,#$1F |
||||
|
cmp readback,#5 wz |
||||
|
if_z mov user_cmd,#0 ' great |
||||
|
if_nz neg user_cmd,#ERR_ASM_BLOCK_NOT_WRITTEN ' oops |
||||
|
' send out another 8 clocks |
||||
|
call #in8 |
||||
|
' all done |
||||
|
mov idle_time,#0 |
||||
|
write_single_block_ret |
||||
|
ret |
||||
|
|
||||
|
|
||||
|
{=== Assembly Interface Variables ===} |
||||
|
pinDO long 0 ' pin is controlled by a counter |
||||
|
pinCLK long 0 ' pin is controlled by a counter |
||||
|
pinDI long 0 ' pin is controlled by a counter |
||||
|
maskDO long 0 ' mask for reading the DO line from the card |
||||
|
maskDI long 0 ' mask for setting the pin high while reading |
||||
|
maskCS long 0 ' mask = (1<<pin), and is controlled directly |
||||
|
maskAll long 0 |
||||
|
adrShift long 9 ' will be 0 for SDHC, 9 for MMC & SD |
||||
|
bufAdr long 0 ' where in Hub RAM is the buffer to copy to/from? |
||||
|
sdAdr long 0 ' where on the SD card does it read/write? |
||||
|
writeMode long 0 ' the counter setup in NCO single ended, clocking data out on pinDI |
||||
|
'clockOutMode long 0 ' the counter setup in NCO single ended, driving the clock line on pinCLK |
||||
|
N_in8_500ms long 1_000_000 ' used for timeout checking in PASM |
||||
|
'readMode long 0 |
||||
|
clockLineMode long 0 |
||||
|
clockXferMode long %11111 << 26 |
||||
|
const512 long 512 |
||||
|
const1024 long 1024 |
||||
|
incDest4 long 4 << 9 |
||||
|
decDestNminus1 long (512 / 4 - 1) << 9 |
||||
|
|
||||
|
{=== Initialized PASM Variables ===} |
||||
|
seconds long 0 |
||||
|
dtime long 0 |
||||
|
idle_time long 0 |
||||
|
idle_limit long 0 |
||||
|
|
||||
|
{=== Multiblock State Machine ===} |
||||
|
lastIndexPlus long -1 ' state handler will check against lastIndexPlus, which will not have been -1 |
||||
|
lastCommand long 0 ' this will never be the last command. |
||||
|
|
||||
|
{=== Debug Logging Pointers ===} |
||||
|
{ |
||||
|
dbg_ptr long 0 |
||||
|
dbg_end long 0 |
||||
|
'} |
||||
|
|
||||
|
{=== Assembly Scratch Variables ===} |
||||
|
ops_left res 1 ' used as a counter for bytes, words, longs, whatever (start w/ # byte clocks out) |
||||
|
readback res 1 ' all reading from the card goes through here |
||||
|
tmp1 res 1 ' this may get used in all subroutines...don't use except in lowest |
||||
|
user_request res 1 ' the main command variable, read in from Hub: "r"-read single, "w"-write single |
||||
|
user_cmd res 1 ' used internally to handle actual commands to be executed |
||||
|
user_idx res 1 ' the pointer to the Hub RAM where the data block is/goes |
||||
|
block_cmd res 1 ' one of the SD/MMC command codes, no app-specific allowed |
||||
|
buf_ptr res 1 ' moving pointer to the Hub RAM buffer |
||||
|
last_time res 1 ' tracking the timestamp |
||||
|
|
||||
|
{{ |
||||
|
496 longs is my total available space in the cog, |
||||
|
and I want 128 longs for eventual use as one 512- |
||||
|
byte buffer. This gives me a total of 368 longs |
||||
|
to use for umount, and a readblock and writeblock |
||||
|
for both Hub RAM and Cog buffers. |
||||
|
}} |
||||
|
speed_buf res 128 ' 512 bytes to be used for read-ahead / write-behind |
||||
|
|
||||
|
'fit 467 |
||||
|
FIT 496 |
||||
|
|
||||
|
'' 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. |
||||
|
}} |
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Loading…
Reference in new issue