sid/component/testsuite/sidcomp.rtc/ds1742.exp

   1 # Initialisation.
   2 set size 2048
   3
   4 # FIXME: need to test the frequency test.
   5
   6 proc get_epoch {} {
   7     global victim
   8     return [sid_cmd "sid::component::attribute_value $victim epoch-time"]
   9 }
  10
  11 proc mask {value mask} {
  12     return [expr $value & $mask]
  13 }
  14
  15 # Enter write mode.
  16 proc start_write {} {
  17     global bus
  18     set result [sid_cmd "sid::bus::write_h4_l1 $bus 0x7F8 0x80"]
  19     if {$result == "ok"} { return 1 } else { return 0 }
  20 }
  21
  22 # Leave write mode.
  23 proc end_write {} {
  24     global bus
  25     set result [sid_cmd "sid::bus::write_h4_l1 $bus 0x7F8 0x0"]
  26     if {$result == "ok"} { return 1 } else { return 0 }
  27 }
  28
  29 # Enter read mode.
  30 proc start_read {} {
  31     global bus
  32     set result [sid_cmd "sid::bus::write_h4_l1 $bus 0x7F8 0x40"]
  33     if {$result == "ok"} { return 1 } else { return 0 }
  34 }
  35
  36 # Leave read mode.
  37 proc end_read {} {
  38     global bus
  39     set result [sid_cmd "sid::bus::write_h4_l1 $bus 0x7F8 0x0"]
  40     if {$result == "ok"} { return 1 } else { return 0 }
  41 }
  42
  43
  44 set test "sid configuration"
  45 sid_config_component_etc_test_with_tracing "ds1742.conf" \
  46     "load [sid_find_file librtc.la] rtc_component_library" \
  47     "hw-rtc-ds1742" \
  48     "load [sid_find_file libsched.la] sched_component_library
  49 new sid-sched-host-accurate sched
  50 load [sid_find_file libmemory.la] mem_component_library
  51 new hw-memory-ram/rom-basic nvram
  52 set sched num-clients 1
  53 set sched enabled? 1
  54 set nvram size 2048
  55 connect-bus real-victim memory-bus nvram read-write-port
  56 connect-pin sched 0-control <- wrapper clock-control
  57 connect-pin sched 0-event -> wrapper clock-event
  58 relate tester sched sched"
  59
  60 pass $test
  61
  62 set test "sid start"
  63 if {[sid_start "ds1742.conf"]} { pass $test } else { fail $test ; return }
  64
  65
  66 set test "read-write-port bus is present"
  67 set result [sid_cmd "sid::component::find_bus $victim read-write-port"]
  68 if {$result != ""} { pass $test } else { fail $test }
  69
  70 set test "clock pin is present"
  71 set result [sid_cmd "sid::component::find_pin $victim clock"]
  72 if {$result != ""} { pass $test } else { fail $test }
  73
  74 set test "all attributes are present"
  75 sid_assert_includes_all "sid::component::attribute_names $victim" \
  76   {"epoch-time" "century" "year" "month" "date" "day-of-week" "hour" "minute" "second"}
  77
  78 set test "reported time since epoch is sensible"
  79 set result [get_epoch]
  80 if {$result != "" && [expr abs($result - [clock seconds]) < 5]} {
  81     pass $test
  82 } else {
  83     fail $test
  84 }
  85
  86
  87 # Set up an array of triggerpoint sensor pins (connected to the victim).
  88 # Maintain another array that counts the number of times the triggerpoints are hit.
  89
  90 catch {unset watchpins triggercount}
  91 foreach watchable {epoch-time oscillating write-mode} {
  92     set test "establish a triggerpoint for watchable state variable: $watchable"
  93     set watchpins($watchable) [sid_cmd "sid::pin::new"]
  94     sid_cmd "set triggercount($watchable) 0"
  95     sid_cmd \
  96             "set hook_driven_h4($watchpins($watchable)) {global triggercount driven_h4_value; incr triggercount($watchable) }"
  97
  98     # Some limited URL encoding hacks.
  99     # see sid/include/sidwatchutil.h for the rules.
 100     regsub -- "-" $watchable "%2D" watchEnc
 101     set result [sid_cmd "sid::component::connect_pin $victim watch:${watchEnc}:change $watchpins($watchable)"]
 102     if {$result == "ok"} { pass $test } else { fail $test }
 103 }
 104
 105
 106 set test "save state"
 107 set saved(time) [get_epoch]
 108 set saved(state) \
 109     [sid_cmd "sid::component::attribute_value $victim state-snapshot"]
 110 if {$saved(state) != ""} { pass $test } else { fail $test }
 111
 112 foreach test_type { regular resstate } {
 113 set test "time is incremented by an advancing clock"
 114 set origin [get_epoch]
 115 set clock_pin [sid_cmd "sid::component::find_pin $victim clock"]
 116 for {set i 0} {$i < 5} {incr i} {
 117     sid_cmd "sid::pin::driven_h4 $clock_pin 0"
 118 }
 119 # Time should now be advanced by 5.
 120 set result [get_epoch]
 121 if {$result != "" && [expr ($result - $origin) == 5]} {
 122     pass $test
 123 } else {
 124     fail $test
 125 }
 126
 127 set origin [get_epoch]
 128
 129 set test "read century attribute"
 130 set result [sid_cmd "sid::component::attribute_value $victim century"]
 131 if {$result != ""} {
 132     set test_century $result
 133     scan [clock format $origin -gmt true -format %Y] %d host_century
 134     set host_century [expr $host_century / 100]
 135     if {$test_century == $host_century} {
 136         pass $test
 137     } else {
 138         fail "$test -- got $test_century, expected $host_century"
 139     }
 140 } else {
 141     fail $test
 142 }
 143
 144 set test "read year attribute"
 145 set result [sid_cmd "sid::component::attribute_value $victim year"]
 146 if {$result != ""} {
 147     set test_year $result
 148     scan [clock format $origin -gmt true -format %y] %d host_year
 149     if {$test_year == $host_year} {
 150         pass $test
 151     } else {
 152         fail "$test -- got $test_year, expected $host_year"
 153     }
 154 } else {
 155     fail $test
 156 }
 157
 158 set test "read month attribute"
 159 set result [sid_cmd "sid::component::attribute_value $victim month"]
 160 if {$result != ""} {
 161     set test_month $result
 162     scan [clock format $origin -gmt true -format %m] %d host_month
 163     if {$test_month == $host_month} {
 164         pass $test
 165     } else {
 166         fail "$test -- got $test_month, expected $host_month"
 167     }
 168 } else {
 169     fail $test
 170 }
 171
 172 set test "read date attribute"
 173 set result [sid_cmd "sid::component::attribute_value $victim date"]
 174 if {$result != ""} {
 175     set test_date $result
 176     scan [clock format $origin -gmt true -format %d] %d host_date
 177     if {$test_date == $host_date} {
 178         pass $test
 179     } else {
 180         fail "$test -- got $test_date, expected $host_date"
 181     }
 182 } else {
 183     fail $test
 184 }
 185
 186 set test "read day-of-week attribute"
 187 set result [sid_cmd "sid::component::attribute_value $victim day-of-week"]
 188 if {$result != ""} {
 189     set test_weekday $result
 190     scan [clock format $origin -gmt true -format %w] %d host_weekday
 191     incr host_weekday
 192     if {$test_weekday == $host_weekday} {
 193         pass $test
 194     } else {
 195         fail "$test -- got $test_weekday, expected $host_weekday"
 196     }
 197 } else {
 198     fail $test
 199 }
 200
 201 set test "read hour attribute"
 202 set result [sid_cmd "sid::component::attribute_value $victim hour"]
 203 if {$result != ""} {
 204     set test_hour $result
 205     scan [clock format $origin -gmt true -format %H] %d host_hour
 206     if {$test_hour == $host_hour} {
 207         pass $test
 208     } else {
 209         fail "$test -- got $test_hour, expected $host_hour"
 210     }
 211 } else {
 212     fail $test
 213 }
 214
 215 set test "read minute attribute"
 216 set result [sid_cmd "sid::component::attribute_value $victim minute"]
 217 if {$result != ""} {
 218     set test_minute $result
 219     scan [clock format $origin -gmt true -format %M] %d host_minute
 220     if {$test_minute == $host_minute} {
 221         pass $test
 222     } else {
 223         fail "$test -- got $test_minute, expected $host_minute"
 224     }
 225 } else {
 226     fail $test
 227 }
 228
 229 set test "read second attribute"
 230 set result [sid_cmd "sid::component::attribute_value $victim second"]
 231 if {$result != ""} {
 232     set test_second $result
 233     scan [clock format $origin -gmt true -format %S] %d host_second
 234     if {$test_second == $host_second} {
 235         pass $test
 236     } else {
 237         fail "$test -- got $test_second, expected $host_second"
 238     }
 239 } else {
 240     fail $test
 241 }
 242
 243 set test "fill regular non-volatile memory with test bytes"
 244 set okay 1
 245 set bus [sid_cmd "sid::component::find_bus $victim read-write-port"]
 246 if {$bus == ""} {
 247     fail $test
 248 } else {
 249     for {set addr 0} {$addr < [expr $size - 8]} {incr addr} {
 250         if {$addr % 2} { set data 0x55 } else { set data 0xAA }
 251         set result [sid_cmd "sid::bus::write_h4_l1 $bus $addr $data"]
 252         if {$result != "ok"} { set okay 0; break }
 253     }
 254     if {$okay} { pass $test } else { fail $test }
 255 }
 256
 257
 258 set test "validate memory was written correctly"
 259 set okay 1
 260 set bus [sid_cmd "sid::component::find_bus $victim read-write-port"]
 261 if {$bus == ""} {
 262     fail $test
 263 } else {
 264     for {set addr 0} {$addr < [expr $size - 8]} {incr addr} {
 265         if {$addr % 2} { set data 0x55 } else { set data 0xAA }
 266         set result [sid_cmd "sid::bus::read_h4_l1 $bus $addr"]
 267         if {[lindex $result 0] != "ok" || [lindex $result 1] != $data} {
 268             set okay 0
 269             break
 270         }
 271     }
 272     if {$okay} { pass $test } else { fail $test }
 273 }
 274
 275
 276 # Make sure out of range addresses are caught.
 277 set test "out by one address is caught unmapped"
 278 set bus [sid_cmd "sid::component::find_bus $victim read-write-port"]
 279 if {$bus == ""} {
 280     fail $test
 281 } else {
 282     set result [sid_cmd "sid::bus::write_h4_l1 $bus $size 0"]
 283     if {$result != "unmapped"} { fail $test } else { pass $test }
 284 }
 285
 286
 287 set test "battery is not flat"
 288 set result [sid_cmd "sid::bus::read_h4_l1 $bus 0x7FC"]
 289 if {[lindex $result 0] == "ok" && [mask [lindex $result 1] 0x80] == 0x80} {
 290     pass $test
 291 } else {
 292     fail "$test -- got $result, expected 0x80 to be set"
 293 }
 294
 295
 296 set test "read mode does not alter epoch time"
 297 if {[start_read] && [end_read]} {
 298     set now [get_epoch]
 299     if {$origin == $now} {
 300         pass $test
 301     } else {
 302         fail "$test -- got $now, expected $origin"
 303     }
 304 } else {
 305     fail $test
 306 }
 307
 308
 309 set test "write mode does not alter epoch time"
 310 if {[start_write] && [end_write]} {
 311     set now [get_epoch]
 312     if {$origin == $now} {
 313         pass $test
 314     } else {
 315         fail "$test -- got $now, expected $origin"
 316     }
 317 } else { fail $test }
 318
 319
 320 set test "read year register"
 321 set result [sid_cmd "sid::bus::read_h4_l1 $bus 0x7FF"]
 322 scan [clock format $origin -gmt true -format %y] %x year
 323 if {[lindex $result 0] == "ok" && [lindex $result 1] == $year} {
 324     pass $test
 325 } else {
 326     fail $test
 327 }
 328
 329
 330 set test "read month register"
 331 set result [sid_cmd "sid::bus::read_h4_l1 $bus 0x7FE"]
 332 scan [clock format $origin -gmt true -format %m] %x month
 333 if {[lindex $result 0] == "ok" && [mask [lindex $result 1] 0x1F] == $month} {
 334     pass $test
 335 } else {
 336     fail $test
 337 }
 338
 339
 340 set test "read date register"
 341 set result [sid_cmd "sid::bus::read_h4_l1 $bus 0x7FD"]
 342 scan [clock format $origin -gmt true -format %d] %x date
 343 if {[lindex $result 0] == "ok" && [mask [lindex $result 1] 0x3F] == $date} {
 344     pass $test
 345 } else {
 346     fail $test
 347 }
 348
 349
 350 set test "read day register"
 351 set result [sid_cmd "sid::bus::read_h4_l1 $bus 0x7FC"]
 352 set wday [expr [clock format $origin -gmt true -format %w] + 1]
 353
 354 if {[lindex $result 0] == "ok" && [mask [lindex $result 1] 0x07] == $wday} {
 355     pass $test
 356 } else {
 357     fail $test
 358 }
 359
 360
 361 set test "read hour register"
 362 set result [sid_cmd "sid::bus::read_h4_l1 $bus 0x7FB"]
 363 scan [clock format $origin -gmt true -format %H] %x hour
 364 if {[lindex $result 0] == "ok" && [mask [lindex $result 1] 0x3F] == $hour} {
 365     pass $test
 366 } else {
 367     fail $test
 368 }
 369
 370
 371 set test "read minutes register"
 372 set result [sid_cmd "sid::bus::read_h4_l1 $bus 0x7FA"]
 373 scan [clock format $origin -gmt true -format %M] %x mins
 374 if {[lindex $result 0] == "ok" && [mask [lindex $result 1] 0x7F] == $mins} {
 375     pass $test
 376 } else {
 377     fail $test
 378 }
 379
 380
 381 set test "read seconds register"
 382 set result [sid_cmd "sid::bus::read_h4_l1 $bus 0x7F9"]
 383 scan [clock format $origin -gmt true -format %S] %x secs
 384 set sec [mask [lindex $result 1] 0x7F]
 385
 386 if {[lindex $result 0] == "ok" && [mask [lindex $result 1] 0x7F] == $secs} {
 387     pass $test
 388 } else {
 389     fail $test
 390 }
 391
 392
 393 set test "read bit stops the clock"
 394 set origin [get_epoch]
 395 if {[start_read]} {
 396     set clock_pin [sid_cmd "sid::component::find_pin $victim clock"]
 397     for {set i 0} {$i < 5} {incr i} {
 398         sid_cmd "sid::pin::driven_h4 $clock_pin 0"
 399     }
 400     # Time should now be advanced by 5.
 401     if {![end_read]} {
 402         fail $test
 403     } else {
 404         set now [get_epoch]
 405         if {$now == $origin} { pass $test } else { fail $test }
 406     }
 407 } else { fail $test }
 408
 409
 410 set test "write bit stops the clock"
 411 set origin [get_epoch]
 412 if {[start_read]} {
 413     set clock_pin [sid_cmd "sid::component::find_pin $victim clock"]
 414     for {set i 0} {$i < 5} {incr i} {
 415         sid_cmd "sid::pin::driven_h4 $clock_pin 0"
 416     }
 417     # Time should now be advanced by 5.
 418     if {![end_write]} {
 419         fail $test
 420     } else {
 421         set now [get_epoch]
 422         if {$now == $origin} { pass $test } else { fail $test }
 423     }
 424 } else { fail $test }
 425
 426
 427 # Disconnect the oscillator.
 428
 429 set test "disconnect the oscillator"
 430 set origin [get_epoch]
 431 set result [sid_cmd "sid::bus::write_h4_l1 $bus 0x7F9 0x80"]
 432 if {$result == "ok"} { pass $test } else { fail $test }
 433
 434 set clock_pin [sid_cmd "sid::component::find_pin $victim clock"]
 435 for {set i 0} {$i < 5} {incr i} {
 436     sid_cmd "sid::pin::driven_h4 $clock_pin 0"
 437 }
 438 # Time should now be advanced by 5.
 439
 440 set test "read year register with oscillator disconnected"
 441 set result [sid_cmd "sid::bus::read_h4_l1 $bus 0x7FF"]
 442 scan [clock format $origin -gmt true -format %y] %x year
 443 if {[lindex $result 0] == "ok" && [lindex $result 1] == $year} {
 444     pass $test
 445 } else {
 446     fail $test
 447 }
 448
 449
 450 set test "read month register with oscillator disconnected"
 451 set result [sid_cmd "sid::bus::read_h4_l1 $bus 0x7FE"]
 452 scan [clock format $origin -gmt true -format %m] %x month
 453 if {[lindex $result 0] == "ok" && [mask [lindex $result 1] 0x1F] == $month} {
 454     pass $test
 455 } else {
 456     fail $test
 457 }
 458
 459
 460 set test "read date register with oscillator disconnected"
 461 set result [sid_cmd "sid::bus::read_h4_l1 $bus 0x7FD"]
 462 scan [clock format $origin -gmt true -format %d] %x date
 463 if {[lindex $result 0] == "ok" && [mask [lindex $result 1] 0x3F] == $date} {
 464     pass $test
 465 } else {
 466     fail $test
 467 }
 468
 469
 470 set test "read day register with oscillator disconnected"
 471 set result [sid_cmd "sid::bus::read_h4_l1 $bus 0x7FC"]
 472 set wday [expr [clock format $origin -gmt true -format %w] + 1]
 473 if {[lindex $result 0] == "ok" && [mask [lindex $result 1] 0x07] == $wday} {
 474     pass $test
 475 } else {
 476     fail $test
 477 }
 478
 479
 480 set test "read hour register with oscillator disconnected"
 481 set result [sid_cmd "sid::bus::read_h4_l1 $bus 0x7FB"]
 482 scan [clock format $origin -gmt true -format %H] %x hour
 483 if {[lindex $result 0] == "ok" && [mask [lindex $result 1] 0x3F] == $hour} {
 484     pass $test
 485 } else {
 486     fail $test
 487 }
 488
 489
 490 set test "read minutes register with oscillator disconnected"
 491 set result [sid_cmd "sid::bus::read_h4_l1 $bus 0x7FA"]
 492 scan [clock format $origin -gmt true -format %M] %x mins
 493 if {[lindex $result 0] == "ok" && [mask [lindex $result 1] 0x7F] == $mins} {
 494     pass $test
 495 } else {
 496     fail $test
 497 }
 498
 499
 500 set test "read seconds register with oscillator disconnected"
 501 set result [sid_cmd "sid::bus::read_h4_l1 $bus 0x7F9"]
 502 scan [clock format $origin -gmt true -format %S] %x secs
 503 set sec [mask [lindex $result 1] 0x7F]
 504 if {[lindex $result 0] == "ok" && $sec == $secs} {
 505     pass $test
 506 } else {
 507     fail $test
 508 }
 509
 510 # Reconnect the oscillator.
 511
 512 set test "reconnect the oscillator"
 513 set result [sid_cmd "sid::bus::write_h4_l1 $bus 0x7F9 0"]
 514 if {$result == "ok"} { pass $test } else { fail $test }
 515
 516 set clock_pin [sid_cmd "sid::component::find_pin $victim clock"]
 517 for {set i 0} {$i < 5} {incr i} {
 518     sid_cmd "sid::pin::driven_h4 $clock_pin 0"
 519 }
 520 # Time should now be advanced by 5.
 521
 522 # Check that epoch time has advanced by 5.
 523 set test "reconnecting the oscillator works"
 524 set result [get_epoch]
 525 if {[expr $result - $origin] == 5} { pass $test } else { fail $test }
 526
 527 # Test altering each field of the time/date structure.
 528 # These are written to the registers as BCD.
 529
 530 set test "modify the year register"
 531 set origin [get_epoch]
 532 set year 05
 533 start_write
 534 set result [sid_cmd "sid::bus::write_h4_l1 $bus 0x7FF $year"]
 535 if {$result != "ok"} {
 536     fail $test
 537 } else {
 538     end_write
 539     if {[get_epoch] != $origin} { pass $test } else { fail $test }
 540 }
 541
 542
 543 set test "modify the month register"
 544 set origin [get_epoch]
 545 start_read
 546 set result [sid_cmd "sid::bus::read_h4_l1 $bus 0x7FE"]
 547 if {[lindex $result 0] != "ok"} {
 548     fail $test
 549 } else {
 550     end_read
 551     set month [lindex $result 1]
 552     incr month
 553     if {$month > 12} { set month 1 }
 554     start_write
 555     set result [sid_cmd "sid::bus::write_h4_l1 $bus 0x7FE $month"]
 556     if {$result != "ok"} {
 557         fail $test
 558     } else {
 559         end_write
 560         if {[get_epoch] != $origin} { pass $test } else { fail $test }
 561     }
 562 }
 563
 564
 565 set test "modify the date register"
 566 set origin [get_epoch]
 567 start_read
 568 set result [sid_cmd "sid::bus::read_h4_l1 $bus 0x7FD"]
 569 if {[lindex $result 0] != "ok"} {
 570     fail $test
 571 } else {
 572     end_read
 573     set date [lindex $result 1]
 574     incr date
 575     # Don't bother trying to handle variable number of days/month.
 576     if {$date > 28} { set date 1 }
 577     start_write
 578     set result [sid_cmd "sid::bus::write_h4_l1 $bus 0x7FD $date"]
 579     if {$result != "ok"} {
 580         fail $test
 581     } else {
 582         end_write
 583         if {[get_epoch] != $origin} { pass $test } else { fail $test }
 584     }
 585 }
 586
 587
 588 set test "modify the day register with an invalid value"
 589 set result [sid_cmd "sid::bus::write_h4_l1 $bus 0x7FC 0"]
 590 if {$result == "ok"} { pass $test } else { fail $test}
 591
 592
 593 set test "modify the day register"
 594 set origin [get_epoch]
 595 start_read
 596 set result [sid_cmd "sid::bus::read_h4_l1 $bus 0x7FC"]
 597 if {[lindex $result 0] != "ok"} {
 598     fail $test
 599 } else {
 600     end_read
 601     set day [lindex $result 1]
 602     set data [expr $day & 0xF8]
 603     set day [expr $day & 0x07]
 604     if {$day > 7} { set day 1 } else { incr day }
 605     set day [format %X [expr $data | $day]]
 606     start_write
 607     set result [sid_cmd "sid::bus::write_h4_l1 $bus 0x7FC $day"]
 608     if {$result != "ok"} {
 609         fail $test
 610     } else {
 611         end_write
 612         if {[get_epoch] == $origin} { pass $test } else { fail $test }
 613     }
 614 }
 615
 616
 617 set test "modify the hour register"
 618 set origin [get_epoch]
 619 start_read
 620 set result [sid_cmd "sid::bus::read_h4_l1 $bus 0x7FB"]
 621 if {[lindex $result 0] != "ok"} {
 622     fail $test
 623 } else {
 624     end_read
 625     set hour [lindex $result 1]
 626     incr hour
 627     if {$hour > 23} { set hour 0 }
 628     start_write
 629     set result [sid_cmd "sid::bus::write_h4_l1 $bus 0x7FB $hour"]
 630     if {$result != "ok"} {
 631         fail $test
 632     } else {
 633         end_write
 634         if {[get_epoch] != $origin} { pass $test } else { fail $test }
 635     }
 636 }
 637
 638
 639 set test "modify the minute register"
 640 set origin [get_epoch]
 641 start_read
 642 set result [sid_cmd "sid::bus::read_h4_l1 $bus 0x7FA"]
 643 if {[lindex $result 0] != "ok"} {
 644     fail $test
 645 } else {
 646     end_read
 647     set minute [lindex $result 1]
 648     incr minute
 649     if {$minute > 59} { set minute 0 }
 650     start_write
 651     set result [sid_cmd "sid::bus::write_h4_l1 $bus 0x7FA $minute"]
 652     if {$result != "ok"} {
 653         fail $test
 654     } else {
 655         end_write
 656         if {[get_epoch] != $origin} { pass $test } else { fail $test }
 657     }
 658 }
 659
 660
 661 set test "modify the second register"
 662 set origin [get_epoch]
 663 start_read
 664 set result [sid_cmd "sid::bus::read_h4_l1 $bus 0x7F9"]
 665 if {[lindex $result 0] != "ok"} {
 666     fail $test
 667 } else {
 668     end_read
 669     set seconds [lindex $result 1]
 670     incr seconds
 671     if {$seconds > 59} { set seconds 0 }
 672     start_write
 673     set result [sid_cmd "sid::bus::write_h4_l1 $bus 0x7F9 $seconds"]
 674     if {$result != "ok"} {
 675         fail $test
 676     } else {
 677         end_write
 678         if {[get_epoch] != $origin} { pass $test } else { fail $test }
 679     }
 680 }
 681
 682
 683 set test "modify the century register"
 684 set origin [get_epoch]
 685 start_read
 686 set result [sid_cmd "sid::bus::read_h4_l1 $bus 0x7F8"]
 687 if {[lindex $result 0] != "ok"} {
 688     fail $test
 689 } else {
 690     end_read
 691     set century [lindex $result 1]
 692     set data [expr $century | 0x80]
 693     start_write
 694     set result [sid_cmd "sid::bus::write_h4_l1 $bus 0x7F8 $data"]
 695     if {$result != "ok"} {
 696         fail $test
 697     } else {
 698         end_write
 699         if {[get_epoch] != $origin} { fail $test } else { pass $test }
 700     }
 701 }
 702
 703 # FIXME: test restore state.
 704
 705 set res_testtype [string compare $test_type "regular"]
 706 if { $res_testtype == 0 } {
 707 #set test "Restore state"
 708 set test "Restore state"
 709 set ok [sid_cmd "sid::component::set_attribute_value $victim state-snapshot [list $saved(state)]"]
 710 if {$ok == "ok"} then { pass $test } else { fail $test }
 711 }
 712 }
 713
 714
 715 # This list specifies addresses and bitmasks to locate free, unused
 716 # bits which may be used as NVRAM.
 717
 718 foreach pair {{0x7FE 0xE0} {0x7FD 0xC0} {0x7FC 0x38} {0x7FB 0xC0} {0x7FA 0x80}} {
 719     set hex_addr [lindex $pair 0]
 720     set hex_mask [lindex $pair 1]
 721
 722     set test "store data in free bits at $hex_addr"
 723     set result [sid_cmd "sid::bus::write_h4_l1 $bus $hex_addr 0xFF"]
 724     if {$result == "ok"} {
 725         set result [sid_cmd "sid::bus::read_h4_l1 $bus $hex_addr"]
 726         if {[lindex $result 0] == "ok" && \
 727                 [mask [lindex $result 1] $hex_mask] == $hex_mask} {
 728             pass $test
 729         } else {
 730             fail "$test -- readback error"
 731         }
 732     } else {
 733         fail "$test -- write error"
 734     }
 735 }
 736
 737
 738 set test "epoch-time triggerpoint fired 16 times"
 739 if {[sid_cmd "set triggercount(epoch-time)"] == "32"} { pass $test } else { fail $test }
 740
 741 set test "oscillating triggerpoint fired twice"
 742 if {[sid_cmd "set triggercount(oscillating)"] == "4"} { pass $test } else { fail $test }
 743
 744 set test "write-mode triggerpoint fired 37 times"
 745 if {[sid_cmd "set triggercount(write-mode)"] == "81"} { pass $test } else { fail $test }
 746
 747 catch {unset watchpins triggercount}
 748
 749
 750 # FIXME: add tests for the frequency test function.
 751
 752 set test "sid stop"
 753 if [sid_stop] then { pass $test } else { fail $test ; return }
 754
 755 # zap temp file if tests were successful
 756 global exit_status
 757 if {$exit_status == "0"} then { file delete "ds1742.conf" }