--- /dev/null
+# Initialisation.
+set manufacturer_code 1F
+
+set test "sid configuration"
+sid_config_component_test "am29.conf" \
+ "load libmemory.la mem_component_library" \
+ "hw-memory-flash-am29"
+pass $test
+
+proc write_seq {pairs} {
+ global victim
+ set bus [sid_cmd "sid::component::find_bus $victim read-write-port"]
+ foreach pair $pairs {
+ set addr [lindex $pair 0]
+ set data [lindex $pair 1]
+ set result [sid_cmd "sid::bus::write_h4_l1 $bus $addr $data"]
+ if ![sid_bus_ok_p $result] { return 0 }
+ }
+ return 1
+}
+
+proc erase_mode {} {
+ return [write_seq {{0x555 0xAA} {0x2AA 0x55} {0x555 0x80} \
+ {0x555 0xAA} {0x2AA 0x55} {0x555 0x10}}]
+}
+
+proc sector_erase_mode {} {
+ return [write_seq {{0x555 0xAA} {0x2AA 0x55} {0x555 0x80} \
+ {0x555 0xAA} {0x2AA 0x55}}]
+}
+
+proc autoselect_mode {} {
+ return [write_seq {{0x555 0xAA} {0x2AA 0x55} {0x555 0x90}}]
+}
+
+proc program_mode {} {
+ return [write_seq {{0x555 0xAA} {0x2AA 0x55} {0x555 0xA0}}]
+}
+
+proc bypass_mode {} {
+ return [write_seq {{0x555 0xAA} {0x2AA 0x55} {0x555 0x20}}]
+}
+
+set test "sid start"
+if {[sid_start "am29.conf"]} { pass $test } else { fail $test ; return }
+
+set test "attribute list"
+sid_assert_includes_all "sid::component::attribute_names $victim" \
+ { image-file image-load image-store device-code manufacturer-code \
+ mode state-snapshot sector-size size-max size }
+
+set test "read-write-port bus is present"
+set result [sid_cmd "sid::component::find_bus $victim read-write-port"]
+if {$result != ""} { pass $test } else { fail $test }
+
+
+# Test various sector sizes.
+
+foreach bad_sectorsize {0 123456789} {
+ set test "set an invalid sector size of $bad_sectorsize bytes"
+ set result [sid_cmd \
+ "sid::component::set_attribute_value $victim sector-size $bad_sectorsize"]
+ if {$result == "bad_value"} { pass $test } else { fail $test}
+}
+
+foreach sectorsize {16 32 128 256 512 1024} {
+ set test "set and validate sector size of $sectorsize bytes"
+ sid_cmd "sid::component::set_attribute_value $victim sector-size $sectorsize"
+ set result [sid_cmd "sid::component::attribute_value $victim sector-size"]
+ if {"$result" == "$sectorsize"} { pass $test } else {
+ fail "$test -- got $result and $sectorsize"
+ }
+}
+
+set test "validate memory is fully erased from the factory"
+set okay 1
+set bus [sid_cmd "sid::component::find_bus $victim read-write-port"]
+foreach addr {100 200 300 512 968 1024 2048 3000} {
+ set result [sid_cmd "sid::bus::read_h4_l1 $bus $addr"]
+ if {![sid_bus_ok_p $result] || [lindex $result 1] != "0xFF"} {
+ set okay 0
+ fail "$test -- got unexpected $result @ address $addr"
+ break
+ }
+}
+if {$okay} { pass $test }
+
+# FIXME: use a coder instead of the raw enum values.
+
+set test "initial mode is READ (0)"
+set result [sid_cmd "sid::component::attribute_value $victim mode"]
+if {$result == "0"} {
+ pass $test
+} else {
+ fail "$test -- got $result, expected 0"
+}
+
+# Enter autoselect mode. Check the mode at each step.
+
+set test "enter autoselect mode"
+set bus [sid_cmd "sid::component::find_bus $victim read-write-port"]
+set okay 1
+
+foreach triplet {{0x555 0xAA 1} {0x2AA 0x55 2} {0x555 0x90 3}} {
+ set addr [lindex $triplet 0]
+ set data [lindex $triplet 1]
+ set expected_mode [lindex $triplet 2]
+
+ set result [sid_cmd "sid::bus::write_h4_l1 $bus $addr $data"]
+ if ![sid_bus_ok_p $result] {
+ fail "$test -- error at $addr: $result"
+ set okay 0
+ break
+ }
+ set mode [sid_cmd "sid::component::attribute_value $victim mode"]
+ if {$mode != $expected_mode} {
+ fail "$test -- did not switch to correct internal state"
+ set okay 0
+ break
+ }
+}
+if {$okay} { pass $test }
+
+
+set test "return to read mode"
+set bus [sid_cmd "sid::component::find_bus $victim read-write-port"]
+set result [sid_cmd "sid::bus::write_h4_l1 $bus 0x123 0xF0"]
+if [sid_bus_ok_p $result] {
+ set mode [sid_cmd "sid::component::attribute_value $victim mode"]
+ if {$mode == "0"} {
+ pass $test
+ } else {
+ fail "$test -- did not switch to read mode"
+ }
+} else {
+ fail "$test -- bus error: $result"
+}
+
+set test "invalid unlock1 sequence sends device to read mode"
+set bus [sid_cmd "sid::component::find_bus $victim read-write-port"]
+set okay 1
+foreach triplet {{0x555 0xAA 1} {0x2AA 0x54 0}} {
+ set addr [lindex $triplet 0]
+ set data [lindex $triplet 1]
+ set expected_mode [lindex $triplet 2]
+
+ set result [sid_cmd "sid::bus::write_h4_l1 $bus $addr $data"]
+ if ![sid_bus_ok_p $result] {
+ fail "$test -- error at $addr: $result"
+ set okay 0
+ break
+ }
+ set mode [sid_cmd "sid::component::attribute_value $victim mode"]
+ if {$mode != $expected_mode} {
+ fail "$test -- did not switch to correct internal state"
+ set okay 0
+ break
+ }
+}
+if {$okay} { pass $test }
+
+
+set test "invalid unlock2 sequence sends device to read mode"
+set bus [sid_cmd "sid::component::find_bus $victim read-write-port"]
+set okay 1
+foreach triplet {{0x555 0xAA 1} {0x2AA 0x55 2} {0x555 0x91 0}} {
+ set addr [lindex $triplet 0]
+ set data [lindex $triplet 1]
+ set expected_mode [lindex $triplet 2]
+
+ set result [sid_cmd "sid::bus::write_h4_l1 $bus $addr $data"]
+ if ![sid_bus_ok_p $result] {
+ fail "$test -- error at $addr: $result"
+ set okay 0
+ break
+ }
+ set mode [sid_cmd "sid::component::attribute_value $victim mode"]
+ if {$mode != $expected_mode} {
+ fail "$test -- did not switch to correct internal state"
+ set okay 0
+ break
+ }
+}
+if {$okay} { pass $test }
+
+
+set test "autoselect mode allows multiple reads of info addresses"
+set bus [sid_cmd "sid::component::find_bus $victim read-write-port"]
+if {[autoselect_mode]} {
+ foreach addr {0 1 0 1 1 0 0} {
+ set mode [sid_cmd "sid::component::attribute_value $victim mode"]
+ if {$mode != "3"} {
+ fail "$test -- not in autoselect mode; in mode $mode"
+ break
+ }
+ set result [sid_cmd "sid::bus::read_h4_l1 $bus $addr"]
+ if ![sid_bus_ok_p $result] {
+ fail "$test -- bus error"
+ break
+ }
+ }
+} else {
+ fail "$test -- did not enter autoselect mode"
+}
+
+set test "issue reset command"
+set bus [sid_cmd "sid::component::find_bus $victim read-write-port"]
+set mode [sid_cmd "sid::component::attribute_value $victim mode"]
+if {$mode != "3"} {
+ fail "$test -- prior test should have left the device in autoselect mode"
+} else {
+ set result [sid_cmd "sid::bus::write_h4_l1 $bus 0x123 0xF0"]
+ if ![sid_bus_ok_p $result] {
+ fail "$test -- bus error"
+ } else {
+ set mode [sid_cmd "sid::component::attribute_value $victim mode"]
+ if {$mode == "0"} {
+ pass $test
+ } else {
+ fail "$test -- in mode $mode, expected mode 0"
+ }
+ }
+}
+
+
+set test "read manufacturer code without entering autoselect mode"
+set bus [sid_cmd "sid::component::find_bus $victim read-write-port"]
+set result [sid_cmd "sid::bus::read_h4_l1 $bus 0"]
+if {[sid_bus_ok_p $result] && [lindex $result 1] != 0x1F} {
+ pass $test
+} else {
+ fail "$test -- read 0x1F from address 0!"
+}
+
+
+set test "read device id code without entering autoselect mode"
+set bus [sid_cmd "sid::component::find_bus $victim read-write-port"]
+set result [sid_cmd "sid::bus::read_h4_l1 $bus 1"]
+sid_cmd "sid::component::set_attribute_value $victim device-code 0x4F"
+if {[sid_bus_ok_p $result] && [lindex $result 1] != 0x4F} {
+ pass $test
+} else {
+ fail "$test -- read 0x4F from address 1!"
+}
+
+
+set test "read manufacturer code"
+set bus [sid_cmd "sid::component::find_bus $victim read-write-port"]
+if {![autoselect_mode]} {
+ fail $test
+} else {
+ set result [sid_cmd "sid::bus::read_h4_l1 $bus 0"]
+ if {[sid_bus_ok_p $result] && [lindex $result 1] == "0x01"} {
+ pass $test
+ } else {
+ fail "$test -- expected 0x01, got $result"
+ }
+}
+
+
+set test "read device id code for a typical flash (id=0x4F)"
+set bus [sid_cmd "sid::component::find_bus $victim read-write-port"]
+sid_cmd "sid::component::set_attribute_value $victim device-code 0x4F"
+set result [sid_cmd "sid::bus::read_h4_l1 $bus 1"]
+if {[sid_bus_ok_p $result] && [lindex $result 1] == "0x4F"} {
+ pass $test
+} else {
+ fail "$test -- expected 0x4F, got $result"
+}
+
+set test "read sector protect verify status for each sector address"
+set okay 1
+set sectorsize [sid_cmd "sid::component::attribute_value $victim sector-size"]
+set memsize [sid_cmd "sid::component::attribute_value $victim size"]
+set numsectors [expr $memsize / $sectorsize]
+set bus [sid_cmd "sid::component::find_bus $victim read-write-port"]
+for {set i 0} {$i < $numsectors} {incr i} {
+ set addr [expr [expr $i << 16] | 2]
+ set result [sid_cmd "sid::bus::read_h4_l1 $bus $addr"]
+ if {![sid_bus_ok_p $result] || [lindex $result 1] != "0"} {
+ fail "$test -- expected {ok,0}, got $result"
+ set okay 0
+ break
+ }
+}
+if {$okay} {pass $test}
+
+
+set test "return to read mode"
+set mode [sid_cmd "sid::component::attribute_value $victim mode"]
+if {$mode == "0"} {
+ fail "$test -- mode is already 0"
+} else {
+ sid_cmd "sid::bus::write_h4_l1 $bus 0x123 0xF0"
+ set result [sid_cmd "sid::component::attribute_value $victim mode"]
+ if {$result == "0"} {
+ pass $test
+ } else {
+ fail "$test -- in mode $result, expected mode 0"
+ }
+}
+
+
+set test "set size to 512 bytes"
+sid_assert_success "sid::component::set_attribute_value $victim size 512"
+
+set test "validate size is 512 bytes"
+set size [sid_cmd "sid::component::attribute_value $victim size"]
+if {$size == "512"} { pass $test } else { fail $test }
+
+
+set test "test for memory leaks"
+set iterations 100
+for {set i 0} {$i < $iterations} {incr i} {
+ # some size between 1 .. 16MB
+ set size [expr {1000000 + (($i * 101) % 16) * 1000000}]
+ sid_cmd "sid::component::set_attribute_value $victim size $size"
+}
+sid_assert_success "sid::component::set_attribute_value $victim size 0"
+
+
+set test "set memory size to 8192 bytes"
+sid_cmd "sid::component::set_attribute_value $victim size 8192"
+set memsize [sid_cmd "sid::component::attribute_value $victim size"]
+if {$memsize == "8192"} { pass $test } else { fail $test }
+
+
+set test "set sector size to 256 bytes"
+sid_cmd "sid::component::set_attribute_value $victim sector-size 256"
+set sectorsize [sid_cmd "sid::component::attribute_value $victim sector-size"]
+if {$sectorsize == "256"} { pass $test } else { fail $test }
+
+
+set test "chip erase sets all ones"
+set bus [sid_cmd "sid::component::find_bus $victim read-write-port"]
+set okay 1
+# First, preprogram a few locations with zero.
+set size [sid_cmd "sid::component::attribute_value $victim size"]
+for {set i 0} {$i < $size} {set i [expr $i + 256]} {
+ if {[program_mode]} {
+ set result [sid_cmd "sid::bus::write_h4_l1 $bus $i 0"]
+ if ![sid_bus_ok_p $result] { fail $test; set okay 0; break }
+ } else {
+ fail "$test -- failed to enter programming mode"; set okay 0; break
+ }
+}
+if {$okay && [erase_mode]} {
+ set mode [sid_cmd "sid::component::attribute_value $victim mode"]
+ if {$mode != "0"} {
+ fail "$test -- did not return to read mode"; set okay 0; break
+ } else {
+ # Validate all ones are set in locations previously set to 0.
+ for {set i 0} {$i < $size} {set i [expr $i + 256]} {
+ set result [sid_cmd "sid::bus::read_h4_l1 $bus $i"]
+ if {![sid_bus_ok_p $result] || [lindex $result 1] != "0xFF"} {
+ fail "$test -- @ $i expected {ok,0xFF} got $result"
+ set okay 0
+ break
+ }
+ }
+ }
+}
+if {$okay} {pass $test}
+
+
+set test "write a single byte"
+set bus [sid_cmd "sid::component::find_bus $victim read-write-port"]
+if {[program_mode]} {
+ if {[sid_cmd "sid::component::attribute_value $victim mode"] == "4"} {
+ set result [sid_cmd "sid::bus::write_h4_l1 $bus 0x123 0x39"]
+ if [sid_bus_ok_p $result] {
+ set mode [sid_cmd "sid::component::attribute_value $victim mode"]
+ if {$mode == "0"} {
+ pass $test
+ } else { fail $test }
+ } else { fail $test }
+ } else { fail $test }
+} else { fail $test }
+
+
+set test "write lots of bytes across sector boundaries"
+set bus [sid_cmd "sid::component::find_bus $victim read-write-port"]
+set okay 1
+foreach addr {0x10 0x39 0x120 0x290 0x391 0x500 0x800 0x1024 0x1701} {
+ if {[program_mode]} {
+ if {[sid_cmd "sid::component::attribute_value $victim mode"] == "4"} {
+ set result [sid_cmd "sid::bus::write_h4_l1 $bus $addr 0x39"]
+ if [sid_bus_ok_p $result] {
+ if {[sid_cmd "sid::component::attribute_value $victim mode"] == "0"} {
+ pass $test
+ } else {
+ fail "$test -- restored mode is not 0"; set okay 0; break
+ }
+ } else {
+ fail "$test -- bus error @ $addr: $result"; set okay 0; break
+ }
+ } else {
+ fail "$test -- mode is not 4"; set okay 0; break
+ }
+ } else {
+ fail "$test -- failed to enter programming mode"; set okay 0; break
+ }
+}
+if {$okay} { pass $test } else { fail $test }
+
+
+set test "validate freshly written bytes"
+set bus [sid_cmd "sid::component::find_bus $victim read-write-port"]
+set okay 1
+foreach addr {0x10 0x39 0x120 0x290 0x391 0x500 0x800 0x1024 0x1701} {
+ set result [sid_cmd "sid::bus::read_h4_l1 $bus $addr"]
+ if {[sid_bus_ok_p $result] && [lindex $result 1] == "0x39"} {
+ pass $test
+ } else {
+ fail "$test -- mismatch @ $addr: [lindex $result 1] != 0x39"
+ }
+}
+
+set test "enter unlock bypass mode"
+set bus [sid_cmd "sid::component::find_bus $victim read-write-port"]
+if {[bypass_mode]} {
+ set mode [sid_cmd "sid::component::attribute_value $victim mode"]
+ if {$mode == "8"} {
+ pass $test
+ } else {
+ fail "$test -- expected mode 8, got mode $mode"
+ }
+} else {
+ fail "$test -- unable to enter bypass mode"
+}
+
+
+set test "reset from unlock bypass mode to read mode"
+set bus [sid_cmd "sid::component::find_bus $victim read-write-port"]
+set result [sid_cmd "sid::bus::write_h4_l1 $bus 0x123 0x90"]
+set mode [sid_cmd "sid::component::attribute_value $victim mode"]
+if {![sid_bus_ok_p $result] || $mode != "9"} {
+ fail "$test -- expected ok,9, got $result,$mode"
+} else {
+ set result [sid_cmd "sid::bus::write_h4_l1 $bus 0x123 0x00"]
+ set mode [sid_cmd "sid::component::attribute_value $victim mode"]
+ if [sid_bus_ok_p $result] {
+ if {$mode == "0"} {
+ pass $test
+ } else {
+ fail "$test -- expected mode 0, got mode $mode"
+ }
+ } else {
+ fail "$test -- bus error ($result)"
+ }
+}
+
+
+set test "unlock bypass program"
+set bus [sid_cmd "sid::component::find_bus $victim read-write-port"]
+if {[bypass_mode]} {
+ set result [sid_cmd "sid::bus::write_h4_l1 $bus 0x123 0xA0"]
+ if ![sid_bus_ok_p $result] {
+ fail "$test -- bus error ($result)"
+ } else {
+ set mode [sid_cmd "sid::component::attribute_value $victim mode"]
+ if {$mode == "4"} {
+ set result [sid_cmd "sid::bus::write_h4_l1 $bus 0x123 0x77"]
+ if ![sid_bus_ok_p $result] {
+ fail "$test -- bus error ($result)"
+ set result [sid_cmd "sid::bus::read_h4_l1 $bus 0x123"]
+ if {[sid_bus_ok_p $result] || [lindex $result 1] != "0x77"} {
+ fail "$test -- expected ok,0x77, got $result"
+ } else {
+ pass $test
+ }
+ }
+ } else {
+ fail "$test -- expected mode 4, got mode $mode"
+ }
+ }
+} else {
+ fail "$test -- unable to enter bypass mode"
+}
+
+
+# Test that a zero bit cannot be reprogrammed to a 1.
+# Use FF and 00 as the test bytes, for simplicity.
+
+set test "a zero cannot be reset to a one in any location"
+if {![program_mode]} {
+ fail "$test -- unable to enter programming mode"
+} else {
+ set result [sid_cmd "sid::bus::write_h4_l1 $bus 0x123 0"]
+ if ![sid_bus_ok_p $result] {
+ fail "$test -- bus error ($result)"
+ } else {
+ set result [sid_cmd "sid::bus::read_h4_l1 $bus 0x123"]
+ if ![sid_bus_ok_p $result] {
+ fail "$test -- bus error ($result)"
+ } else {
+ if {[lindex $result 1] != "0"} {
+ fail "$test -- expected 0, got [lindex $result 1]"
+ } else {
+ program_mode
+ set result [sid_cmd "sid::bus::write_h4_l1 $bus 0x123 0xFF"]
+ if ![sid_bus_ok_p $result] {
+ fail "$test -- bus error ($result)"
+ } else {
+ set result [sid_cmd "sid::bus::read_h4_l1 $bus 0x123"]
+ if ![sid_bus_ok_p $result] {
+ fail "$test -- bus error ($result)"
+ } else {
+ if {[lindex $result 1] != "0"} {
+ fail "$test -- expected 0, got [lindex $result 1]"
+ } else {
+ # Woohoo!
+ pass $test
+ }
+ }
+ }
+ }
+ }
+ }
+}
+
+# Test sector erase.
+# Erase sector 1, leaving sectors 0 and 2 unmodified.
+# ss = sector size
+#
+# Before:
+# 0 1 2 3
+# +------------+------------+----------+
+# | 7777777777 | 7777777777 | 77777777 |
+# +------------+------------+----------+
+#
+# After:
+# 0 1 2 3
+# +------------+------------+----------+
+# | 7777777777 | FFFFFFFFFF | 77777777 |
+# +------------+------------+----------+
+#
+# ie mem[ss-1] = mem[ss*2] = 0x77.
+# all bytes in sector 1 are 0xFF.
+
+set test "sector erase"
+set okay 1
+if {![erase_mode]} {
+ fail "$test -- unable to erase entire chip"
+} else {
+ set sectorsize [sid_cmd "sid::component::attribute_value $victim sector-size"]
+ for {set i 0} {$i < [expr 3 * $sectorsize]} {incr i} {
+ if {![program_mode]} {
+ fail "$test -- unable to enter program mode"
+ set okay 0
+ break
+ }
+ set result [sid_cmd "sid::bus::write_h4_l1 $bus $i 0x77"]
+ if ![sid_bus_ok_p $result] {
+ fail "$test -- bus error ($result)"
+ set okay 0
+ break
+ }
+ }
+ if {!$okay || ![sector_erase_mode]} {
+ fail "$test -- unable to enter sector erase mode"
+ } else {
+ # Erase sector 1.
+ set sa [expr 1 << 16]
+ set result [sid_cmd "sid::bus::write_h4_l1 $bus $sa 0x30"]
+
+ if ![sid_bus_ok_p $result] {
+ fail "$test -- bus error ($result)"
+ } else {
+ # Now check the lay of the land.
+ for {set i 0} {$i < [expr 3 * $sectorsize]} {incr i} {
+ set result [sid_cmd "sid::bus::read_h4_l1 $bus $i"]
+ if ![sid_bus_ok_p $result] {
+ fail "$test -- bus error ($result)"
+ } else {
+ if {$i < $sectorsize && [lindex $result 1] != "0x77"} {
+ fail "$test -- $i not 0x77"
+ set okay 0
+ break
+ } elseif {$i >= $sectorsize && $i < [expr 2 * $sectorsize]} {
+ if {[lindex $result 1] != "0xFF"} {
+ fail "$test -- $i not 0xFF"
+ set okay 0
+ break
+ }
+ } elseif {$i >= [expr 2 * $sectorsize] && $i < [expr 3 * $sectorsize]} {
+ if {[lindex $result 1] != "0x77"} {
+ fail "$test -- $i not 0x77"
+ set okay 0
+ break
+ }
+ }
+ }
+ }
+ }
+ }
+ if {$okay} { pass $test }
+}
+
+
+set test "read memory image from a file"
+set file [open "test.dat" w]
+fconfigure $file -translation binary
+set data 0
+set size [sid_cmd "sid::component::attribute_value $victim size"]
+for {set i 0} {$i < $size} {incr i} {
+ set data [expr {(($data * 19) + 13) % 256}]
+ puts -nonewline $file [binary format "c" $data]
+}
+close $file
+set res [sid_cmd "sid::component::set_attribute_value $victim image-file test.dat"]
+set pin [sid_cmd "sid::component::find_pin $victim image-load"]
+sid_cmd "sid::pin::driven_h4 $pin 0"
+file delete -force $file
+if {$res == "ok" && $pin != ""} then { pass $test } else { fail $test }
+file delete -force $file
+
+
+set test "verify read memory image"
+set data 0
+set bus [sid_cmd "sid::component::find_bus $victim read-write-port"]
+set size [sid_cmd "sid::component::attribute_value $victim size"]
+for {set i 0} {$i < $size} {incr i} {
+ set data [expr {(($data * 19) + 13) % 256}]
+ set addr $i
+ set result [sid_cmd "sid::bus::read_h4_l1 $bus $addr"]
+ if ![sid_bus_ok_p $result] { fail "$test - bad"; break }
+ set result_data [lindex $result 1]
+ if {$result_data != $data} {
+ fail "$test - mismatch @ $i - $result_data vs $data"
+ break
+ }
+}
+if {$i == $size} { pass $test } else { fail "$test $i $size" }
+
+
+set test "save state"
+set state [sid_cmd "sid::component::attribute_value $victim state-snapshot"]
+if {$state != ""} { pass $test } else { fail $test }
+
+
+set test "restore state"
+sid_assert_success "sid::component::set_attribute_value $victim state-snapshot [list $state]"
+
+
+set test "sid stop"
+if [sid_stop] then { pass $test } else { fail $test ; return }
+
+
+# zap temp file if tests were successful
+global exit_status
+if {$exit_status == "0"} then { file delete "am29.conf" }
OSDN Git Service
