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