Merge PCB updates
[SCSI2SD.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 }\r
65 \r
66 uint8_t\r
67 scsiReadDBxPins()\r
68 {\r
69         return\r
70                 (SCSI_ReadPin(SCSI_In_DBx_DB7) << 7) |\r
71                 (SCSI_ReadPin(SCSI_In_DBx_DB6) << 6) |\r
72                 (SCSI_ReadPin(SCSI_In_DBx_DB5) << 5) |\r
73                 (SCSI_ReadPin(SCSI_In_DBx_DB4) << 4) |\r
74                 (SCSI_ReadPin(SCSI_In_DBx_DB3) << 3) |\r
75                 (SCSI_ReadPin(SCSI_In_DBx_DB2) << 2) |\r
76                 (SCSI_ReadPin(SCSI_In_DBx_DB1) << 1) |\r
77                 SCSI_ReadPin(SCSI_In_DBx_DB0);\r
78 }\r
79 \r
80 uint8_t\r
81 scsiReadByte(void)\r
82 {\r
83         while (scsiPhyTxFifoFull() && !scsiDev.resetFlag) {}\r
84         scsiPhyTx(0);\r
85 \r
86         while (scsiPhyRxFifoEmpty() && !scsiDev.resetFlag) {}\r
87         uint8_t val = scsiPhyRx();\r
88         scsiDev.parityError = scsiDev.parityError || SCSI_Parity_Error_Read();\r
89 \r
90         while (!(scsiPhyStatus() & SCSI_PHY_TX_COMPLETE) && !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         scsiDev.parityError = scsiDev.parityError || SCSI_Parity_Error_Read();\r
117         while (!(scsiPhyStatus() & SCSI_PHY_TX_COMPLETE) && !scsiDev.resetFlag) {}\r
118 }\r
119 \r
120 static void\r
121 doRxSingleDMA(uint8* data, uint32 count)\r
122 {\r
123         // Prepare DMA transfer\r
124         dmaInProgress = 1;\r
125 \r
126         CyDmaTdSetConfiguration(\r
127                 scsiDmaTxTd[0],\r
128                 count,\r
129                 CY_DMA_DISABLE_TD, // Disable the DMA channel when TD completes count bytes\r
130                 SCSI_TX_DMA__TD_TERMOUT_EN // Trigger interrupt when complete\r
131                 );\r
132         CyDmaTdSetConfiguration(\r
133                 scsiDmaRxTd[0],\r
134                 count,\r
135                 CY_DMA_DISABLE_TD, // Disable the DMA channel when TD completes count bytes\r
136                 TD_INC_DST_ADR |\r
137                         SCSI_RX_DMA__TD_TERMOUT_EN // Trigger interrupt when complete\r
138                 );\r
139         \r
140         CyDmaTdSetAddress(\r
141                 scsiDmaTxTd[0],\r
142                 LO16((uint32)&dummyBuffer),\r
143                 LO16((uint32)scsiTarget_datapath__F0_REG));\r
144         CyDmaTdSetAddress(\r
145                 scsiDmaRxTd[0],\r
146                 LO16((uint32)scsiTarget_datapath__F1_REG),\r
147                 LO16((uint32)data)\r
148                 );\r
149         \r
150         CyDmaChSetInitialTd(scsiDmaTxChan, scsiDmaTxTd[0]);\r
151         CyDmaChSetInitialTd(scsiDmaRxChan, scsiDmaRxTd[0]);\r
152         \r
153         // The DMA controller is a bit trigger-happy. It will retain\r
154         // a drq request that was triggered while the channel was\r
155         // disabled.\r
156         CyDmaClearPendingDrq(scsiDmaTxChan);\r
157         CyDmaClearPendingDrq(scsiDmaRxChan);\r
158 \r
159         txDMAComplete = 0;\r
160         rxDMAComplete = 0;\r
161 \r
162         CyDmaChEnable(scsiDmaRxChan, 1);\r
163         CyDmaChEnable(scsiDmaTxChan, 1);\r
164 }\r
165 \r
166 void\r
167 scsiReadDMA(uint8* data, uint32 count)\r
168 {\r
169         dmaSentCount = 0;\r
170         dmaTotalCount = count;\r
171         dmaBuffer = data;\r
172 \r
173         uint32_t singleCount = (count > MAX_DMA_BYTES) ? MAX_DMA_BYTES : count;\r
174         doRxSingleDMA(data, singleCount);\r
175         dmaSentCount += count;\r
176 }\r
177 \r
178 int\r
179 scsiReadDMAPoll()\r
180 {\r
181         if (txDMAComplete && rxDMAComplete && (scsiPhyStatus() & SCSI_PHY_TX_COMPLETE))\r
182         {\r
183                 if (dmaSentCount == dmaTotalCount)\r
184                 {\r
185                         dmaInProgress = 0;\r
186                         scsiDev.parityError = scsiDev.parityError || SCSI_Parity_Error_Read();\r
187                         return 1;\r
188                 }\r
189                 else\r
190                 {\r
191                         // Transfer was too large for a single DMA transfer. Continue\r
192                         // to send remaining bytes.\r
193                         uint32_t count = dmaTotalCount - dmaSentCount;\r
194                         if (count > MAX_DMA_BYTES) count = MAX_DMA_BYTES;\r
195                         doRxSingleDMA(dmaBuffer + dmaSentCount, count);\r
196                         dmaSentCount += count;\r
197                         return 0;\r
198                 }\r
199         }\r
200         else\r
201         {\r
202                 return 0;\r
203         }\r
204 }\r
205 \r
206 void\r
207 scsiRead(uint8_t* data, uint32_t count)\r
208 {\r
209         if (count < 8)\r
210         {\r
211                 scsiReadPIO(data, count);\r
212         }\r
213         else\r
214         {\r
215                 scsiReadDMA(data, count);\r
216                 while (!scsiReadDMAPoll() && !scsiDev.resetFlag) {};\r
217         }\r
218 }\r
219 \r
220 void\r
221 scsiWriteByte(uint8 value)\r
222 {\r
223         while (scsiPhyTxFifoFull() && !scsiDev.resetFlag) {}\r
224         scsiPhyTx(value);\r
225 \r
226         while (!(scsiPhyStatus() & SCSI_PHY_TX_COMPLETE) && !scsiDev.resetFlag) {}\r
227         scsiPhyRxFifoClear();\r
228 }\r
229 \r
230 static void\r
231 scsiWritePIO(uint8_t* data, uint32_t count)\r
232 {\r
233         int i = 0;\r
234 \r
235         while (i < count && !scsiDev.resetFlag)\r
236         {\r
237                 if (!scsiPhyTxFifoFull())\r
238                 {\r
239                         scsiPhyTx(data[i]);\r
240                         ++i;\r
241                 }\r
242         }\r
243 \r
244         while (!(scsiPhyStatus() & SCSI_PHY_TX_COMPLETE) && !scsiDev.resetFlag) {}\r
245         scsiPhyRxFifoClear();\r
246 }\r
247 \r
248 static void\r
249 doTxSingleDMA(uint8* data, uint32 count)\r
250 {\r
251         // Prepare DMA transfer\r
252         dmaInProgress = 1;\r
253 \r
254         CyDmaTdSetConfiguration(\r
255                 scsiDmaTxTd[0],\r
256                 count,\r
257                 CY_DMA_DISABLE_TD, // Disable the DMA channel when TD completes count bytes\r
258                 TD_INC_SRC_ADR |\r
259                         SCSI_TX_DMA__TD_TERMOUT_EN // Trigger interrupt when complete\r
260                 );\r
261         CyDmaTdSetAddress(\r
262                 scsiDmaTxTd[0],\r
263                 LO16((uint32)data),\r
264                 LO16((uint32)scsiTarget_datapath__F0_REG));\r
265         CyDmaChSetInitialTd(scsiDmaTxChan, scsiDmaTxTd[0]);\r
266 \r
267         // The DMA controller is a bit trigger-happy. It will retain\r
268         // a drq request that was triggered while the channel was\r
269         // disabled.\r
270         CyDmaClearPendingDrq(scsiDmaTxChan);\r
271 \r
272         txDMAComplete = 0;\r
273         rxDMAComplete = 1;\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                         return 1;\r
300                 }\r
301                 else\r
302                 {\r
303                         // Transfer was too large for a single DMA transfer. Continue\r
304                         // to send remaining bytes.\r
305                         uint32_t count = dmaTotalCount - dmaSentCount;\r
306                         if (count > MAX_DMA_BYTES) count = MAX_DMA_BYTES;\r
307                         doTxSingleDMA(dmaBuffer + dmaSentCount, count);\r
308                         dmaSentCount += count;\r
309                         return 0;\r
310                 }\r
311         }\r
312         else\r
313         {\r
314                 return 0;\r
315         }\r
316 }\r
317 \r
318 void\r
319 scsiWrite(uint8_t* data, uint32_t count)\r
320 {\r
321         if (count < 8)\r
322         {\r
323                 scsiWritePIO(data, count);\r
324         }\r
325         else\r
326         {\r
327                 scsiWriteDMA(data, count);\r
328                 while (!scsiWriteDMAPoll() && !scsiDev.resetFlag) {};\r
329         }\r
330 }\r
331 \r
332 static void busSettleDelay(void)\r
333 {\r
334         // Data Release time (switching IO) = 400ns\r
335         // + Bus Settle time (switching phase) = 400ns.\r
336         CyDelayUs(1); // Close enough.\r
337 }\r
338 \r
339 void scsiEnterPhase(int phase)\r
340 {\r
341         int newPhase = phase > 0 ? phase : 0;\r
342         if (newPhase != SCSI_CTL_PHASE_Read())\r
343         {\r
344                 SCSI_CTL_PHASE_Write(phase > 0 ? phase : 0);\r
345                 busSettleDelay();\r
346         }\r
347 }\r
348 \r
349 void scsiPhyReset()\r
350 {\r
351         if (dmaInProgress)\r
352         {\r
353                 dmaInProgress = 0;\r
354                 dmaBuffer = NULL;\r
355                 dmaSentCount = 0;\r
356                 dmaTotalCount = 0;\r
357                 CyDmaChSetRequest(scsiDmaTxChan, CY_DMA_CPU_TERM_CHAIN);\r
358                 CyDmaChSetRequest(scsiDmaRxChan, CY_DMA_CPU_TERM_CHAIN);\r
359                 while (!(txDMAComplete && rxDMAComplete)) {}\r
360 \r
361                 CyDmaChDisable(scsiDmaTxChan);\r
362                 CyDmaChDisable(scsiDmaRxChan);\r
363         }\r
364 \r
365         // Set the Clear bits for both SCSI device FIFOs\r
366         scsiTarget_AUX_CTL = scsiTarget_AUX_CTL | 0x03;\r
367 \r
368         // Trigger RST outselves.  It is connected to the datapath and will\r
369         // ensure it returns to the idle state.  The datapath runs at the BUS clk\r
370         // speed (ie. same as the CPU), so we can be sure it is active for a sufficient\r
371         // duration.\r
372         SCSI_SetPin(SCSI_Out_RST);\r
373 \r
374         SCSI_CTL_PHASE_Write(0);\r
375         SCSI_ClearPin(SCSI_Out_ATN);\r
376         SCSI_ClearPin(SCSI_Out_BSY);\r
377         SCSI_ClearPin(SCSI_Out_ACK);\r
378         SCSI_ClearPin(SCSI_Out_RST);\r
379         SCSI_ClearPin(SCSI_Out_SEL);\r
380         SCSI_ClearPin(SCSI_Out_REQ);\r
381 \r
382         // Allow the FIFOs to fill up again.\r
383         SCSI_ClearPin(SCSI_Out_RST);\r
384         scsiTarget_AUX_CTL = scsiTarget_AUX_CTL & ~(0x03);\r
385 \r
386         SCSI_Parity_Error_Read(); // clear sticky bits\r
387 }\r
388 \r
389 static void scsiPhyInitDMA()\r
390 {\r
391         // One-time init only.\r
392         if (scsiDmaTxChan == CY_DMA_INVALID_CHANNEL)\r
393         {\r
394                 scsiDmaRxChan =\r
395                         SCSI_RX_DMA_DmaInitialize(\r
396                                 1, // Bytes per burst\r
397                                 1, // request per burst\r
398                                 HI16(CYDEV_PERIPH_BASE),\r
399                                 HI16(CYDEV_SRAM_BASE)\r
400                                 );\r
401 \r
402                 scsiDmaTxChan =\r
403                         SCSI_TX_DMA_DmaInitialize(\r
404                                 1, // Bytes per burst\r
405                                 1, // request per burst\r
406                                 HI16(CYDEV_SRAM_BASE),\r
407                                 HI16(CYDEV_PERIPH_BASE)\r
408                                 );\r
409 \r
410                 CyDmaChDisable(scsiDmaRxChan);\r
411                 CyDmaChDisable(scsiDmaTxChan);\r
412 \r
413                 scsiDmaRxTd[0] = CyDmaTdAllocate();\r
414                 scsiDmaTxTd[0] = CyDmaTdAllocate();\r
415 \r
416                 SCSI_RX_DMA_COMPLETE_StartEx(scsiRxCompleteISR);\r
417                 SCSI_TX_DMA_COMPLETE_StartEx(scsiTxCompleteISR);\r
418         }\r
419 }\r
420 \r
421 \r
422 void scsiPhyInit()\r
423 {\r
424         scsiPhyInitDMA();\r
425 \r
426         SCSI_RST_ISR_StartEx(scsiResetISR);\r
427 }\r