Many bug fixes, including selection fixes.
[SCSI2SD.git] / software / SCSI2SD / SCSI2SD.cydsn / scsiTarget / scsiTarget.v
1 \r
2 //`#start header` -- edit after this line, do not edit this line\r
3 //      Copyright (C) 2013 Michael McMaster <michael@codesrc.com>\r
4 //\r
5 //      This file is part of SCSI2SD.\r
6 //\r
7 //      SCSI2SD is free software: you can redistribute it and/or modify\r
8 //      it under the terms of the GNU General Public License as published by\r
9 //      the Free Software Foundation, either version 3 of the License, or\r
10 //      (at your option) any later version.\r
11 //\r
12 //      SCSI2SD is distributed in the hope that it will be useful,\r
13 //      but WITHOUT ANY WARRANTY; without even the implied warranty of\r
14 //      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
15 //      GNU General Public License for more details.\r
16 //\r
17 //      You should have received a copy of the GNU General Public License\r
18 //      along with SCSI2SD.  If not, see <http://www.gnu.org/licenses/>.\r
19 `include "cypress.v"\r
20 //`#end` -- edit above this line, do not edit this line\r
21 // Generated on 10/16/2013 at 00:01\r
22 // Component: scsiTarget\r
23 module scsiTarget (\r
24         output [7:0] DBx_out, // Active High, connected to SCSI bus via inverter\r
25         output  REQ, // Active High, connected to SCSI bus via inverter\r
26         input   nACK, // Active LOW, connected directly to SCSI bus.\r
27         input  [7:0] nDBx_in, // Active LOW, connected directly to SCSI bus.\r
28         input   IO, // Active High, set by CPU via status register.\r
29         input   nRST, // Active LOW, connected directly to SCSI bus.\r
30         input   clk\r
31 );\r
32 \r
33 \r
34 //`#start body` -- edit after this line, do not edit this line\r
35 \r
36 /////////////////////////////////////////////////////////////////////////////\r
37 // Force Clock Sync\r
38 /////////////////////////////////////////////////////////////////////////////\r
39 // The udb_clock_enable primitive component is used to indicate that the input\r
40 // clock must always be synchronous and if not implement synchronizers to make\r
41 // it synchronous.\r
42 wire op_clk;\r
43 cy_psoc3_udb_clock_enable_v1_0 #(.sync_mode(`TRUE)) ClkSync\r
44 (\r
45     .clock_in(clk),\r
46     .enable(1'b1),\r
47     .clock_out(op_clk)\r
48 );\r
49 \r
50 /////////////////////////////////////////////////////////////////////////////\r
51 // FIFO Status Register\r
52 /////////////////////////////////////////////////////////////////////////////\r
53 // Status Register: scsiTarget_StatusReg__STATUS_REG\r
54 //     Bit 0: Tx FIFO not full\r
55 //     Bit 1: Rx FIFO not empty\r
56 //     Bit 2: Tx FIFO empty\r
57 //     Bit 3: Rx FIFO full\r
58 //\r
59 // TX FIFO Register: scsiTarget_scsiTarget_u0__F0_REG\r
60 // RX FIFO Register: scsiTarget_scsiTarget_u0__F1_REG\r
61 // Use with CY_GET_REG8 and CY_SET_REG8\r
62 wire f0_bus_stat;   // Tx FIFO not full\r
63 wire f0_blk_stat;       // Tx FIFO empty\r
64 wire f1_bus_stat;       // Rx FIFO not empty\r
65 wire f1_blk_stat;       // Rx FIFO full\r
66 cy_psoc3_status #(.cy_force_order(1), .cy_md_select(8'h00)) StatusReg\r
67 (\r
68     /* input          */  .clock(op_clk),\r
69     /* input  [04:00] */  .status({4'b0, f1_blk_stat, f0_blk_stat, f1_bus_stat, f0_bus_stat})\r
70 );\r
71 \r
72 /////////////////////////////////////////////////////////////////////////////\r
73 // CONSTANTS\r
74 /////////////////////////////////////////////////////////////////////////////\r
75 localparam IO_WRITE = 1'b1;\r
76 localparam IO_READ = 1'b0;\r
77 \r
78 /////////////////////////////////////////////////////////////////////////////\r
79 // STATE MACHINE\r
80 /////////////////////////////////////////////////////////////////////////////\r
81 // TX States:\r
82 // IDLE\r
83 //     Wait for an entry in the FIFO, and for the SCSI Initiator to be ready\r
84 // FIFOLOAD\r
85 //     Load F0 into A0. Feed (old) A0 into the ALU SRCA.\r
86 // TX\r
87 //     Load data register from PO. PO is fed by A0 going into the ALU via SRCA\r
88 //     A0 must remain unchanged.\r
89 // DESKEW_INIT\r
90 //     DBx output signals will be output in this state\r
91 //     Load deskew clock count into A0 from D0\r
92 // DESKEW\r
93 //     DBx output signals will be output in this state\r
94 //     Wait for the SCSI deskew time of 55ms. (DEC A0).\r
95 //     A1 must be fed into SRCA, so PO is now useless.\r
96 // READY\r
97 //     REQ and DBx output signals will be output in this state\r
98 //     Wait for acknowledgement from the SCSI initiator.\r
99 // RX\r
100 //     Dummy state for flow control.\r
101 //     REQ signal will be output in this state\r
102 //     PI enabled for input into ALU "PASS" operation, storing into F1.\r
103 //\r
104 // RX States:\r
105 // IDLE\r
106 //     Wait for a dummy "enabling" entry in the input FIFO, and wait for space\r
107 //     in output the FIFO, and for the SCSI Initiator to be ready\r
108 // FIFOLOAD\r
109 //     Load F0 into A0.\r
110 //     The input FIFO is used to control the number of bytes we attempt to\r
111 //     read from the SCSI bus.\r
112 // READY\r
113 //     REQ signal will be output in this state\r
114 //     Wait for the initiator to send a byte on the SCSI bus.\r
115 // RX\r
116 //     REQ signal will be output in this state\r
117 //     PI enabled for input into ALU "PASS" operation, storing into F1.\r
118 \r
119 \r
120 localparam STATE_IDLE = 3'b000;\r
121 localparam STATE_FIFOLOAD = 3'b001;\r
122 localparam STATE_TX = 3'b010;\r
123 localparam STATE_DESKEW_INIT = 3'b011;\r
124 localparam STATE_DESKEW = 3'b100;\r
125 // This state intentionally not used.\r
126 localparam STATE_READY = 3'b110;\r
127 localparam STATE_RX = 3'b111;\r
128 \r
129 // state selects the datapath register.\r
130 reg[2:0] state;\r
131 \r
132 // Data being read/written from/to the SCSI bus\r
133 reg[7:0] data;\r
134 \r
135 // Set by the datapath zero detector (z1). High when A1 counts down to zero.\r
136 wire deskewComplete;\r
137 \r
138 // Parallel input to the datapath SRCA.\r
139 // Selected for input through to the ALU if CFB EN bit set for the datapath\r
140 // state and enabled by PI DYN bit in CFG15-14\r
141 wire[7:0] pi;\r
142 \r
143 // Parallel output from the selected SRCA value (A0 or A1) to the ALU.\r
144 wire[7:0] po;\r
145 \r
146 // Set true to trigger storing A1 into F1.\r
147 wire fifoStore;\r
148 \r
149 // Set Output Pins\r
150 assign REQ = state[1] & state[2]; // STATE_READY & STATE_RX\r
151 assign DBx_out[7:0] = data;\r
152 assign pi[7:0] = ~nDBx_in[7:0]; // Invert active low scsi bus\r
153 assign fifoStore = (state == STATE_RX) ? 1'b1 : 1'b0;\r
154 \r
155 always @(posedge op_clk) begin\r
156         case (state)\r
157                 STATE_IDLE:\r
158                 begin\r
159                         // Check that SCSI initiator is ready, and input FIFO is not empty,\r
160                         // and output FIFO is not full.\r
161                         // Note that output FIFO is unused in TX mode.\r
162                         if (nACK & !f0_blk_stat && !f1_blk_stat)\r
163                                 state <= STATE_FIFOLOAD;\r
164                         else\r
165                                 state <= STATE_IDLE;\r
166 \r
167                         // Clear our output pins\r
168                         data <= 8'b0;\r
169                 end\r
170 \r
171                 STATE_FIFOLOAD:\r
172                         state <= IO == IO_WRITE ? STATE_TX : STATE_READY;\r
173 \r
174                 STATE_TX:\r
175                 begin\r
176                         state <= STATE_DESKEW_INIT;\r
177                         data <= po;\r
178                 end\r
179 \r
180                 STATE_DESKEW_INIT: state <= STATE_DESKEW;\r
181 \r
182                 STATE_DESKEW:\r
183                         if(deskewComplete) state <= STATE_READY;\r
184                         else state <= STATE_DESKEW;\r
185 \r
186                 STATE_READY:\r
187                         if (~nACK) state <= STATE_RX;\r
188                         else state <= STATE_READY;\r
189 \r
190                 STATE_RX: state <= STATE_IDLE;\r
191 \r
192                 default: state <= STATE_IDLE;\r
193         endcase\r
194 end\r
195 \r
196 // D1 is used for the deskew count.\r
197 // The data output is valid during the DESKEW_INIT phase as well,\r
198 // so we subtract 1.\r
199 // D1 = [0.000000055 / (1 / clk)] - 1\r
200 cy_psoc3_dp #(.d1_init(3), \r
201 .cy_dpconfig(\r
202 {\r
203     `CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,\r
204     `CS_SHFT_OP_PASS, `CS_A0_SRC_NONE, `CS_A1_SRC_NONE,\r
205     `CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,\r
206     `CS_CMP_SEL_CFGA, /*CFGRAM0:         IDLE*/\r
207     `CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,\r
208     `CS_SHFT_OP_PASS, `CS_A0_SRC___F0, `CS_A1_SRC_NONE,\r
209     `CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,\r
210     `CS_CMP_SEL_CFGA, /*CFGRAM1:         FIFO Load*/\r
211     `CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,\r
212     `CS_SHFT_OP_PASS, `CS_A0_SRC_NONE, `CS_A1_SRC_NONE,\r
213     `CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,\r
214     `CS_CMP_SEL_CFGA, /*CFGRAM2:         TX*/\r
215     `CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,\r
216     `CS_SHFT_OP_PASS, `CS_A0_SRC___D0, `CS_A1_SRC_NONE,\r
217     `CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,\r
218     `CS_CMP_SEL_CFGA, /*CFGRAM3:         DESKEW INIT*/\r
219     `CS_ALU_OP__DEC, `CS_SRCA_A0, `CS_SRCB_D0,\r
220     `CS_SHFT_OP_PASS, `CS_A0_SRC__ALU, `CS_A1_SRC_NONE,\r
221     `CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,\r
222     `CS_CMP_SEL_CFGA, /*CFGRAM4:         DESKEW*/\r
223     `CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,\r
224     `CS_SHFT_OP_PASS, `CS_A0_SRC_NONE, `CS_A1_SRC_NONE,\r
225     `CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,\r
226     `CS_CMP_SEL_CFGA, /*CFGRAM5:   Not used*/\r
227     `CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,\r
228     `CS_SHFT_OP_PASS, `CS_A0_SRC_NONE, `CS_A1_SRC_NONE,\r
229     `CS_FEEDBACK_DSBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,\r
230     `CS_CMP_SEL_CFGA, /*CFGRAM6:         READY*/\r
231     `CS_ALU_OP_PASS, `CS_SRCA_A0, `CS_SRCB_D0,\r
232     `CS_SHFT_OP_PASS, `CS_A0_SRC_NONE, `CS_A1_SRC_NONE,\r
233     `CS_FEEDBACK_ENBL, `CS_CI_SEL_CFGA, `CS_SI_SEL_CFGA,\r
234     `CS_CMP_SEL_CFGA, /*CFGRAM7:         RX*/\r
235     8'hFF, 8'h00,  /*CFG9:            */\r
236     8'hFF, 8'hFF,  /*CFG11-10:            */\r
237     `SC_CMPB_A1_D1, `SC_CMPA_A1_D1, `SC_CI_B_ARITH,\r
238     `SC_CI_A_ARITH, `SC_C1_MASK_DSBL, `SC_C0_MASK_DSBL,\r
239     `SC_A_MASK_DSBL, `SC_DEF_SI_0, `SC_SI_B_DEFSI,\r
240     `SC_SI_A_DEFSI, /*CFG13-12:            */\r
241     `SC_A0_SRC_ACC, `SC_SHIFT_SL, `SC_PI_DYN_EN,\r
242     1'h0, `SC_FIFO1_ALU, `SC_FIFO0_BUS,\r
243     `SC_MSB_DSBL, `SC_MSB_BIT0, `SC_MSB_NOCHN,\r
244     `SC_FB_NOCHN, `SC_CMP1_NOCHN,\r
245     `SC_CMP0_NOCHN, /*CFG15-14:            */\r
246     10'h00, `SC_FIFO_CLK__DP,`SC_FIFO_CAP_AX,\r
247     `SC_FIFO_LEVEL,`SC_FIFO__SYNC,`SC_EXTCRC_DSBL,\r
248     `SC_WRK16CAT_DSBL /*CFG17-16:            */\r
249 }\r
250 )) datapath(\r
251         /*  input                   */  .reset(1'b0),\r
252         /*  input                   */  .clk(op_clk),\r
253         /*  input   [02:00]         */  .cs_addr(state),\r
254         /*  input                   */  .route_si(1'b0),\r
255         /*  input                   */  .route_ci(1'b0),\r
256         /*  input                   */  .f0_load(1'b0),\r
257         /*  input                   */  .f1_load(fifoStore),\r
258         /*  input                   */  .d0_load(1'b0),\r
259         /*  input                   */  .d1_load(1'b0),\r
260         /*  output                  */  .ce0(),\r
261         /*  output                  */  .cl0(),\r
262         /*  output                  */  .z0(deskewComplete),\r
263         /*  output                  */  .ff0(),\r
264         /*  output                  */  .ce1(),\r
265         /*  output                  */  .cl1(),\r
266         /*  output                  */  .z1(),\r
267         /*  output                  */  .ff1(),\r
268         /*  output                  */  .ov_msb(),\r
269         /*  output                  */  .co_msb(),\r
270         /*  output                  */  .cmsb(),\r
271         /*  output                  */  .so(),\r
272         /*  output                  */  .f0_bus_stat(f0_bus_stat),\r
273         /*  output                  */  .f0_blk_stat(f0_blk_stat),\r
274         /*  output                  */  .f1_bus_stat(f1_bus_stat),\r
275         /*  output                  */  .f1_blk_stat(f1_blk_stat),\r
276         \r
277         /* input                    */  .ci(1'b0),     // Carry in from previous stage\r
278         /* output                   */  .co(),         // Carry out to next stage\r
279         /* input                    */  .sir(1'b0),    // Shift in from right side\r
280         /* output                   */  .sor(),        // Shift out to right side\r
281         /* input                    */  .sil(1'b0),    // Shift in from left side\r
282         /* output                   */  .sol(),        // Shift out to left side\r
283         /* input                    */  .msbi(1'b0),   // MSB chain in\r
284         /* output                   */  .msbo(),       // MSB chain out\r
285         /* input [01:00]            */  .cei(2'b0),    // Compare equal in from prev stage\r
286         /* output [01:00]           */  .ceo(),        // Compare equal out to next stage\r
287         /* input [01:00]            */  .cli(2'b0),    // Compare less than in from prv stage\r
288         /* output [01:00]           */  .clo(),        // Compare less than out to next stage\r
289         /* input [01:00]            */  .zi(2'b0),     // Zero detect in from previous stage\r
290         /* output [01:00]           */  .zo(),         // Zero detect out to next stage\r
291         /* input [01:00]            */  .fi(2'b0),     // 0xFF detect in from previous stage\r
292         /* output [01:00]           */  .fo(),         // 0xFF detect out to next stage\r
293         /* input [01:00]            */  .capi(2'b0),   // Software capture from previous stage\r
294         /* output [01:00]           */  .capo(),       // Software capture to next stage\r
295         /* input                    */  .cfbi(1'b0),   // CRC Feedback in from previous stage\r
296         /* output                   */  .cfbo(),       // CRC Feedback out to next stage\r
297         /* input [07:00]            */  .pi(pi),     // Parallel data port\r
298         /* output [07:00]           */  .po(po)          // Parallel data port\r
299 );\r
300 //`#end` -- edit above this line, do not edit this line\r
301 endmodule\r
302 //`#start footer` -- edit after this line, do not edit this line\r
303 //`#end` -- edit above this line, do not edit this line\r