OpenCores
URL https://opencores.org/ocsvn/usb_ft232h_avalon-mm_interface/usb_ft232h_avalon-mm_interface/trunk

Subversion Repositories usb_ft232h_avalon-mm_interface

[/] [usb_ft232h_avalon-mm_interface/] [trunk/] [testbench/] [altera_project/] [test_usb_ft232h/] [software/] [usb_ft232h/] [main.cpp] - Blame information for rev 6

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 6 melman701 
/*
2 
 * main.cpp
3 
 *
4 
 *  Created on: 14 ����� 2017 �.
5 
 *      Author: EDV
6 
 */
7 
 
8 
#include <inttypes.h>
9 
#include <stdlib.h>
10 
#include <stdio.h>
11 
 
12 
#include "system.h"
13 
#include "altera_avalon_dma_regs.h"
14 
#include "altera_avalon_pio_regs.h"
15 
 
16 
#include "usb_ft232h.h"
17 
 
18 
 
19 
 
20 
 
21 
const alt_u32 DMA_USB_TX_BASE = DMA_TX_BASE;
22 
const alt_u32 DMA_USB_RX_BASE = DMA_RX_BASE;
23 
const alt_u32 USB_FT232H_BASE = USB_BASE;
24 
 
25 
const alt_u16 USB_TX_FIFO_SIZE = 2048;
26 
const alt_u16 USB_RX_FIFO_SIZE = 1024;
27 
const alt_u16 BUFFER_SIZE = 2048;
28 
const alt_u16 MIN_TRANSACTION_SIZE = 128;
29 
const alt_u16 TRANSACTION_SIZE = 1024;
30 
 
31 
 
32 
enum TestMode {
33 
    TM_READ = 1,
34 
    TM_ECHO
35 
};
36 
 
37 
 
38 
uint8_t txBuffer[BUFFER_SIZE];
39 
uint16_t txBufferHead = 0;
40 
uint16_t txFree = 0;
41 
uint8_t rxBuffer[BUFFER_SIZE];
42 
uint16_t rxBufferTail = 0;
43 
uint16_t rxCount = 0;
44 
uint16_t ret = 0;
45 
 
46 
uint32_t targetSize = 0;
47 
 
48 
uint32_t receivedSize = 0;
49 
uint32_t sendedSize = 0;
50 
 
51 
uint16_t bytesRead = 0, bytesWrite = 0;
52 
 
53 
uint32_t ledDivider = 0;
54 
 
55 
 
56 
 
57 
void init() {
58 
        IOWR_ALTERA_AVALON_DMA_RADDRESS(DMA_USB_RX_BASE, USB_FT232H_RDDATA_ADDR);
59 
        IOWR_ALTERA_AVALON_DMA_WADDRESS(DMA_USB_TX_BASE, USB_FT232H_WRDATA_ADDR);
60 
}
61 
 
62 
 
63 
uint16_t getRxDataCount() {
64 
        return IORD_USB_FT232H_RXDATA_COUNT(USB_FT232H_BASE);
65 
//      return IORD_16DIRECT(USB_FT232H_BASE, USB_FT232H_RXSTATUSL_ADDR) & USB_FT232H_STATUS_COUNT_MSK;
66 
}
67 
 
68 
uint16_t getTxFreeSpace() {
69 
        return (USB_TX_FIFO_SIZE - IORD_USB_FT232H_TXDATA_COUNT(USB_FT232H_BASE));
70 
}
71 
 
72 
uint8_t readByte() {
73 
        return IORD_USB_FT232H_DATA(USB_FT232H_BASE);
74 
}
75 
 
76 
void writeByte(uint8_t byte) {
77 
        IOWR_USB_FT232H_DATA(USB_FT232H_BASE, byte);
78 
}
79 
 
80 
inline
81 
void readData(uint8_t *buffer, uint16_t size)
82 
{
83 
        for (uint16_t i = 0; i < size; ++i) {
84 
                buffer[i] = readByte();
85 
        }
86 
}
87 
 
88 
inline
89 
uint16_t readDataDMA(void *buffer, uint16_t size) {
90 
        alt_u32 status;
91 
        IOWR_ALTERA_AVALON_DMA_STATUS(DMA_USB_RX_BASE, 0);
92 
        IOWR_ALTERA_AVALON_DMA_CONTROL(DMA_USB_RX_BASE, 0x1E1); //����� ��������� � �����������, � ����� ������, �� ���� ����� �����
93 
        IOWR_ALTERA_AVALON_DMA_WADDRESS(DMA_USB_RX_BASE, reinterpret_cast<uint32_t>(buffer));
94 
        IOWR_ALTERA_AVALON_DMA_LENGTH(DMA_USB_RX_BASE, size);
95 
        IOWR_ALTERA_AVALON_DMA_CONTROL(DMA_USB_RX_BASE, 0x1E9); // ���������
96 
        do {
97 
                status = IORD_ALTERA_AVALON_DMA_STATUS(DMA_USB_RX_BASE);
98 
        } while (status & ALTERA_AVALON_DMA_STATUS_BUSY_MSK);
99 
        return IORD_ALTERA_AVALON_DMA_LENGTH(DMA_USB_RX_BASE);
100 
}
101 
 
102 
inline
103 
void writeData(const uint8_t *data, uint16_t size)
104 
{
105 
        for (uint16_t i = 0; i < size; ++i)
106 
                writeByte(data[i]);
107 
}
108 
 
