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 5

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

Line No. Rev Author Line
1 3 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 4 Quanticles
        1.1 - January 7, 2011
13 3 Quanticles
 
14
SCAN DESCRIPTION
15
        This is a simple scan chain implemented with deperlify. It has been
16
        used, successfully, on multiple tapeouts.
17
 
18
        This scan chain is designed to safely and easily  move data onto and
19
        off of a chip with a minimal number of pins. Performance is not a
20
        priority, however, we have found it to be sufficiently fast for
21
        any student project.
22
 
23
        For safety, this scan uses two non-overlapping "clocks" that operate
24
        out of phase. Each bit in the scan chain has a master latch and
25
        a slave latch. The master latch is connected to the signal "phi",
26
        and the slave latch is connected to the signal "phi_bar". To clock
27
        in one bit (and out another), "data_in" is first set to the correct
28
        value, then "phi" is *pulsed*, afterward "phi_bar" is *pulsed*. The
29
        process then repeats for the next bit. Since each clock is pulsed
30
        individually, they will never overlap. Note that this design
31
        is immune to signal bouncing.
32
 
33
        Every data_bit coming out of the scan chain unit is first buffered
34
        with a latch. This latch is transparent when "scan_load_chip" is
35
        high. Thus, data is loaded onto the chip by first clocking in all
36
        of the data as described above, then pulsing "scan_load_chip".
37
        This means that the signals coming out of the scan unit to the
38
        rest of the chip do not toggle randomly when the scan chain is
39
        being loaded, and therefore the scan chain can be operated while
40
        the chip is running.
41
 
42
        The signal "scan_load_chain" controls a mux on the input of each
43
        latch pair. If "scan_load_chain" is high, then data from the chip
44
        is loaded into the scan chain when the two clocks are pulsed,
45
        instead of data from the preceding bit. Thus, to read data
46
        from the chip, first raise "scan_load_chain" high, pulse the two
47
        clocks once as normal, then lower "scan_load_chain". Now that
48
        the chip data has been loaded into the scan chain, clock out the
49
        data as normal.
50
 
51 4 Quanticles
        To create a large number of bits, address and data fields may
52
        be created for a signal. 2^addr_bits*data_bits must be greater
53
        than the size. In this way, only addr_bits+data_bits number of
54
        bits may be generated in the scan chain, which reduces the
55
        length of the scan chain, as well as the area, since latches
56
        are much smaller than the muxing elements needed for the
57
        chain. Since this is a new feature, the size specified by the
58
        address and data bits should most likely match the total size
59
        in order to avoid bugs.
60
 
61
        Due to the buffering latches, complex internal interfaces can be
62 3 Quanticles
        emulated using the scan chain. For instance, an SRAM could be
63
        connected to a clock, chip select, write enable, 64-bit data-in,
64
        and 64-bit data-out, all of which are connected to the scan
65
        chain. The scan chain would need to be used a few times for each
66
        "cycle" of the SRAM. For instance, each time the clock signal
67
        toggles the scan chain would need to be completely reloaded.
68
        Although this process is slow, it works reliably.
69
 
70
        The example description below has additional information about
71
        how to use the scan chain.
72
 
73
 
74
EXAMPLE DESCRIPTION
75 4 Quanticles
        To run the example, call "make". The example uses Synopsys VCS.
76 3 Quanticles
 
77
        This example takes advantage of the DEPERLIFY_INCLUDE command. The
78
        scan.perl.v file reads in the data structure scan_signal_list.pl
79
        in order to generate the scan chain. The file scan_testbench.perl.v
80
        uses the same data structure to generate variables and functions
81
        to access the scan chain.
82
 
83
        The testbench generates a write variable and read variable for
84
        each element in the scan chain. The write variable is called
85
         and the read variable is called _read. The values
86
        with the name  are what is scanned into the scan chain
87
        by the task "rotate_chain". The task "rotate_chain" writes the
88
        variables with the name _read with the data that is scanned
89
        out by the scan chain. Note that data is simultaneously scanned
90
        in and out.
91
 
92
        To write a value:
93
        1. Set the value of  to what you desire
94
        2. Call "rotate_chain"
95
        3. Call "load_chip"
96
 
97
        To read a value:
98
        1. Call "load_chain"
99
        2. Call "rotate_chain"
100
        3. Read the value of _read
101
 
102
 
103
 
104
 
105 2 Quanticles
 

powered by: WebSVN 2.1.0

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