Added glitch filter on ACK line, registered all outputs, double-synced inputs, and...
[SCSI2SD-V6.git] / software / SCSI2SD / src / scsiPhy.c
1 //      Copyright (C) 2013 Michael McMaster <michael@codesrc.com>\r
2 //\r
3 //      This file is part of SCSI2SD.\r
4 //\r
5 //      SCSI2SD is free software: you can redistribute it and/or modify\r
6 //      it under the terms of the GNU General Public License as published by\r
7 //      the Free Software Foundation, either version 3 of the License, or\r
8 //      (at your option) any later version.\r
9 //\r
10 //      SCSI2SD is distributed in the hope that it will be useful,\r
11 //      but WITHOUT ANY WARRANTY; without even the implied warranty of\r
12 //      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
13 //      GNU General Public License for more details.\r
14 //\r
15 //      You should have received a copy of the GNU General Public License\r
16 //      along with SCSI2SD.  If not, see <http://www.gnu.org/licenses/>.\r
17 \r
18 #include "device.h"\r
19 #include "scsi.h"\r
20 #include "scsiPhy.h"\r
21 #include "bits.h"\r
22 \r
23 #define scsiTarget_AUX_CTL (* (reg8 *) scsiTarget_datapath__DP_AUX_CTL_REG)\r
24 \r
25 // DMA controller can't handle any more bytes.\r
26 #define MAX_DMA_BYTES 4095\r
27 \r
28 // Private DMA variables.\r
29 static int dmaInProgress = 0;\r
30 // used when transferring > MAX_DMA_BYTES.\r
31 static uint8_t* dmaBuffer = NULL;\r
32 static uint32_t dmaSentCount = 0;\r
33 static uint32_t dmaTotalCount = 0;\r
34 \r
35 static uint8 scsiDmaRxChan = CY_DMA_INVALID_CHANNEL;\r
36 static uint8 scsiDmaTxChan = CY_DMA_INVALID_CHANNEL;\r
37 \r
38 // DMA descriptors\r
39 static uint8 scsiDmaRxTd[1] = { CY_DMA_INVALID_TD };\r
40 static uint8 scsiDmaTxTd[1] = { CY_DMA_INVALID_TD };\r
41 \r
42 // Source of dummy bytes for DMA reads\r
43 static uint8 dummyBuffer = 0xFF;\r
44 \r
45 volatile static uint8 rxDMAComplete;\r
46 volatile static uint8 txDMAComplete;\r
47 \r
48 CY_ISR_PROTO(scsiRxCompleteISR);\r
49 CY_ISR(scsiRxCompleteISR)\r
50 {\r
51         rxDMAComplete = 1;\r
52 }\r
53 \r
54 CY_ISR_PROTO(scsiTxCompleteISR);\r
55 CY_ISR(scsiTxCompleteISR)\r
56 {\r
57         txDMAComplete = 1;\r
58 }\r
59 \r
60 CY_ISR_PROTO(scsiResetISR);\r
61 CY_ISR(scsiResetISR)\r
62 {\r
63         scsiDev.resetFlag = 1;\r
64         SCSI_RST_ClearInterrupt();\r
65 }\r
66 \r
67 uint8_t\r
68 scsiReadDBxPins()\r
69 {\r
70         return\r
71                 (SCSI_ReadPin(SCSI_In_DBx_DB7) << 7) |\r
72                 (SCSI_ReadPin(SCSI_In_DBx_DB6) << 6) |\r
73                 (SCSI_ReadPin(SCSI_In_DBx_DB5) << 5) |\r
74                 (SCSI_ReadPin(SCSI_In_DBx_DB4) << 4) |\r
75                 (SCSI_ReadPin(SCSI_In_DBx_DB3) << 3) |\r
76                 (SCSI_ReadPin(SCSI_In_DBx_DB2) << 2) |\r
77                 (SCSI_ReadPin(SCSI_In_DBx_DB1) << 1) |\r
78                 SCSI_ReadPin(SCSI_In_DBx_DB0);\r
79 }\r
80 \r
81 uint8_t\r
82 scsiReadByte(void)\r
83 {\r
84         while (scsiPhyTxFifoFull() && !scsiDev.resetFlag) {}\r
85         scsiPhyTx(0);\r
86 \r
87         while (scsiPhyRxFifoEmpty() && !scsiDev.resetFlag) {}\r
88         uint8_t val = scsiPhyRx();\r
89         scsiDev.parityError = scsiDev.parityError || SCSI_Parity_Error_Read();\r
90 \r
91         while (!(scsiPhyStatus() & SCSI_PHY_TX_COMPLETE) && !scsiDev.resetFlag) {}\r
92 \r
93         return val;\r
94 }\r
95 \r
96 static void\r
97 scsiReadPIO(uint8* data, uint32 count)\r
98 {\r
99         int prep = 0;\r
100         int i = 0;\r
101 \r
102         while (i < count && !scsiDev.resetFlag)\r
103         {\r
104                 uint8_t status = scsiPhyStatus();\r
105 \r
106                 if (prep < count && (status & SCSI_PHY_TX_FIFO_NOT_FULL))\r
107                 {\r
108                         scsiPhyTx(0);\r
109                         ++prep;\r
110                 }\r
111                 if (status & SCSI_PHY_RX_FIFO_NOT_EMPTY)\r
112                 {\r
113                         data[i] = scsiPhyRx();\r
114                         ++i;\r
115                 }\r
116         }\r
117         scsiDev.parityError = scsiDev.parityError || SCSI_Parity_Error_Read();\r
118         while (!(scsiPhyStatus() & SCSI_PHY_TX_COMPLETE) && !scsiDev.resetFlag) {}\r
119 }\r
120 \r
121 static void\r
122 doRxSingleDMA(uint8* data, uint32 count)\r
123 {\r
124         // Prepare DMA transfer\r
125         dmaInProgress = 1;\r
126 \r
127         CyDmaTdSetConfiguration(\r
128                 scsiDmaTxTd[0],\r
129                 count,\r
130                 CY_DMA_DISABLE_TD, // Disable the DMA channel when TD completes count bytes\r
131                 SCSI_TX_DMA__TD_TERMOUT_EN // Trigger interrupt when complete\r
132                 );\r
133         CyDmaTdSetConfiguration(\r
134                 scsiDmaRxTd[0],\r
135                 count,\r
136                 CY_DMA_DISABLE_TD, // Disable the DMA channel when TD completes count bytes\r
137                 TD_INC_DST_ADR |\r
138                         SCSI_RX_DMA__TD_TERMOUT_EN // Trigger interrupt when complete\r
139                 );\r
140         \r
141         CyDmaTdSetAddress(\r
142                 scsiDmaTxTd[0],\r
143                 LO16((uint32)&dummyBuffer),\r
144                 LO16((uint32)scsiTarget_datapath__F0_REG));\r
145         CyDmaTdSetAddress(\r
146                 scsiDmaRxTd[0],\r
147                 LO16((uint32)scsiTarget_datapath__F1_REG),\r
148                 LO16((uint32)data)\r
149                 );\r
150         \r
151         CyDmaChSetInitialTd(scsiDmaTxChan, scsiDmaTxTd[0]);\r
152         CyDmaChSetInitialTd(scsiDmaRxChan, scsiDmaRxTd[0]);\r
153         \r
154         // The DMA controller is a bit trigger-happy. It will retain\r
155         // a drq request that was triggered while the channel was\r
156         // disabled.\r
157         CyDmaClearPendingDrq(scsiDmaTxChan);\r
158         CyDmaClearPendingDrq(scsiDmaRxChan);\r
159 \r
160         txDMAComplete = 0;\r
161         rxDMAComplete = 0;\r
162 \r
163         CyDmaChEnable(scsiDmaRxChan, 1);\r
164         CyDmaChEnable(scsiDmaTxChan, 1);\r
165 }\r
166 \r
167 void\r
168 scsiReadDMA(uint8* data, uint32 count)\r
169 {\r
170         dmaSentCount = 0;\r
171         dmaTotalCount = count;\r
172         dmaBuffer = data;\r
173 \r
174         uint32_t singleCount = (count > MAX_DMA_BYTES) ? MAX_DMA_BYTES : count;\r
175         doRxSingleDMA(data, singleCount);\r
176         dmaSentCount += count;\r
177 }\r
178 \r
179 int\r
180 scsiReadDMAPoll()\r
181 {\r
182         if (txDMAComplete && rxDMAComplete && (scsiPhyStatus() & SCSI_PHY_TX_COMPLETE))\r
183         {\r
184                 if (dmaSentCount == dmaTotalCount)\r
185                 {\r
186                         dmaInProgress = 0;\r
187                         scsiDev.parityError = scsiDev.parityError || SCSI_Parity_Error_Read();\r
188                         return 1;\r
189                 }\r
190                 else\r
191                 {\r
192                         // Transfer was too large for a single DMA transfer. Continue\r
193                         // to send remaining bytes.\r
194                         uint32_t count = dmaTotalCount - dmaSentCount;\r
195                         if (count > MAX_DMA_BYTES) count = MAX_DMA_BYTES;\r
196                         doRxSingleDMA(dmaBuffer + dmaSentCount, count);\r
197                         dmaSentCount += count;\r
198                         return 0;\r
199                 }\r
200         }\r
201         else\r
202         {\r
203                 return 0;\r
204         }\r
205 }\r
206 \r
207 void\r
208 scsiRead(uint8_t* data, uint32_t count)\r
209 {\r
210         if (count < 8)\r
211         {\r
212                 scsiReadPIO(data, count);\r
213         }\r
214         else\r
215         {\r
216                 scsiReadDMA(data, count);\r
217                 while (!scsiReadDMAPoll() && !scsiDev.resetFlag) {};\r
218         }\r
219 }\r
220 \r
221 void\r
222 scsiWriteByte(uint8 value)\r
223 {\r
224         while (scsiPhyTxFifoFull() && !scsiDev.resetFlag) {}\r
225         scsiPhyTx(value);\r
226 \r
227         while (!(scsiPhyStatus() & SCSI_PHY_TX_COMPLETE) && !scsiDev.resetFlag) {}\r
228         scsiPhyRxFifoClear();\r
229 }\r
230 \r
231 static void\r
232 scsiWritePIO(uint8_t* data, uint32_t count)\r
233 {\r
234         int i = 0;\r
235 \r
236         while (i < count && !scsiDev.resetFlag)\r
237         {\r
238                 if (!scsiPhyTxFifoFull())\r
239                 {\r
240                         scsiPhyTx(data[i]);\r
241                         ++i;\r
242                 }\r
243         }\r
244 \r
245         while (!(scsiPhyStatus() & SCSI_PHY_TX_COMPLETE) && !scsiDev.resetFlag) {}\r
246         scsiPhyRxFifoClear();\r
247 }\r
248 \r
249 static void\r
250 doTxSingleDMA(uint8* data, uint32 count)\r
251 {\r
252         // Prepare DMA transfer\r
253         dmaInProgress = 1;\r
254 \r
255         CyDmaTdSetConfiguration(\r
256                 scsiDmaTxTd[0],\r
257                 count,\r
258                 CY_DMA_DISABLE_TD, // Disable the DMA channel when TD completes count bytes\r
259                 TD_INC_SRC_ADR |\r
260                         SCSI_TX_DMA__TD_TERMOUT_EN // Trigger interrupt when complete\r
261                 );\r
262         CyDmaTdSetAddress(\r
263                 scsiDmaTxTd[0],\r
264                 LO16((uint32)data),\r
265                 LO16((uint32)scsiTarget_datapath__F0_REG));\r
266         CyDmaChSetInitialTd(scsiDmaTxChan, scsiDmaTxTd[0]);\r
267 \r
268         // The DMA controller is a bit trigger-happy. It will retain\r
269         // a drq request that was triggered while the channel was\r
270         // disabled.\r
271         CyDmaClearPendingDrq(scsiDmaTxChan);\r
272 \r
273         txDMAComplete = 0;\r
274         rxDMAComplete = 1;\r
275 \r
276         CyDmaChEnable(scsiDmaTxChan, 1);\r
277 }\r
278 \r
279 void\r
280 scsiWriteDMA(uint8* data, uint32 count)\r
281 {\r
282         dmaSentCount = 0;\r
283         dmaTotalCount = count;\r
284         dmaBuffer = data;\r
285 \r
286         uint32_t singleCount = (count > MAX_DMA_BYTES) ? MAX_DMA_BYTES : count;\r
287         doTxSingleDMA(data, singleCount);\r
288         dmaSentCount += count;\r
289 }\r
290 \r
291 int\r
292 scsiWriteDMAPoll()\r
293 {\r
294         if (txDMAComplete && (scsiPhyStatus() & SCSI_PHY_TX_COMPLETE))\r
295         {\r
296                 if (dmaSentCount == dmaTotalCount)\r
297                 {\r
298                         scsiPhyRxFifoClear();\r
299                         dmaInProgress = 0;\r
300                         return 1;\r
301                 }\r
302                 else\r
303                 {\r
304                         // Transfer was too large for a single DMA transfer. Continue\r
305                         // to send remaining bytes.\r
306                         uint32_t count = dmaTotalCount - dmaSentCount;\r
307                         if (count > MAX_DMA_BYTES) count = MAX_DMA_BYTES;\r
308                         doTxSingleDMA(dmaBuffer + dmaSentCount, count);\r
309                         dmaSentCount += count;\r
310                         return 0;\r
311                 }\r
312         }\r
313         else\r
314         {\r
315                 return 0;\r
316         }\r
317 }\r
318 \r
319 void\r
320 scsiWrite(uint8_t* data, uint32_t count)\r
321 {\r
322         if (count < 8)\r
323         {\r
324                 scsiWritePIO(data, count);\r
325         }\r
326         else\r
327         {\r
328                 scsiWriteDMA(data, count);\r
329                 while (!scsiWriteDMAPoll() && !scsiDev.resetFlag) {};\r
330         }\r
331 }\r
332 \r
333 static void busSettleDelay(void)\r
334 {\r
335         // Data Release time (switching IO) = 400ns\r
336         // + Bus Settle time (switching phase) = 400ns.\r
337         CyDelayUs(1); // Close enough.\r
338 }\r
339 \r
340 void scsiEnterPhase(int phase)\r
341 {\r
342         int newPhase = phase > 0 ? phase : 0;\r
343         if (newPhase != SCSI_CTL_PHASE_Read())\r
344         {\r
345                 SCSI_CTL_PHASE_Write(phase > 0 ? phase : 0);\r
346                 busSettleDelay();\r
347         }\r
348 }\r
349 \r
350 void scsiPhyReset()\r
351 {\r
352         if (dmaInProgress)\r
353         {\r
354                 dmaInProgress = 0;\r
355                 dmaBuffer = NULL;\r
356                 dmaSentCount = 0;\r
357                 dmaTotalCount = 0;\r
358                 CyDmaChSetRequest(scsiDmaTxChan, CY_DMA_CPU_TERM_CHAIN);\r
359                 CyDmaChSetRequest(scsiDmaRxChan, CY_DMA_CPU_TERM_CHAIN);\r
360                 while (!(txDMAComplete && rxDMAComplete)) {}\r
361 \r
362                 CyDmaChDisable(scsiDmaTxChan);\r
363                 CyDmaChDisable(scsiDmaRxChan);\r
364         }\r
365 \r
366         // Set the Clear bits for both SCSI device FIFOs\r
367         scsiTarget_AUX_CTL = scsiTarget_AUX_CTL | 0x03;\r
368 \r
369         // Trigger RST outselves.  It is connected to the datapath and will\r
370         // ensure it returns to the idle state.  The datapath runs at the BUS clk\r
371         // speed (ie. same as the CPU), so we can be sure it is active for a sufficient\r
372         // duration.\r
373         SCSI_SetPin(SCSI_Out_RST);\r
374 \r
375         SCSI_CTL_PHASE_Write(0);\r
376         SCSI_ClearPin(SCSI_Out_ATN);\r
377         SCSI_ClearPin(SCSI_Out_BSY);\r
378         SCSI_ClearPin(SCSI_Out_ACK);\r
379         SCSI_ClearPin(SCSI_Out_RST);\r
380         SCSI_ClearPin(SCSI_Out_SEL);\r
381         SCSI_ClearPin(SCSI_Out_REQ);\r
382 \r
383         // Allow the FIFOs to fill up again.\r
384         SCSI_ClearPin(SCSI_Out_RST);\r
385         scsiTarget_AUX_CTL = scsiTarget_AUX_CTL & ~(0x03);\r
386 \r
387         SCSI_Parity_Error_Read(); // clear sticky bits\r
388 }\r
389 \r
390 static void scsiPhyInitDMA()\r
391 {\r
392         // One-time init only.\r
393         if (scsiDmaTxChan == CY_DMA_INVALID_CHANNEL)\r
394         {\r
395                 scsiDmaRxChan =\r
396                         SCSI_RX_DMA_DmaInitialize(\r
397                                 1, // Bytes per burst\r
398                                 1, // request per burst\r
399                                 HI16(CYDEV_PERIPH_BASE),\r
400                                 HI16(CYDEV_SRAM_BASE)\r
401                                 );\r
402 \r
403                 scsiDmaTxChan =\r
404                         SCSI_TX_DMA_DmaInitialize(\r
405                                 1, // Bytes per burst\r
406                                 1, // request per burst\r
407                                 HI16(CYDEV_SRAM_BASE),\r
408                                 HI16(CYDEV_PERIPH_BASE)\r
409                                 );\r
410 \r
411                 CyDmaChDisable(scsiDmaRxChan);\r
412                 CyDmaChDisable(scsiDmaTxChan);\r
413 \r
414                 scsiDmaRxTd[0] = CyDmaTdAllocate();\r
415                 scsiDmaTxTd[0] = CyDmaTdAllocate();\r
416 \r
417                 SCSI_RX_DMA_COMPLETE_StartEx(scsiRxCompleteISR);\r
418                 SCSI_TX_DMA_COMPLETE_StartEx(scsiTxCompleteISR);\r
419         }\r
420 }\r
421 \r
422 \r
423 void scsiPhyInit()\r
424 {\r
425         scsiPhyInitDMA();\r
426 \r
427         SCSI_RST_ISR_StartEx(scsiResetISR);\r
428 \r
429         // Interrupts may have already been directed to the (empty)\r
430         // standard ISR generated by PSoC Creator.\r
431         SCSI_RST_ClearInterrupt();\r
432 }\r