OpenCores
URL https://opencores.org/ocsvn/scan_based_serial_communication/scan_based_serial_communication/trunk

Subversion Repositories scan_based_serial_communication

[/] [scan_based_serial_communication/] [trunk/] [SCAN_README.txt] - Blame information for rev 2

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 2 Quanticles
 
2
FILES
3
        scan.perl.v
4
        scan_signal_list.pl
5
        scan_testbench.perl.v
6
 
7
AUTHOR
8
        David Fick - dfick@umich.edu
9
 
10
VERSION
11
        1.0 - June 27, 2010
12
 
13
SCAN DESCRIPTION
14
        This is a simple scan chain implemented with deperlify. It has been
15
        used, successfully, on multiple tapeouts.
16
 
17
        This scan chain is designed to safely and easily  move data onto and
18
        off of a chip with a minimal number of pins. Performance is not a
19
        priority, however, we have found it to be sufficiently fast for
20
        any student project.
21
 
22
        For safety, this scan uses two non-overlapping "clocks" that operate
23
        out of phase. Each bit in the scan chain has a master latch and
24
        a slave latch. The master latch is connected to the signal "phi",
25
        and the slave latch is connected to the signal "phi_bar". To clock
26
        in one bit (and out another), "data_in" is first set to the correct
27
        value, then "phi" is *pulsed*, afterward "phi_bar" is *pulsed*. The
28
        process then repeats for the next bit. Since each clock is pulsed
29
        individually, they will never overlap. Note that this design
30
        is immune to signal bouncing.
31
 
32
        Every data_bit coming out of the scan chain unit is first buffered
33
        with a latch. This latch is transparent when "scan_load_chip" is
34
        high. Thus, data is loaded onto the chip by first clocking in all
35
        of the data as described above, then pulsing "scan_load_chip".
36
        This means that the signals coming out of the scan unit to the
37
        rest of the chip do not toggle randomly when the scan chain is
38
        being loaded, and therefore the scan chain can be operated while
39
        the chip is running.
40
 
41
        The signal "scan_load_chain" controls a mux on the input of each
42
        latch pair. If "scan_load_chain" is high, then data from the chip
43
        is loaded into the scan chain when the two clocks are pulsed,
44
        instead of data from the preceding bit. Thus, to read data
45
        from the chip, first raise "scan_load_chain" high, pulse the two
46
        clocks once as normal, then lower "scan_load_chain". Now that
47
        the chip data has been loaded into the scan chain, clock out the
48
        data as normal.
49
 
50
        Due to the buffering latch, complex internal interfaces can be
51
        emulated using the scan chain. For instance, an SRAM could be
52
        connected to a clock, chip select, write enable, 64-bit data-in,
53
        and 64-bit data-out, all of which are connected to the scan
54
        chain. The scan chain would need to be used a few times for each
55
        "cycle" of the SRAM. For instance, each time the clock signal
56
        toggles the scan chain would need to be completely reloaded.
57
        Although this process is slow, it works reliably.
58
 
59
        The example description below has additional information about
60
        how to use the scan chain.
61
 
62
 
63
EXAMPLE DESCRIPTION
64
        To run the example, use deperlify to generate scan.v and
65
        scan_testbench.v:
66
 
67
        perl deperlify.pl scan.perl.v
68
        perl depeflify.pl scan_testbench.perl.v
69
 
70
        Then use your Verilog simulator of choice.
71
 
72
        This example takes advantage of the DEPERLIFY_INCLUDE command. The
73
        scan.perl.v file reads in the data structure scan_signal_list.pl
74
        in order to generate the scan chain. The file scan_testbench.perl.v
75
        uses the same data structure to generate variables and functions
76
        to access the scan chain.
77
 
78
        The testbench generates a write variable and read variable for
79
        each element in the scan chain. The write variable is called
80
         and the read variable is called _read. The values
81
        with the name  are what is scanned into the scan chain
82
        by the task "rotate_chain". The task "rotate_chain" writes the
83
        variables with the name _read with the data that is scanned
84
        out by the scan chain. Note that data is simultaneously scanned
85
        in and out.
86
 
87
        To write a value:
88
        1. Set the value of  to what you desire
89
        2. Call "rotate_chain"
90
        3. Call "load_chip"
91
 
92
        To read a value:
93
        1. Call "load_chain"
94
        2. Call "rotate_chain"
95
        3. Read the value of _read
96
 
97
 
98
 
99
 
100
 

powered by: WebSVN 2.1.0

© copyright 1999-2020 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.