Use DMA for SCSI and SD card transfers for a massive performance boost.
[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 \r
90         while (SCSI_ReadPin(SCSI_In_ACK) && !scsiDev.resetFlag) {}\r
91 \r
92         return val;\r
93 }\r
94 \r
95 static void\r
96 scsiReadPIO(uint8* data, uint32 count)\r
97 {\r
98         int prep = 0;\r
99         int i = 0;\r
100 \r
101         while (i < count && !scsiDev.resetFlag)\r
102         {\r
103                 uint8_t status = scsiPhyStatus();\r
104 \r
105                 if (prep < count && (status & SCSI_PHY_TX_FIFO_NOT_FULL))\r
106                 {\r
107                         scsiPhyTx(0);\r
108                         ++prep;\r
109                 }\r
110                 if (status & SCSI_PHY_RX_FIFO_NOT_EMPTY)\r
111                 {\r
112                         data[i] = scsiPhyRx();\r
113                         ++i;\r
114                 }\r
115         }\r
116         while (SCSI_ReadPin(SCSI_In_ACK) && !scsiDev.resetFlag) {}\r
117 }\r
118 \r
119 static void\r
120 doRxSingleDMA(uint8* data, uint32 count)\r
121 {\r
122         // Prepare DMA transfer\r
123         dmaInProgress = 1;\r
124 \r
125         CyDmaTdSetConfiguration(\r
126                 scsiDmaTxTd[0],\r
127                 count,\r
128                 CY_DMA_DISABLE_TD, // Disable the DMA channel when TD completes count bytes\r
129                 SCSI_TX_DMA__TD_TERMOUT_EN // Trigger interrupt when complete\r
130                 );\r
131         CyDmaTdSetConfiguration(\r
132                 scsiDmaRxTd[0],\r
133                 count,\r
134                 CY_DMA_DISABLE_TD, // Disable the DMA channel when TD completes count bytes\r
135                 TD_INC_DST_ADR |\r
136                         SCSI_RX_DMA__TD_TERMOUT_EN // Trigger interrupt when complete\r
137                 );\r
138         \r
139         CyDmaTdSetAddress(\r
140                 scsiDmaTxTd[0],\r
141                 LO16((uint32)&dummyBuffer),\r
142                 LO16((uint32)scsiTarget_datapath__F0_REG));\r
143         CyDmaTdSetAddress(\r
144                 scsiDmaRxTd[0],\r
145                 LO16((uint32)scsiTarget_datapath__F1_REG),\r
146                 LO16((uint32)data)\r
147                 );\r
148         \r
149         CyDmaChSetInitialTd(scsiDmaTxChan, scsiDmaTxTd[0]);\r
150         CyDmaChSetInitialTd(scsiDmaRxChan, scsiDmaRxTd[0]);\r
151         \r
152         // The DMA controller is a bit trigger-happy. It will retain\r
153         // a drq request that was triggered while the channel was\r
154         // disabled.\r
155         CyDmaClearPendingDrq(scsiDmaTxChan);\r
156         CyDmaClearPendingDrq(scsiDmaRxChan);\r
157 \r
158         txDMAComplete = 0;\r
159         rxDMAComplete = 0;\r
160 \r
161         CyDmaChEnable(scsiDmaRxChan, 1);\r
162         CyDmaChEnable(scsiDmaTxChan, 1);\r
163 }\r
164 \r
165 void\r
166 scsiReadDMA(uint8* data, uint32 count)\r
167 {\r
168         dmaSentCount = 0;\r
169         dmaTotalCount = count;\r
170         dmaBuffer = data;\r
171 \r
172         uint32_t singleCount = (count > MAX_DMA_BYTES) ? MAX_DMA_BYTES : count;\r
173         doRxSingleDMA(data, singleCount);\r
174         dmaSentCount += count;\r
175 }\r
176 \r
177 int\r
178 scsiReadDMAPoll()\r
179 {\r
180         if (txDMAComplete && rxDMAComplete && (scsiPhyStatus() & SCSI_PHY_TX_COMPLETE))\r
181         {\r
182                 if (dmaSentCount == dmaTotalCount)\r
183                 {\r
184                         dmaInProgress = 0;\r
185                         while (SCSI_ReadPin(SCSI_In_ACK) && !scsiDev.resetFlag) {}\r
186                         return 1;\r
187                 }\r
188                 else\r
189                 {\r
190                         // Transfer was too large for a single DMA transfer. Continue\r
191                         // to send remaining bytes.\r
192                         uint32_t count = dmaTotalCount - dmaSentCount;\r
193                         if (count > MAX_DMA_BYTES) count = MAX_DMA_BYTES;\r
194                         doRxSingleDMA(dmaBuffer + dmaSentCount, count);\r
195                         dmaSentCount += count;\r
196                         return 0;\r
197                 }\r
198         }\r
199         else\r
200         {\r
201                 return 0;\r
202         }\r
203 }\r
204 \r
205 void\r
206 scsiRead(uint8_t* data, uint32_t count)\r
207 {\r
208         if (count < 8)\r
209         {\r
210                 scsiReadPIO(data, count);\r
211         }\r
212         else\r
213         {\r
214                 scsiReadDMA(data, count);\r
215                 while (!scsiReadDMAPoll() && !scsiDev.resetFlag) {};\r
216         }\r
217 }\r
218 \r
219 void\r
220 scsiWriteByte(uint8 value)\r
221 {\r
222         while (scsiPhyTxFifoFull() && !scsiDev.resetFlag) {}\r
223         scsiPhyTx(value);\r
224 \r
225         while (!(scsiPhyStatus() & SCSI_PHY_TX_COMPLETE) && !scsiDev.resetFlag) {}\r
226         scsiPhyRxFifoClear();\r
227 \r
228         while (SCSI_ReadPin(SCSI_In_ACK) && !scsiDev.resetFlag) {}\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 \r
275         CyDmaChEnable(scsiDmaTxChan, 1);\r
276 }\r
277 \r
278 void\r
279 scsiWriteDMA(uint8* data, uint32 count)\r
280 {\r
281         dmaSentCount = 0;\r
282         dmaTotalCount = count;\r
283         dmaBuffer = data;\r
284 \r
285         uint32_t singleCount = (count > MAX_DMA_BYTES) ? MAX_DMA_BYTES : count;\r
286         doTxSingleDMA(data, singleCount);\r
287         dmaSentCount += count;\r
288 }\r
289 \r
290 int\r
291 scsiWriteDMAPoll()\r
292 {\r
293         if (txDMAComplete && (scsiPhyStatus() & SCSI_PHY_TX_COMPLETE))\r
294         {\r
295                 if (dmaSentCount == dmaTotalCount)\r
296                 {\r
297                         scsiPhyRxFifoClear();\r
298                         dmaInProgress = 0;\r
299                         while (SCSI_ReadPin(SCSI_In_ACK) && !scsiDev.resetFlag) {}\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 \r
388 static void scsiPhyInitDMA()\r
389 {\r
390         // One-time init only.\r
391         if (scsiDmaTxChan == CY_DMA_INVALID_CHANNEL)\r
392         {\r
393                 scsiDmaRxChan =\r
394                         SCSI_RX_DMA_DmaInitialize(\r
395                                 1, // Bytes per burst\r
396                                 1, // request per burst\r
397                                 HI16(CYDEV_PERIPH_BASE),\r
398                                 HI16(CYDEV_SRAM_BASE)\r
399                                 );\r
400                         \r
401                 scsiDmaTxChan =\r
402                         SCSI_TX_DMA_DmaInitialize(\r
403                                 1, // Bytes per burst\r
404                                 1, // request per burst\r
405                                 HI16(CYDEV_SRAM_BASE),\r
406                                 HI16(CYDEV_PERIPH_BASE)\r
407                                 );\r
408 \r
409                 CyDmaChDisable(scsiDmaRxChan);\r
410                 CyDmaChDisable(scsiDmaTxChan);\r
411 \r
412                 scsiDmaRxTd[0] = CyDmaTdAllocate();\r
413                 scsiDmaTxTd[0] = CyDmaTdAllocate();\r
414                 \r
415                 SCSI_RX_DMA_COMPLETE_StartEx(scsiRxCompleteISR);\r
416                 SCSI_TX_DMA_COMPLETE_StartEx(scsiTxCompleteISR);\r
417         }\r
418 }\r
419 \r
420 \r
421 void scsiPhyInit()\r
422 {\r
423         scsiPhyInitDMA();\r
424 \r
425         SCSI_RST_ISR_StartEx(scsiResetISR);\r
426 \r
427         // Interrupts may have already been directed to the (empty)\r
428         // standard ISR generated by PSoC Creator.\r
429         SCSI_RST_ClearInterrupt();\r
430 }\r