109 
inline
110 
uint16_t writeDataDMA(void *data, uint16_t size) {
111 
        alt_u32 status;
112 
        IOWR_ALTERA_AVALON_DMA_STATUS(DMA_USB_TX_BASE, 0);
113 
        IOWR_ALTERA_AVALON_DMA_CONTROL(DMA_USB_TX_BASE, 0x2E1); //����� ��������� � �����������, � ����� ������, �� ���� ����� �����
114 
        IOWR_ALTERA_AVALON_DMA_RADDRESS(DMA_USB_TX_BASE, reinterpret_cast<uint32_t>(data));
115 
        IOWR_ALTERA_AVALON_DMA_LENGTH(DMA_USB_TX_BASE, size);
116 
        IOWR_ALTERA_AVALON_DMA_CONTROL(DMA_USB_TX_BASE, 0x2E9);
117 
        do {
118 
                status = IORD_ALTERA_AVALON_DMA_STATUS(DMA_USB_TX_BASE);
119 
        } while (status & ALTERA_AVALON_DMA_STATUS_BUSY_MSK);
120 
        return IORD_ALTERA_AVALON_DMA_LENGTH(DMA_USB_TX_BASE);
121 
}
122 
 
123 
void transmitMode() {
124 
        puts("Transmit mode");
125 
        while(true) {
126 
                txFree = getTxFreeSpace();
127 
                if(txFree >= TRANSACTION_SIZE) {
128 
                        ret = writeDataDMA(&txBuffer[txBufferHead], TRANSACTION_SIZE);
129 
//                      writeData(&txBuffer[txBufferHead], TRANSACTION_SIZE);
130 
                        txBufferHead += TRANSACTION_SIZE;
131 
                        if(txBufferHead >= BUFFER_SIZE) {
132 
                                txBufferHead = 0;
133 
                        }
134 
                }
135 
        }
136 
}
137 
 
138 
void echoMode() {
139 
        rxCount = 0;
140 
        receivedSize = 0;
141 
        sendedSize = 0;
142 
 
143 
        readData(reinterpret_cast<uint8_t *>(&targetSize), 4);
144 
//      printf("Echo mode. %ld\n", targetSize);
145 
 
146 
        while ((receivedSize < targetSize) || (sendedSize < targetSize)) {
147 
                if (rxCount) {
148 
                        txFree = getTxFreeSpace();
149 
                        if (txFree >= rxCount) {
150 
//                              puts("send");
151 
//                              writeData(rxBuffer, rxCount);
152 
                                bytesWrite = writeDataDMA(rxBuffer, rxCount);
153 
                                if (bytesWrite) {
154 
                                        puts("Write error");
155 
                                }
156 
                                sendedSize += rxCount;
157 
                                if (sendedSize > targetSize) {
158 
//                                      printf("Too much tx data. %ld\n", sendedSize - targetSize);
159 
                                }
160 
                                rxCount = 0;
161 
                        }
162 
                }
163 
                else {
164 
                        rxCount = getRxDataCount();
165 
                        if (rxCount >= TRANSACTION_SIZE) {
166 
//                              puts("get");
167 
                                rxCount = TRANSACTION_SIZE;
168 
//                              readData(rxBuffer, rxCount);
169 
                                bytesRead = readDataDMA(rxBuffer, rxCount);
170 
                                if (bytesRead) {
171 
                                        puts("Read error");
172 
                                }
173 
                                receivedSize += rxCount;
174 
                                if (receivedSize > targetSize) {
175 
//                                      printf("Too much rx data. %ld\n", receivedSize - targetSize);
176 
//                                      return;
177 
                                }
178 
                        }
179 
                        else {
180 
                                rxCount = 0;
181 
                        }
182 
                }
183 
 
184 
                ++ledDivider;
185 
                if (ledDivider == 50000) {
186 
                        IOWR_ALTERA_AVALON_PIO_DATA(LED_BASE, 0x1);
187 
                }
188 
                else if (ledDivider == 100000) {
189 
                        IOWR_ALTERA_AVALON_PIO_DATA(LED_BASE, 0x0);
190 
                        ledDivider = 0;
191 
                }
192 
        }
193 
//      printf("Finish. Target size: %ld Received size: %ld Sended size: %ld Rx FIFO status: %ld\n", targetSize, receivedSize, sendedSize, getRxDataCount());
194 
}
195 
 
196 
int main() {
197 
        init();
198 
 
199 
        uint8_t byte;
200 
 
201 
        for(int i=0; i<BUFFER_SIZE; i++) {
202 
                txBuffer[i] = i & 0xFF;
203 
        }
204 
 
205 
        printf("Hello\n");
206 
 
207 
        while (true) {
208 
                rxCount = getRxDataCount();
209 
                if (rxCount) {
210 
                        byte = readByte();
211 
//                      puts("kkd");
212 
                        printf("Read %d\n", byte);
213 
                        switch (byte) {
214 
                        case TM_READ:
215 
                                transmitMode();
216 
                                break;
217 
                        case TM_ECHO:
218 
                                echoMode();
219 
                                break;
220 
                        default:
221 
                                break;
222 
                        }
223 
                }
224 
        }
225 
 
226 
        /*while (true) {
227 
                rxCount = getRxDataCount();
228 
                if (rxCount) {
229 
                        byte = readByte();
230 
                        printf("Read %d\n", byte);
231 
                        if (byte)
232 
                                break;
233 
                }
234 
        }
235 
        if(--rxCount)
236 
                readDataDMA(rxBuffer, rxCount);
237 
//      byte = WMODE_ECHO;
238 
 
239 
        switch (byte) {
240 
                case TM_READ:
241 
                        transmitMode();
242 
                        break;
243 
                case TM_ECHO:
244 
                        echoMode();
245 
                        break;
246 
                default:
247 
                        break;
248 
        }*/
249 
 
250 
        return 0;
251 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.